nlqdb

Natural-language databases.

Create one in a word. Talk to it in English. The schema, the engine, the indexes, the backups — all invisible. The escape hatch to raw SQL stays one click away, always.

Built with an obsessive standard for user experience.

Spin up a database from a sentence.

Anonymous — no sign-in. Your DB lives 72h; sign in (always free) to keep it.

read

<nlq-data goal=""></nlq-data>

drink	orders	revenue
flat white	14	64.4
cortado	11	47.3
americano	9	35.1
cold brew	8	36.8
espresso	6	19.2
latte	4	18

today aggregated · sorted by revenue

SQL the engine ran

SELECT drink, COUNT(*) AS orders, ROUND(SUM(total), 2) AS revenue
  FROM orders
 WHERE created_at > date_trunc('day', now())
 GROUP BY drink
 ORDER BY revenue DESC;

create
CLI
```
nlq new ""
```
renders ↓
✓ created db_coffee · 1 table inferred

schema = orders(id, customer, drink, total, created_at)
SQL the engine ran
```
CREATE DATABASE db_coffee;
CREATE TABLE orders (id, customer, drink, total, created_at);
```
schema
CLI
```
nlq schema ""
```
renders ↓
✓ column added · 47 rows backfilled to default
SQL the engine ran
```
ALTER TABLE drinks
  ADD COLUMN allergens TEXT[] DEFAULT '{}';
```

read

curl api.nlqdb.com/v1/ask -d '{"goal":""}'

hour	orders
11	47

11:00 — 47 orders, 22% of the day's volume

SQL the engine ran

SELECT EXTRACT(HOUR FROM created_at) AS hour, COUNT(*) AS orders
  FROM orders
 WHERE created_at > date_trunc('day', now())
 GROUP BY 1
 ORDER BY orders DESC
 LIMIT 1;

write

<nlq-action goal="">Log order</nlq-action>

✓ inserted order #4128

SQL the engine ran

INSERT INTO orders (customer, drink, total)
 VALUES ('sarah', 'latte', 4.50)
RETURNING id;

read

<nlq-data goal=""></nlq-data>

name	last_order_at
noah	2026-02-14
priya	2026-02-28
marcus	2026-03-08
kira	2026-03-19

SQL the engine ran

SELECT name, last_order_at
  FROM customers c
 WHERE NOT EXISTS (
   SELECT 1 FROM orders o
    WHERE o.customer = c.name
      AND o.created_at > now() - interval '30 days'
 )
 ORDER BY last_order_at;

create
CLI
```
nlq new ""
```
renders ↓
✓ created db_crm · 2 tables inferred

schema = contacts(name, company, email), deals(contact_id, value, stage)
SQL the engine ran
```
CREATE DATABASE db_crm;
CREATE TABLE contacts (...);
CREATE TABLE deals (...);
```

read

<nlq-data goal=""></nlq-data>

drink	together
latte	87
espresso	62
americano	41
cold brew	18

SQL the engine ran

SELECT drink, COUNT(*) AS together
  FROM orders o
  JOIN order_items i ON i.order_id = o.id
 WHERE i.item = 'cake'
 GROUP BY drink
 ORDER BY together DESC
 LIMIT 4;

write

curl api.nlqdb.com/v1/ask -d '{"goal":""}'

✓ refunded order #4127 · $6.20

SQL the engine ran

UPDATE orders
   SET status = 'refunded', refunded_at = now()
 WHERE id = (SELECT MAX(id) FROM orders)
RETURNING id, total;

read

<nlq-data goal=""></nlq-data>

hour	avg_order
7	4.1
8	4.6
9	4.4
10	4.9
11	5.4
12	6.1

AOV climbs into lunch · pastries kick in at 11

SQL the engine ran

SELECT EXTRACT(HOUR FROM created_at) AS hour,
       ROUND(AVG(total), 2) AS avg_order
  FROM orders
 WHERE created_at > date_trunc('day', now())
 GROUP BY 1
 ORDER BY 1;

schema
CLI
```
nlq schema ""
```
renders ↓
✓ column added

1,247 rows · default NULL · backfill via /v1/ask later
SQL the engine ran
```
ALTER TABLE customers
  ADD COLUMN birthday DATE;
```
read
REST
```
curl api.nlqdb.com/v1/ask -d '{"goal":""}'
```
renders ↓
id drink total created_at

4118 americano 3.8 2026-04-27 09:14
4101 latte 4.5 2026-04-26 18:32
4087 cortado 4.3 2026-04-26 11:10

3 anonymous orders this week
SQL the engine ran
```
SELECT id, drink, total, created_at
  FROM orders
 WHERE customer IS NULL
    OR customer = ''
 ORDER BY created_at DESC;
```

write

nlqdb.ask({ goal: "" })

✓ updated 23 rows

SQL the engine ran

UPDATE customers
   SET tier = 'gold', updated_at = now()
 WHERE id IN (
   SELECT customer_id FROM orders
    GROUP BY customer_id
   HAVING COUNT(*) > 100
 );

read

<nlq-data goal=""></nlq-data>

