SQL and NoSQL Database MCP Servers

Database MCP servers let AI coding tools introspect a live schema and run read-only queries instead of guessing at table structure. PostgreSQL teams reach for Prisma MCP or Supabase MCP, MongoDB projects use the MongoDB MCP server, SQLite covers local prototyping, and dbhub connects several engines at once. Two workflows follow: generating a data model from a real table, and debugging live data.

Your AI just wrote a beautiful ORM query against a table that does not exist. It assumed users.email is unique when your schema allows duplicates. It wrote a User interface from memory that guesses email is non-null, misses the deleted_at soft-delete column, and types created_at as a string when it is a timestamptz. Ten minutes later you are debugging stuck orders and it cheerfully suggests a query against a payment table that is actually named payments.

Every one of those failures has the same root cause: the AI is guessing at your data instead of reading it. A database MCP server closes the gap. Once the AI can introspect the schema and run read-only queries, it stops inventing and starts working with what is actually there.

What database MCP servers give you

• Setup for PostgreSQL (Prisma and Supabase), MongoDB, SQLite and dbhub across Cursor, Claude Code and Codex
• A decision framework for picking the right server for your stack
• The read-only security posture that makes all of this safe to run against staging
• A repeatable flow for generating an exact data model — types, nullability, defaults — from a live table
• A live-data debugging loop that finds the offending rows in minutes instead of hand-written joins
• Prompts for schema-aware code generation, migration drafting and ad-hoc data analysis

Choosing the right database MCP for your stack

Stack	Recommended MCP	Why
TypeScript + Prisma	Prisma MCP	Native integration with your ORM and migration system
Supabase	Supabase MCP	Respects RLS policies, includes auth and storage tools
MongoDB	MongoDB MCP	Schema inference, JSON querying, collection analysis
SQLite / Local dev	SQLite MCP	Zero-config, perfect for prototyping
Multiple databases	dbhub	Universal connector supporting PostgreSQL, MySQL, SQLite, and more

Registration is the same shape for every one of them, and it is one of the places the three tools genuinely converge. Cursor and Claude Code read the same mcpServers JSON, so you can paste the Cursor block into Claude Code’s .mcp.json verbatim — or use claude mcp add to have the CLI write it. Only Codex differs in format: [mcp_servers.<id>] TOML, where stdio transport is inferred from command and there is no transport key.

PostgreSQL: Prisma MCP and Supabase MCP

For TypeScript teams, the Prisma MCP server is the most natural fit. It integrates with your existing Prisma schema and lets the AI query data, inspect schemas, and manage migrations.

Cursor

{
  "mcpServers": {
    "prisma": {
      "command": "npx",
      "args": ["-y", "prisma", "mcp"]
    }
  }
}

Claude Code

claude mcp add prisma -- npx -y prisma mcp

Codex

[mcp_servers.prisma]
command = "npx"
args = ["-y", "prisma", "mcp"]

For teams on Supabase, the Supabase MCP server is aware of Row Level Security policies and the wider Supabase ecosystem, including auth, storage, and edge functions.

MongoDB MCP

For document databases, the MongoDB MCP server provides schema inspection and JSON querying. It helps the AI navigate semi-structured collections and understand embedded document patterns.

Cursor

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": ["-y", "mongodb-mcp-server"],
      "env": {
        "MONGODB_URI": "mongodb://localhost:27017/mydb"
      }
    }
  }
}

Claude Code

claude mcp add --env MONGODB_URI=mongodb://localhost:27017/mydb mongodb -- npx -y mongodb-mcp-server

Codex

[mcp_servers.mongodb]
command = "npx"
args = ["-y", "mongodb-mcp-server"]

[mcp_servers.mongodb.env]
MONGODB_URI = "mongodb://localhost:27017/mydb"

SQLite MCP

SQLite is the reliable choice for local-first development and prototyping. Let the AI experiment with schemas and build internal tools without touching production data.

Cursor

{
  "mcpServers": {
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "./dev.db"]
    }
  }
}

Claude Code

claude mcp add sqlite -- uvx mcp-server-sqlite --db-path ./dev.db

Codex

[mcp_servers.sqlite]
command = "uvx"
args = ["mcp-server-sqlite", "--db-path", "./dev.db"]

Read-only first, staging not production

Caution

Connect with a database user scoped to read-only (SELECT) permissions, and point it at staging. A server that can run arbitrary SQL can run DROP TABLE — a read-only role removes that entire class of accident while you build trust in the workflow. This is the single most important safeguard on this page, and it costs one CREATE ROLE.

