The KiviDB MCP Server Is Live: Run Your Databases from Claude, ChatGPT, Gemini and Cursor

Murtaza Shajapurwala ·

Today we're launching the KiviDB MCP server. Claude, ChatGPT, Gemini, Cursor, VS Code and any other client that speaks the Model Context Protocol can now run your KiviDB Cloud databases, query them, and pass context to each other through them.

It's published on npm as @kividbio/mcp-server, and there's nothing to install. Your client starts it on demand with npx.

What it looks like

Here's a real exchange from our own testing:

You: Launch a Pro instance with 2 replicas, 8 GB, in the ap-south-1 AWS region.

Assistant: Before I create it, here's the cost. Pro, 8 GB, 2 replicas in ap-south-1 comes to about $535.72/month. What should I name it?

You: Name it test-db.

Assistant: test-db is provisioning. It usually takes a minute or two.

The assistant quoted the price before creating anything, because paid databases bill your organization. The tools say so, so the assistant asks before spending.

What it can do

Databases. List them, read their details, and create one, including a free-tier database that costs nothing. Resize the disk, switch throughput mode, scale replicas, upgrade Essentials to Pro, rename, stop, start and delete. Renaming changes the display name only; the hostname stays the same, so nothing that connects to it breaks.

Shared context between assistants. remember writes a note and recall reads it back. Notes live in your own database, so any assistant pointed at the same database and namespace sees them. That's how one assistant picks up where another left off, with no agreement between them beyond a name.

Vectors. vector_search finds the nearest neighbours of an element in a vector set, and list_vector_sets shows which sets exist. KiviDB doesn't build embeddings, so the vectors need to be in the database already, added with VADD.

Backups. Take a disk snapshot, and list the ones you have.

Anything else. run_command runs a single KiviDB command: SET, GET, FT.SEARCH, VADD, VSIM and the rest. Commands that manage the server itself are refused by KiviDB.

Finding your way around. list_organizations shows which organizations you belong to, list_nodes shows the machines behind a database and their health, and list_documentation points the assistant at the right docs page instead of letting it guess.

One assistant remembers, another recalls

Point two assistants at the same database and namespace, and they read each other's notes.

In ChatGPT:

Remember that we moved the staging allowlist into Terraform.

Later, in Claude:

What do we know about the allowlist?

[mul8o6rx] 2026-09-28 by chatgpt (staging, deploy)
The staging allowlist reverts on every deploy until the Terraform apply runs.

Notes carry an author and optional tags, and recall filters on both, so you can ask what one assistant concluded without everyone else's notes crowding it out. Namespaces keep projects apart: the default is shared, and a note in another namespace is invisible to anyone using this one.

Nothing is remembered unless an assistant is asked to remember it. These are notes in your database, not a transcript.

The API key is the limit

Everything the server does, it does as an API key. The key belongs to one organization and carries a role, so what an assistant can see and change is decided by KiviDB, not by the assistant and not by the package.

RoleCan
memberCreate, change and delete databases; read and write data
adminThe same, plus mint and revoke API keys
ownerThe same, plus billing and membership

Mint keys in the console under API keys, and give each one the smallest role that does the job. Two habits we recommend:

  • One key per assistant, named for it. The console shows each key's last use, so you can see which assistant is actually doing anything, and revoking one doesn't disturb the others.
  • Revoke to stop. Revoking a key in the console stops every assistant holding it, immediately.

When KiviDB refuses something, the assistant is told why in KiviDB's own words. "Free tier instances are one per person", not "request failed", so it can pass that on instead of retrying.

Built to be careful

  • Cost before commitment. Creating or upgrading a paid database costs money, and the tools say so, so assistants ask first.
  • Deletes check the name. delete_database takes the database's exact current name and checks it against KiviDB before deleting anything. An assistant that has confused two ids is stopped rather than believed.
  • No server administration. Admin commands are refused by KiviDB itself.
  • Data-plane safety lives in ACLs. run_command doesn't ask for confirmation, because that would mean sending the same string twice, and it can run destructive commands. What stops it is the database user's own permissions, so give assistants a user scoped to what they need.

Connect it

The server runs two ways. The tools are identical either way.

As a subprocess (stdio). The client starts the server and talks over its pipes, and your key stays on your machine. This is how Claude Desktop, Claude Code, the Gemini CLI, Cursor and VS Code work.

Claude Desktop, Cursor and the Gemini CLI all use the same shape. Put it in Claude Desktop's config (Settings → Developer → Edit Config), .cursor/mcp.json, or ~/.gemini/settings.json:

{
  "mcpServers": {
    "kividb": {
      "command": "npx",
      "args": ["-y", "@kividbio/mcp-server"],
      "env": { "KIVIDB_API_KEY": "kvdb_live_..." }
    }
  }
}

Claude Code:

claude mcp add kividb --env KIVIDB_API_KEY=kvdb_live_... -- npx -y @kividbio/mcp-server

VS Code can prompt for the key instead of storing it in the file, which is worth doing in a shared repository. Add this to .vscode/mcp.json:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "kividb-key",
      "description": "KiviDB API key",
      "password": true
    }
  ],
  "servers": {
    "kividb": {
      "command": "npx",
      "args": ["-y", "@kividbio/mcp-server"],
      "env": { "KIVIDB_API_KEY": "${input:kividb-key}" }
    }
  }
}

As an HTTPS service. Clients like ChatGPT want a URL. Run the server in HTTP mode:

KIVIDB_API_KEY=kvdb_live_... npx -y @kividbio/mcp-server --http --port 8787

Then add it in ChatGPT under Settings → Connectors → Add custom connector, pointing at your HTTPS URL. Put it behind TLS, since the key is a bearer credential. Each request can also carry its own key as Authorization: Bearer <key>, so one deployment can serve a whole team without anyone sharing a key. GET /healthz answers {"ok":true} for load balancers.

What it costs

The server itself is free. What it does can cost money: creating a paid database, resizing one, or upgrading to Pro bills the organization that owns the key, and paid tiers need prepaid credit first. A free-tier database costs nothing and is the best place to start.

Try it

Mint a member key, add the server to your assistant, and ask it to spin up a free database. The full setup guide and tool reference are in the KiviDB docs. If there's something you wish it could do, tell us on Discord.