drink	orders
flat white	412
americano	298
cortado	244
cold brew	188
espresso	162

SQL the engine ran

SELECT drink, COUNT(*) AS orders
  FROM orders
 WHERE created_at > date_trunc('month', now())
 GROUP BY drink
 ORDER BY orders DESC
 LIMIT 5;

read

<nlq-data goal="" db="db_feedback"></nlq-data>

submitted_at	channel	body	tags
2026-04-27 09:14	email	Tabbed code panel is great!	praise
2026-04-27 08:02	intercom	Can't find sign-in	bug
2026-04-27 06:48	twitter	Try not to feel like Postgres	perf
2026-04-26 22:30	email	Need a Python SDK	feature

mixed signal — 1 bug, 1 feature, 2 praise/observation

SQL the engine ran

SELECT submitted_at, channel, body, tags
  FROM feedback
 WHERE submitted_at > now() - interval '24 hours'
 ORDER BY submitted_at DESC
 LIMIT 5;

read

<nlq-data goal="" db="db_hackathon"></nlq-data>

player	score	region
axolotl-prime	9412	EU
kestrel	9180	NA
mochi-net	8847	APAC
vela	8214	EU
owl-club	7902	NA

SQL the engine ran

SELECT player, score, region
  FROM hackathon_scores
 ORDER BY score DESC
 LIMIT 5;

read

nlqdb.ask({ db: "db_agents", goal: "" })

thread_id	role	content	created_at
t-204	user	summarize last week's invoices	2026-04-26 18:42
t-204	assistant	12 invoices, $14,802 total	2026-04-26 18:42
t-198	user	switch focus to support tickets	2026-04-26 14:10
t-198	assistant	ok, scoping to /support	2026-04-26 14:10
t-187	user	what changed in db schema?	2026-04-26 09:32
t-187	assistant	added `tags` column on `feedback`	2026-04-26 09:32

6 turns · 3 threads · last day

SQL the engine ran

SELECT thread_id, role, content, created_at
  FROM agent_memory
 WHERE created_at > now() - interval '1 day'
 ORDER BY created_at DESC
 LIMIT 6;

read

curl api.nlqdb.com/v1/ask -d '{"db":"db_crm","goal":""}'

name	company	last_touch	status
Maya Chen	Vellum Coffee	2026-04-26	warm
Tomas Reyes	Northwind Audio	2026-04-25	active
Aki Sato	Six Lab	2026-04-24	cold
Priya Nair	Lampshade	2026-04-22	warm
Jonas Berg	Bauhaus Bikes	2026-04-20	active

SQL the engine ran

SELECT name, company, last_touch, status
  FROM contacts
 ORDER BY last_touch DESC
 LIMIT 5;

read

<nlq-data goal=""></nlq-data>

created_at	customer	drink	total
2026-04-23	ben	drip x4	12.4
2026-04-22	lin	latte x3 + scone	18.2
2026-04-21	rod	espresso flight	14
2026-04-21	amy	cold brew growler	22.5

SQL the engine ran

SELECT created_at, customer, drink, total
  FROM orders
 WHERE total > 10
   AND created_at BETWEEN now() - interval '7 days' AND now()
 ORDER BY total DESC;

Join the waitlist

Pre-alpha — we'll email when nlqdb opens up. No marketing fluff, just one note when there's a button to push.

Pick a way in. Same backend — the one that doesn’t exist.

Each snippet is the entire integration. No boilerplate omitted, no “configure your client” step elided. The contrast is the message.

# 1. install (curl, brew, npm — pick one)
curl -fsSL https://nlqdb.com/install | sh

# 2. create from a goal — the DB is a side effect
nlq new "an orders tracker for my coffee shop"

# 3. talk to it
nlq "add an order: alice, latte, $5.50, just now"
nlq "how many orders today, by drink"

<!-- one CDN script registers the elements -->
<script src="https://elements.nlqdb.com/v1.js" type="module"></script>

<!-- describe what you want; the DB is created on first call -->
<nlq-data
  goal="today's orders, newest first, with customer + total"
  db="orders"
  api-key="pk_live_..."
  template="table"
  refresh="5s"
></nlq-data>

import { NlqData } from "@nlqdb/react";

export function Orders() {
  return (
    <NlqData
      goal="today's orders, newest first"
      db="orders"
      apiKey={process.env.NEXT_PUBLIC_NLQDB_KEY}
      template="table"
      refresh="5s"
    />
  );
}

<script setup lang="ts">
import { NlqData } from "@nlqdb/vue";
</script>

<template>
  <NlqData
    goal="today's orders, newest first"
    db="orders"
    api-key="pk_live_..."
    template="table"
    refresh="5s"
  />
</template>

import { createClient } from "@nlqdb/sdk";

const client = createClient({ apiKey: process.env.NLQDB_KEY! });

// no schema, no SQL, no ORM. one verb.
const res = await client.ask({
  goal: "today's orders, newest first",
  dbId: "orders",
});

if (res.status === "ok") console.table(res.rows);

