Best Databases MCP Servers for Postgres Workflows: A 2026 Comparison

The MCPFind databases category covers 317 servers as of May 2026, averaging 13.97 stars each. The Postgres-specific subset handles a narrower surface than that average suggests: structured SQL queries, schema inspection, migration generation, and query performance analysis against a live connection. By adoption, the HEALTHY-tier picks are the official Postgres MCP server, Supabase MCP (2,556 stars), Neon MCP, Prisma MCP (40 stars), Waystation Postgres (45 stars), and SchemaCrawler AI (9 stars). What follows compares them on connection model, tool surface, and the workflows each one actually fits.

Selection Criteria

Two filters shaped the candidate list. First, Postgres has to be the primary target, not a secondary option in a generic SQL client. Servers built for MySQL, SQLite, or generic JDBC connections got cut even when they technically supported Postgres. Second filter: HEALTHY classification in the MCPFind quality audit (50+ GitHub stars or vendor-official status, with a commit in the prior 90 days), or recognition as an official vendor-maintained release. Star counts come from the MCPFind directory snapshot on May 20, 2026. The official Postgres MCP and Neon MCP made the cut on official-vendor and ecosystem-adoption signals; their MCPFind directory entries haven't been enriched with current star counts from their respective GitHub repos yet.

Comparison Table

Official Postgres MCP

Ships as @modelcontextprotocol/server-postgres in the Anthropic-led MCP organization at github.com/modelcontextprotocol/servers. Think of it as the reference implementation for Postgres access: a minimal, connection-string-driven server that wraps a live database and exposes it through typed MCP tools. No platform account. No vendor lock-in. Point it at any Postgres instance, local or remote, and it works. The package picks up regular commits as part of the broader MCP servers monorepo, which stays actively maintained. Star count sits in the low hundreds in the directory snapshot.

The tool surface covers what shows up most often in a Postgres workflow. query accepts raw SQL and returns results as a JSON array, handling everything from a single SELECT to a multi-table join with subqueries. list_schemas and list_tables let an agent survey the database without writing information_schema queries by hand. describe_table returns column names, data types, nullability, and default values for a specific table. For schema work, an agent runs migration DDL directly through query. Pairing a schema-discovery surface with an unrestricted query tool means most Postgres use cases resolve without the agent falling back to raw SQL guess-and-check.

Self-hosted Postgres, or a cloud provider like AWS RDS, Google Cloud SQL, or Azure Database for PostgreSQL? Start here. The connection-string model works identically against any Postgres-compatible endpoint. No custom configuration beyond a DATABASE_URL. When a workflow needs schema inspection before writing a query, then running the query, then summarizing the result, the official server does all three without additional tooling.

Not the right fit if you're on Supabase or Neon and want platform-native features: row-level security management, branch operations, real-time subscription setup. Those need the vendor-specific MCP servers, which expose API surface beyond the database wire protocol. The official Postgres MCP gives you the SQL layer and nothing about the platform around it.

Open source under the MIT license. The broader modelcontextprotocol/servers repo carries 10,000+ stars across all reference servers. The Postgres implementation is actively included in MCPFind's quality tracking.

Setup Snippet

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/yourdb"
      }
    }
  }
}

Supabase MCP

At 2,556 stars on MCPFind, Supabase MCP (github.com/supabase/mcp-server-supabase) is the highest-adoption server in the databases category by a wide margin. Supabase runs on Postgres, so every Postgres workflow applies here. The server reaches well past what the official Postgres MCP covers, though: it wraps the Supabase management API alongside the database, giving an agent access to table editor operations, storage bucket management, edge function deployment, and row-level security configuration through one MCP interface. If your stack is Supabase, this is the complete integration. Database plus platform.

Supabase already has a full deep-dive post on MCPFind covering its tool surface, so this entry focuses on what distinguishes it inside the Postgres-workflow context. The tools that matter most for Postgres-flavored work: execute_sql (raw query execution against the Supabase Postgres instance), apply_migration (runs DDL using Supabase's migration framework), list_tables and get_table_definition (schema inspection), list_extensions (checks which Postgres extensions, including pgvector, are enabled on the project). One difference from the official Postgres MCP, which accepts a raw connection string: Supabase MCP authenticates against the Supabase management API with a project-level access token.

The case for Supabase MCP over the official Postgres server boils down to one thing. If your Postgres is hosted on Supabase, this server speaks the full API surface of your environment, not just the database wire protocol. An agent can inspect a table, run a query, then enable a Postgres extension in one session without switching tools. Teams using Supabase Auth or Storage alongside their database avoid the context-switching tax of maintaining two servers.

Off Supabase? This server has nothing for you. The auth model requires a Supabase access token tied to a specific project. It won't accept arbitrary Postgres connection strings. Self-hosted Postgres users, RDS users, and Cloud SQL users should look at the official Postgres MCP or Neon MCP instead.

2,556 stars, last push March 24, 2026. Maintained directly by the Supabase team. MIT license. Free tier available; Supabase pricing applies to the underlying project.

Setup Snippet

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest"],
      "env": {
        "SUPABASE_ACCESS_TOKEN": "your-personal-access-token"
      }
    }
  }
}