With that in place, the two workflows below are safe to run against real data, because nothing in either of them can mutate anything.

Workflow 1: generate a data model from a live table

You need a User model that matches the users table exactly — not the AI’s best guess.

1. Have the AI read the real schema. Inspecting first means the generated code is grounded in the actual columns, types, and nullability.

   Copy-paste prompt: introspect a table

   “Use the database MCP to inspect the users table. List every column with its exact type, nullability, and default. Call out the primary key, any unique constraints, and any soft-delete or status columns. Do not generate code yet — just report the schema.”

2. Generate the model from that context. Now the AI has the truth in context, so the types line up.

   Copy-paste prompt: generate typed code from a schema

   “Based on the schema you just read, generate a TypeScript interface for User plus a Zod schema that validates a row from that table. Match nullability exactly (nullable columns become optional/null), map timestamptz to Date, and add a short comment on any column that is a soft-delete or status flag. Do not invent columns that are not in the schema.”

   The result matches your table because it was generated from your table — nullable columns are optional, the timestamp is a Date, and deleted_at is documented rather than dropped.

When you want a query rather than a model, the same discipline collapses into one prompt: read the schema first, write the query second.

Copy-paste prompt: schema-aware query generation

“Inspect the database schema. List all tables, their columns, types, and relationships. Then write a Drizzle ORM query that fetches all users who signed up in the last 30 days along with their most recent order, including the order total and status.”

Workflow 2: debug a production issue with live data

Some orders are stuck and you suspect the data, not the code. Instead of hand-writing a join, describe the symptom and let the AI build and run the query.

1. Describe the bad state in plain English. The AI translates it into SQL, runs it through the MCP server against the read-only connection, and shows you the offending rows.

   Copy-paste prompt: hunt down bad rows

   “Using the database MCP, find every order created in the last 24 hours with status = 'pending' that has no matching row in the payments table. Return order id, customer id, created_at, and total, sorted oldest first. Show me the exact SQL you ran so I can sanity-check the join.”

   Asking it to print the SQL it ran is the difference between a black box and a tool you can trust — you verify the join logic yourself before believing the result.

2. Pivot from the evidence. With concrete order ids in hand, you can narrow further without rewriting anything by hand.

   Copy-paste prompt: drill into a finding

   “For those stuck orders, check the payment_attempts table for any failed attempts in the same window. Group by failure reason and count. If a single error code dominates, summarize what it means and which orders it explains.”

You diagnosed the root cause from live data without leaving the editor or hand-writing a multi-table join.

The same loop works for ad-hoc analysis, not just bugs:

Copy-paste prompt: ad-hoc data analysis

“Query the orders table for the last 90 days. Group by product_id and calculate the total revenue, average order value, and order count for each product. Sort by revenue descending and present the top 10 products in a formatted table.”

Migrations and schema drift

The third payoff is catching the gap between what the database holds and what your types claim. The AI can read both sides at once, which is something neither a migration tool nor a type-checker does on its own.

Copy-paste prompt: draft a migration from the drift

“Read the current database schema and compare it to the TypeScript types defined in src/lib/db/schema.ts. Identify any mismatches — missing columns, type differences, or missing indexes. Generate a SQL migration script that brings the database in line with the TypeScript schema.”

Read the generated SQL before you run it. A drift report is evidence; a migration is a change.

When database MCP servers break

Connection refused. Make sure your database is running and reachable from localhost. Check that the connection string carries the correct port, database name, and credentials.

The AI queries a table or column that does not exist. It is still guessing instead of introspecting. Force the inspection step: make it read the schema before it writes any query, and confirm the MCP server is actually connected (the client should list its tools).

The AI writes destructive queries. If it runs UPDATE or DELETE when you only expected SELECT, the database user has too many permissions. Create a dedicated read-only role for MCP access.

Schema inspection returns stale data. Some MCP servers cache schema metadata. After a migration, restart the server to refresh the cache, then re-run the introspection prompt.

Slow queries time out. Analytical scans on large tables can exceed the server’s tool timeout. Add an index, add a tighter WHERE clause, or ask the AI to LIMIT and paginate.

Where to go next with database MCP

Building Your Own MCP Server Wrap an internal API or proprietary data store in your own MCP server.

Documentation Context Keep your AI grounded in current library documentation.

Version Control MCP GitHub and GitLab integration for AI-assisted development.