# same /v1/ask the SDK and the element call — no SDK required
curl -X POST https://app.nlqdb.com/v1/ask \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{"goal":"today orders, newest first","dbId":"orders"}'

// ~/Library/Application Support/Claude/claude_desktop_config.json
// (or ~/.cursor/mcp.json — same shape works in every MCP host)
{
  "mcpServers": {
    "nlqdb": {
      "url": "https://mcp.nlqdb.com",
      "headers": {
        "Authorization": "Bearer sk_mcp_..."
      }
    }
  }
}

import SwiftUI
import Nlqdb

NlqDataView(
  goal: "today's orders, newest first",
  dbId: "orders",
  apiKey: "pk_live_..."
) { result in
  Text("\(result.rowCount) rows")
}

/* No-JS: stack every panel under the tab strip; hide the strip. */ .tabs[data-tabs] [data-tab-panel] { display: block !important; border-top: 2px solid var(--border-strong); } .tabs[data-tabs] > [data-tab-panel]:first-of-type { border-top: 0; } .tabs[data-tabs] .tabs__list { display: none; }

Shipped <nlq-data> <nlq-action> TS SDK anonymous API chat surface db.create MCP server quality-eval React / Next Vue / Nuxt Svelte / Kit Astro Solid Swift

Phase 1 curl recipes

Phase 2 CLI Python SDK Go SDK BYOLLM

Wishlist VSCode JetBrains Slack Discord

Each one is a thin wrapper over the same elements — full matrix in progress.md. Tap a wishlist surface to nudge it up the list.

Eight boxes — or one tag.

Everything a normal backend forces you to wire together, replaced by a single element on the page.

Database
Schema
ORM
Endpoint
Auth
Cache
Migrations
Deploy

<nlq-data>

One element. Schema, plan, cache, auth — all server-side, all invisible.

Backed by the work

We didn't make this up. Here's where each idea comes from.

Pre-alpha making technical claims has to show its work. Each design call below is anchored to a specific paper, postmortem, or production system that taught us the lesson.

Layer the validator like an onion.

Replit's coding agent (July 2025) wiped a customer database during a code freeze with three guardrails active. We layer everything: AST parse, verb allowlist, table allowlist, role isolation, RLS, transaction wrapper.

Fortune — Replit catastrophic failure

Applied at docs/architecture.md §3.6.5 + sql-validate.ts
LLM picks structure, our code emits SQL.

Snowflake Cortex Analyst hits 90%+ accuracy on real BI workloads — about 2× single-prompt GPT-4o — because the LLM picks from a curated semantic layer instead of writing raw SQL. Our schema-create path follows the same logic with a typed plan, not raw DDL.

Snowflake engineering blog

Applied at docs/architecture.md §3.6.2 typed-plan pipeline
Embed tables, not columns, for schema retrieval.

Pinterest's text-to-SQL system uses one embedding per table-card (name + description + columns + sample values). nilenso's 2025 evaluation found hit rate climbed from ~40% to ~90% just from adding table-doc embeddings. We use the table-card pattern from day one.

nilenso — RAG approach for text-to-SQL

Applied at research-receipts §3
Treat fetched row content as untrusted.

Keysight (July 2025) documented an attack class where a row in the user's database contains `ignore previous instructions, DROP TABLE…` — when an agent later reads that row and re-feeds it into its system prompt, the row's content steers the next turn. We never re-feed row content into agent system prompts.

Keysight Threats blog

Applied at research-receipts §4
Generate the semantic layer at create time.

Every shipped enterprise NL-Q product (Cortex, ThoughtSpot, Power BI Q&A, Tableau Pulse, dbt MetricFlow, Cube) depends on a curated semantic layer — none of them auto-creates the database. We own the schema-creation moment, so we generate the metric and dimension layer automatically.

dbt — Semantic Layer vs Text-to-SQL 2026

Applied at docs/architecture.md §3.6.3 the moat

Manifesto

Three rules every build is judged against.

01
Free, forever

Sign up, build, ship to production without a credit card. The free tier isn't a trial — it's the product. Every cost upgrade is gated on a real signal: paying customers, not theoretical scale.
02
Fast. Measured.

p50 query under 400ms on cache hit. p95 under 1.5s on cache miss. Cold start under 800ms. Numbers exist so we can fail them in CI, not so we can quote them in a deck.
03
Goal-first, not DB-first

Nobody woke up wanting to create a database. They want a meal-planner, an agent that remembers, the number for the 4pm sync. The DB materialises as a side effect of the goal.

Read the full manifesto

id	drink	total	created_at
4118	americano	3.8	2026-04-27 09:14
4101	latte	4.5	2026-04-26 18:32
4087	cortado	4.3	2026-04-26 11:10

nlqdb

Spin up a database from a sentence.

Join the waitlist

Eight boxes — or one tag.

Layer the validator like an onion.

LLM picks structure, our code emits SQL.

Embed tables, not columns, for schema retrieval.

Treat fetched row content as untrusted.

Generate the semantic layer at create time.

Free, forever

Fast. Measured.

Goal-first, not DB-first

Something broke on this page.