Neon MCP

Neon builds serverless Postgres, and their MCP server (github.com/neondatabase/mcp-server-neon) is built around Neon's branching model. Standard Postgres MCP servers think in schemas and tables. Neon MCP adds a layer above that: Neon database branches, which are cheap, isolated Postgres instances that fork from a parent in seconds. For development workflows where you want an agent working on a copy of production rather than production itself, Neon's branching primitive changes the risk model. The server is maintained by the Neon team with regular pushes, and shows roughly low hundreds of stars in the MCPFind directory's current data window.

The tools that matter for Postgres work: query (SQL execution against a named branch), create_branch (spin up a new branch from any parent), delete_branch (clean up after a task), list_branches (see what's running in a project), get_connection_string (retrieve the connection string for a branch so other tools can connect to it). Schema-level tools mirror what you'd expect from the official Postgres MCP: list tables, describe columns, check indexes. The Neon-specific value is the workflow orchestration layer on top. An agent can create a branch, run a migration against it, query the results, and delete the branch when done, all in one conversation. No production database touched.

Teams that want agents running migrations or schema changes without direct production exposure get the most out of this. Loop: create a branch from the production snapshot, apply the migration, run queries to verify, then merge or delete depending on outcome. What used to take a staging database and manual teardown now runs as a sequence of MCP tool calls. For SQL query authoring where you want to test against realistic data without risking live rows, Neon branches give you the isolation layer.

If your Postgres isn't on Neon, this one's a no-go. The server connects through the Neon API using an API key tied to a Neon project. There's no support for external Postgres hosts, and the branching tools only work within a Neon project's branch hierarchy.

Low hundreds of stars, maintained by the Neon engineering team, regular pushes in 2026. MIT license. Neon's free tier covers branching and compute for development use.

Setup Snippet

{
  "mcpServers": {
    "neon": {
      "command": "npx",
      "args": ["-y", "@neondatabase/mcp-server-neon"],
      "env": {
        "NEON_API_KEY": "your-neon-api-key"
      }
    }
  }
}

Waystation Postgres

A focused community server for self-hosted Postgres. Waystation Postgres (45 stars on MCPFind, slug ai-waystation-postgres) takes a different philosophy from the official MCP server: fewer abstractions, direct database access, read and write supported, a simple connection string as the only configuration. It sits in the HEALTHY tier with commits through September 2025. If you want an MCP server that gets out of the way and connects an agent to a running Postgres instance with minimal ceremony, this is the lowest-friction option among the community-maintained ones.

The tool surface is deliberately tight. execute_query runs any SQL against the connected database and returns results as structured JSON. get_schema returns table and column definitions for the database in one call, which saves the round-trip of querying information_schema directly. list_tables produces a quick index of what's in each schema. The write model is permissive. There's no read-only mode at the tool level, so the access boundary is entirely set by the Postgres role you supply in the connection string. A SELECT-only role makes it read-only. A role with write privileges gives the agent full read-write access.

Solo developers and small teams running Postgres locally or on a simple cloud VM are the sweet spot here. You get an agent that can query, update, and inspect the database in a single session. Connection-string setup takes about two minutes. No platform account, no API key management beyond the database credentials you already have. Practical use case: write a SELECT across several joined tables, inspect the result, update a set of rows based on that result, confirm the update in one conversation without context-switching to a SQL client.

For teams on Supabase or Neon, this one adds nothing. The platform-native MCP servers cover the same SQL access plus additional platform features. It also has no awareness of ORMs or migration frameworks. Teams using Prisma or another schema-management layer should look at Prisma MCP instead.

45 stars, last push September 10, 2025. Community-maintained. MIT license.

Setup Snippet

{
  "mcpServers": {
    "waystation-postgres": {
      "command": "npx",
      "args": ["-y", "@waystation/postgres-mcp"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/yourdb"
      }
    }
  }
}

Prisma MCP

Prisma MCP (40 stars on MCPFind, io-prisma-mcp, at github.com/prisma/prisma) is the ORM-aware entry in this lineup. The other servers connect at the wire-protocol level and have no concept of how your application models data. Prisma MCP reads your prisma.schema file alongside the live database, so the agent understands your application's data model by name, not just the raw table structure. For Prisma-based teams, that's the difference between an agent that asks "what's in the users table" and one that asks "what does the User model look like, and how does it relate to Post." Last push October 2025.

What separates this from a raw Postgres server: the schema-aware operations. get_schema returns your Prisma schema as structured data. generate_migration takes a description of the schema change you want and produces a Prisma migration file, which you can review before running. run_migration applies a pending migration. format_schema lints and reformats your schema file to Prisma conventions. For direct database access, execute_query runs SQL through Prisma's query engine against the configured datasource. An agent can read your current schema, propose a change, generate the migration, and apply it without leaving the conversation.

Best fit: teams deep in the Prisma ecosystem. Next.js apps, Node.js APIs, anything using Prisma Client as the data layer. An agent that knows your schema by its Prisma model names writes much cleaner queries and migrations than one working from raw table names. Building a new model, adding a field, setting up a relation? Prisma MCP handles the generate-migrate-apply loop interactively.

Teams not using Prisma get nothing here. The server depends on a prisma.schema file and Prisma CLI tooling. Raw Postgres workflows without a Prisma layer should use the official Postgres MCP or Waystation Postgres instead. Prisma MCP is also not the right pick for performance analysis or query tuning, since its SQL access goes through Prisma's query engine rather than directly to the database.

40 stars, last push October 7, 2025. Maintained by Prisma. Apache 2.0 license.

Setup Snippet

{
  "mcpServers": {
    "prisma": {
      "command": "npx",
      "args": ["-y", "@prisma/mcp-server"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/yourdb"
      }
    }
  }
}

SchemaCrawler AI

The schema-documentation specialist of the list. SchemaCrawler AI (9 stars on MCPFind, io-github-schemacrawler-schemacrawler-ai, at github.com/schemacrawler/SchemaCrawler-AI) wraps a long-trusted database schema analysis tool as an MCP server. The original SchemaCrawler has been around for over a decade; the AI variant takes that catalog-reading capability and exposes it through MCP. It reads table definitions, primary keys, foreign keys, indexes, stored procedures, and triggers from the database catalog, then answers natural-language questions about what the schema contains without making the agent write information_schema queries. Postgres is a first-class supported database, alongside MySQL, Oracle, and MSSQL. Last push March 23, 2026.

The tool surface is built around schema discovery rather than query execution. get_database_info returns a high-level database overview: server version, catalog name, supported features. list_tables enumerates tables with row counts and brief descriptions. describe_table returns the full column definition, constraints, indexes, and foreign key relationships for a specific table. find_foreign_keys traces relationships between tables, which is the tool to reach for when you need to understand how a set of tables are connected before writing a JOIN-heavy query. get_stored_procedures lists and describes stored procedures and their parameters.

Where this one earns its spot: the schema-understanding phase before query authoring. When an agent needs to understand an unfamiliar Postgres database well enough to write accurate queries, running describe_table and find_foreign_keys across the relevant tables saves the back-and-forth of querying information_schema and interpreting the raw results. Especially useful for teams inheriting legacy databases where the schema carries domain knowledge that isn't written down anywhere else.

SchemaCrawler AI is read-only against the catalog. No arbitrary SQL execution, no writes, no migration tooling. For a complete Postgres workflow that includes both schema inspection and query execution, pair it with the official Postgres MCP server. SchemaCrawler handles the "what's in here" phase; the official server handles the "now query it" phase.

9 stars, last push March 23, 2026. Open source project with a long maintenance history. LGPL license. Connection uses standard Postgres JDBC-compatible credentials.

Setup Snippet

Because SchemaCrawler AI is a minor candidate at only 9 stars and its install command varies across the schemacrawler organization's release channels, check the SchemaCrawler AI GitHub repo for the current MCP install instructions. The package is published under the schemacrawler organization; the README documents the active runner and any required Java dependencies.

How to Choose: Decision Framework

Start with where your Postgres runs. Self-hosted instances, any VPS, or cloud providers outside the Supabase/Neon ecosystem (RDS, Cloud SQL, Azure Database) point to the official Postgres MCP as the foundation. It accepts any valid Postgres connection string, exposes a direct SQL execution surface, and has no platform dependencies. Waystation Postgres covers the same ground for teams that prefer a community-maintained alternative with a slightly simpler tool surface. Either gives you the SQL access layer; the choice between them comes down to star count and maintenance preference.

Managed Postgres on Supabase? Supabase MCP. You get SQL access plus platform-level tools (RLS configuration, storage, edge functions) in one server. The official Postgres MCP technically works against a Supabase database over a connection string, but you lose all the platform surface that makes Supabase what it is. The Supabase MCP deep dive covers the full tool surface.

Reach for Neon MCP when the workflow involves schema changes or agent-driven migrations. The branching primitive is what separates it from the others: an agent can make changes against an isolated branch, verify the result, and clean up without touching production. Teams running migration workflows, testing schema changes, or prototyping new data models get meaningful safety guarantees from this model that the other servers do not provide.

Prisma MCP fits when your application uses Prisma as the ORM layer and the workflow involves model-level reasoning. Understanding what a model contains, generating a migration for a new field, applying a migration, checking whether the schema and database are in sync. It is not a general-purpose SQL tool and should not replace the official Postgres MCP for raw query workflows. Both can run simultaneously if a workflow needs both model-level awareness and unrestricted SQL access.

SchemaCrawler AI earns a place in the stack when the task is understanding an unfamiliar or undocumented schema before writing queries. Its catalog-reading tools answer structural questions precisely. Pair it with the official Postgres MCP when you need both schema inspection and query execution in one session.

Browse all 317 servers in the MCPFind databases category with the star filter set to 40+ to see the current adoption tier. Coverage grows weekly as new servers get submitted.

Related Servers in This Category

Next Steps

• How to connect PostgreSQL to Claude using MCP
• Supabase MCP server: full deep dive
• Browse all databases MCP servers on MCPFind
• What is MCP and how does it work?