Database MCP Servers

The official MongoDB MCP server, `mongodb-js/mongodb-mcp-server`, maintained by MongoDB. Searchers find it as the MongoDB MCP server or the Mongo MCP server; both names refer to this one project, and there is no separate short-form server. It is really two tool surfaces in one process. The database tools connect to any MongoDB deployment over a connection string in `MDB_MCP_CONNECTION_STRING` — `find`, `aggregate`, `explain`, `collection-schema`, `collection-indexes`, `create-index`, `count`, `export`, `mongodb-logs` and the write tools — or, if no connection string is set, the model calls the `connect` tool at runtime and passes the returned `connectionId` to later calls. The Atlas tools are a separate control plane: listing and creating clusters, database users, IP access-list entries, stream processing resources and the performance advisor. They authenticate with Atlas Service Account credentials (`MDB_MCP_API_CLIENT_ID` / `MDB_MCP_API_CLIENT_SECRET`), not with a connection string, and they simply do not register when those are unset — the usual cause of a 'the Atlas tools are missing' report. Two defaults are worth knowing before you point it at production. `readOnly` is false, so every write tool including `drop-database` is registered unless you pass `--readOnly`, which is why MongoDB's own README uses that flag in every example. And confirmation-required tools rely on MCP elicitation, so on a client that does not support elicitation they execute without prompting — `--readOnly` or `--disabledTools` is the actual boundary. Other guardrails: `indexCheck` rejects queries that would do a collection scan, server-side JavaScript (`$where`, `$function`, `$accumulator`) is disabled by default, results are capped at 100 documents and 16 MB per call, and `--dryRun` prints the resolved config and enabled tool list without starting the server. Requires Node 22.13.0 or later (Node 20 is deprecated); also published as the `mongodb/mongodb-mcp-server` Docker image. Runs over stdio by default, with an optional HTTP transport and a separate monitoring listener for `/health` and Prometheus `/metrics`.

Supabase MCP Server connects Cursor, Claude Code, Claude Desktop, Windsurf and other MCP clients to a Supabase project, and the first thing to know is that the personal access token setup most guides still describe is gone. Supabase now runs a hosted server at https://mcp.supabase.com/mcp using OAuth 2.1 with dynamic client registration — you add the URL, your client opens a browser, you pick the organization, and there is no PAT to mint or rotate. For Claude Code that is `claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"` followed by `/mcp` in a plain terminal (not the IDE extension) to run the auth flow. Three URL query parameters do the real configuration work: `read_only=true` runs every statement as a read-only Postgres role, `project_ref=<id>` scopes the server to one project and drops the account-management tools entirely, and `features=` selects the tool groups. Those groups are database (list_tables, list_extensions, list_migrations, apply_migration, execute_sql), debugging (get_logs across API/Postgres/Edge Functions/Auth/Storage/Realtime, plus get_advisors for security and performance findings), development (get_project_url, get_publishable_keys, generate_typescript_types), Edge Functions (list, get, deploy), account management, docs search, experimental branching on paid plans, and storage — storage is the one group disabled by default. Running Supabase locally with the CLI exposes a reduced server at http://localhost:54321/mcp with no OAuth; self-hosted installs are similar. The npm package `@supabase/mcp-server-supabase` still exists for stdio clients and also exports `createToolSchemas()` so Vercel AI SDK users get typed tool inputs and outputs. Read Supabase's security best-practices page before pointing this at anything with production data — the mutating tools are real.

Embeddings, vector search, document storage, and full-text search with the open-source AI application database.

High-performance vector database MCP server for AI applications. Store and query vector embeddings for semantic search, RAG pipelines, and similarity matching. Connect your AI assistant directly to your Qdrant collections.

Google's open-source MCP Toolbox for Databases — multi-database MCP server supporting AlloyDB, Cloud SQL, Spanner, BigQuery, PostgreSQL, MySQL, and more. Enterprise-grade connection pooling, auth, and query tools for production AI database access.

The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.

conversational read and write access to any SQLite database file, plus a running business-insights memo that accumulates what the analysis turns up. It is a Python server on PyPI, not a Node one, and the difference is the single most common reason setups fail here: `@modelcontextprotocol/server-sqlite` does not exist on npm, so every npx line for it 404s. The working invocation is `uvx mcp-server-sqlite --db-path /path/to/database.db` (PyPI package mcp-server-sqlite, v2025.4.25), or the equivalent `mcp/sqlite` Docker image with a volume mounted at /mcp. The --db-path argument is required and points at the .db file; the server will create it if it is not there yet. Six tools are exposed, deliberately split by risk: read_query for SELECT only, write_query for INSERT/UPDATE/DELETE, create_table for DDL, list_tables and describe-table for schema introspection, and append_insight, which writes into a memo://insights resource that updates live as findings accumulate — that resource, not the SQL tools, is what makes this server different from a generic database connector. It also ships an mcp-demo prompt that takes a business topic, generates a plausible schema and sample data, and walks through an analysis end to end, which is the fastest way to see the memo behaviour without wiring up real data. One caveat to weigh before adopting it: this is an Anthropic reference implementation that now lives in modelcontextprotocol/servers-archived, archived on 2025-05-28. The published package still installs and runs, but it is frozen — no new features, no dependency updates, and no security patches.

The Redis MCP Server (redis/mcp-redis) is Redis's own natural-language interface for agentic applications, letting an AI client read and write Redis data over the Model Context Protocol. Note which one you install: the server most tutorials still point at is Anthropic's reference implementation, which now lives in modelcontextprotocol/servers-archived, and its npm package @modelcontextprotocol/server-redis is explicitly marked "Package no longer supported" with a last publish of 2025-04-25. The maintained server is a Python package instead, run with uvx --from redis-mcp-server@latest, and it covers far more of Redis than the reference one did: string, hash, list, set and sorted-set tools; JSON document tools; pub/sub with stateful channel and pattern subscriptions; Streams tools including consumer-group create, read, acknowledge and destroy; vector index management and vector search through the query engine; a docs search tool; and a server-management tool for database info. Connection is a redis:// or rediss:// URL passed as --url, or the REDIS_HOST/REDIS_PORT/REDIS_PWD/REDIS_SSL environment variables, with Redis Cluster mode behind REDIS_CLUSTER_MODE and EntraID service-principal, managed-identity and default-credential auth flows for Azure Managed Redis. There is no --read-only flag: the documented way to stop an agent writing is a Redis ACL user (ACL SETUSER readonlyuser on >pw ~* +@read -@write). Ships as a PyPI package, a GitHub install via uvx, and an official mcp/redis Docker image; stdio transport only.

The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.

ClickHouse MCP Server is ClickHouse's official MCP server (ClickHouse/mcp-clickhouse) that connects Claude, Cursor, and other MCP clients to a ClickHouse cluster for fast analytical querying over natural language. Its primary tool, run_query, executes arbitrary SQL against your cluster in read-only mode by default (CLICKHOUSE_ALLOW_WRITE_ACCESS=false) so an AI assistant can explore tables, aggregate billions of rows, and answer analytics questions without risk of mutating data — writes can be enabled explicitly when needed. Companion tools list databases and tables and return schema metadata (including the full create_table_query, with an option to omit per-column detail for lighter responses). A second tool set embeds chDB, ClickHouse's in-process engine, via run_chdb_select_query, letting the assistant query files, URLs, and external databases directly without an ETL step (enabled with the optional mcp-clickhouse[chdb] extra). Destructive statements are gated a second time: even with writes enabled, DROP and TRUNCATE require CLICKHOUSE_ALLOW_DROP=true as well. The server supports both stdio and HTTP/SSE transports; on HTTP/SSE authentication is required rather than optional — startup fails unless a static bearer token (CLICKHOUSE_MCP_AUTH_TOKEN), a FastMCP OAuth/OIDC provider (Azure Entra, Google, GitHub, WorkOS via FASTMCP_SERVER_AUTH), or an explicit local-development opt-out (CLICKHOUSE_MCP_AUTH_DISABLED) is configured. Connection is configured through CLICKHOUSE_HOST, CLICKHOUSE_PORT, CLICKHOUSE_USER, and CLICKHOUSE_PASSWORD, with ClickHouse Cloud, self-hosted, and the public SQL playground all supported.

Neo4j graph database server (schema + read/write-cypher) and graph database backed memory.

The Milvus MCP Server (zilliztech/mcp-server-milvus) is Zilliz's official Model Context Protocol bridge into Milvus, the open-source vector database used for RAG pipelines, semantic search, and large-scale embedding retrieval. It gives an AI agent direct, structured access to a running Milvus instance rather than requiring hand-written client code: milvus_vector_search runs similarity search over embeddings, milvus_text_search performs full-text search, and milvus_hybrid_search and milvus_text_similarity_search combine both approaches (the latter requires Milvus 2.6.0+ with a server-side embedding function configured). Beyond search, the server covers full collection lifecycle management — milvus_list_collections, milvus_create_collection (quick-setup or custom schema), milvus_get_collection_info, milvus_load_collection/milvus_release_collection for memory management, plus milvus_query for filter-expression lookups, milvus_insert_data, and milvus_delete_entities for direct data mutation. It supports three transport modes: stdio (default, for local Claude Desktop/Cursor use), SSE for multi-client HTTP access, and Streamable HTTP with an optional stateless flag for production deployments without session persistence. Install with `uv run src/mcp_server_milvus/server.py --milvus-uri http://localhost:19530` after cloning the repo, or point it at any local or remote Milvus cluster by URI — Python 3.10+ and the uv package manager are the only prerequisites. Works with Claude Desktop, Cursor, and any other MCP-compliant client.

The Airtable MCP Server connects your AI assistant directly to Airtable bases, letting you read records, create entries, update fields, and query structured data using natural language — no manual spreadsheet navigation required. The leading community implementation is domdomegg/airtable-mcp-server, which exposes the full Airtable REST API as MCP tools: list all bases and tables in your workspace, fetch records from any view with optional filter formulas, create or update individual records with typed field values, and delete records by ID. Authentication uses an Airtable personal access token passed as AIRTABLE_API_KEY, scoped to whichever bases you grant access; the token needs at least the schema.bases:read and data.records:read scopes, plus the write scopes if you want the assistant to create or update anything. Airtable itself now also runs an official hosted MCP server at https://mcp.airtable.com/mcp, which uses OAuth instead of a token. Once connected, ask Claude to "show me all leads added this week in my CRM base" or "create a new product entry in my inventory table" and the server handles the API calls. Common use cases include AI-assisted CRM workflows (pull contact records, log meeting notes back into Airtable), inventory management, content calendars, and project tracking where Airtable acts as a lightweight database. Works with Claude Desktop, Cursor, VS Code (Copilot Chat), Windsurf, and any MCP-compatible client. Install via: `npx -y airtable-mcp-server` with `AIRTABLE_API_KEY=pat...` set in your environment.

The Elasticsearch MCP Server (elastic/mcp-server-elasticsearch) is Elastic's official server for connecting AI agents to Elasticsearch data over the Model Context Protocol, enabling natural-language querying, analysis, and retrieval across your indices without building custom APIs. Once connected, an assistant can list available indices, inspect field mappings, and run searches or ES|QL queries described in plain English — "show me the top error messages from the last 24 hours" — against an Elasticsearch 8.x or 9.x cluster. Five tools ship in 0.4.x: list_indices, get_mappings, search, esql and get_shards. Important status note: the README now carries a deprecation caution — the standalone server receives only critical security updates going forward, and Elastic has superseded it with the Elastic Agent Builder MCP endpoint at {KIBANA_URL}/api/agent_builder/mcp, available in Elastic 9.2.0+ and Elasticsearch Serverless projects, which is the recommended path for new integrations. The install route also changed at 0.4.0 and this is the trap: 0.3.1 and earlier were published to npm as @elastic/mcp-server-elasticsearch, that package is now marked deprecated on the npm registry and frozen at 0.3.1 (published 2025-07-01), and 0.4.0 onwards ships only as the Docker image docker.elastic.co/mcp/elasticsearch — so every `npx -y @elastic/mcp-server-elasticsearch` config still circulating installs a version two releases behind with no esql tool. The container supports stdio and streamable-HTTP transports (SSE is deprecated); in HTTP mode it listens on :8080 with the MCP endpoint at /mcp and a health check at /ping. Configure it with the `ES_URL` environment variable pointing at your cluster plus either an `ES_API_KEY` or an `ES_USERNAME`/`ES_PASSWORD` pair for authentication; an optional `ES_SSL_SKIP_VERIFY=true` is available for development-only TLS bypass. Run in stdio mode with `docker run -i --rm -e ES_URL -e ES_API_KEY docker.elastic.co/mcp/elasticsearch stdio` and add the equivalent block to your Claude Desktop, Cursor, or VS Code MCP config.

Interact & query with Meilisearch (Full-text & semantic search API).

The Firebase MCP Server ships as part of the official firebase-tools CLI and gives AI coding tools direct access to your Firebase projects and app codebase. It works with any MCP client, including Firebase Studio, Gemini CLI, Claude Code, Cursor, VS Code Copilot, Windsurf, and Cline. Tool coverage spans project and app management (create, list, and configure Firebase projects and apps); Firebase Authentication user administration; Cloud Firestore and Firebase Data Connect querying, reading, and writing; security-rules retrieval and validation for Firestore, Cloud Storage, and Realtime Database; Firebase Cloud Messaging push notifications; Crashlytics crash-report and issue debugging; App Hosting backend monitoring and log retrieval; Realtime Database read/write; Cloud Functions log queries; and Remote Config template management. No separate install is required — it runs through the existing firebase-tools binary via npx -y firebase-tools@latest mcp, and can be added to Claude Code either as a plugin (claude plugin marketplace add firebase/firebase-tools) or manually with claude mcp add firebase npx -- -y firebase-tools@latest mcp. Because it operates against live Firebase projects, treat it like any tool with write access to production data — review generated security-rules and Firestore write operations before approving them. Labeled "experimental" by the Firebase team as the tool surface continues to expand.

Snowflake ships a first-party, Snowflake-managed MCP server that is Generally Available and needs no infrastructure of your own: you create it as a database object with CREATE MCP SERVER ... FROM SPECIFICATION, and clients reach it over Streamable HTTP at https://<account_url>/api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}. The specification YAML lists the tools the server exposes, drawn from five types — CORTEX_AGENT_RUN (a Cortex Agent, the configuration Snowflake recommends for governed business questions), CORTEX_ANALYST_MESSAGE (text-to-SQL over a semantic view), CORTEX_SEARCH_SERVICE_QUERY (unstructured retrieval), SYSTEM_EXECUTE_SQL (query execution, read_only by default), and GENERIC (any UDF or stored procedure, exposed with its signature as the input schema). Because the server is an object in a schema, access is ordinary Snowflake RBAC: USAGE on the MCP server lets a client discover tools, and each underlying agent, search service, semantic view, function or procedure needs its own grant before that tool can actually be invoked. Authentication is Snowflake OAuth by default, with External OAuth available to bind the server to Okta or Entra ID; dynamic client registration is not supported. The server implements MCP revision 2025-11-25, supports tools only — no resources, prompts, roots or sampling — is non-streaming, and caps each server at 50 tools. The older community server at Snowflake-Labs/mcp (snowflake-labs-mcp on PyPI, last released 1.4.2 in May 2026) is now explicitly deprecated in favour of the managed server; isaacwasserman/mcp-snowflake-server remains as an unaffiliated self-hosted read/write SQL alternative.

managed MCP servers that Databricks runs inside your own workspace, which is why there is nothing to install for the common case — you point an MCP client at a workspace URL and authenticate on behalf of the user with an OAuth scope. The hosted endpoints are /api/2.0/mcp/genie and /api/2.0/mcp/genie/{genie_space_id} for natural-language analytics against a Genie space (scope genie, read-only), /api/2.0/mcp/ai-search/{catalog}/{schema}/{index_name} for retrieval over AI Search indexes (scope ai-search; the older /api/2.0/mcp/vector-search/ path still resolves after the rename), /api/2.0/mcp/sql for running AI-generated SQL including writes (scope sql), and /api/2.0/mcp/functions/{catalog}/{schema}/{function_name} for executing SQL tools stored as Unity Catalog functions (scope unity-catalog). All of them prefix the workspace hostname, and because permissions are enforced on-behalf-of the calling user, an agent can only reach the data and tools that user could reach — the reason most teams choose these over a self-hosted server. For self-hosting there is databrickslabs/mcp, an experimental repo whose Unity Catalog server runs locally over stdio via uv and infers its tool list at startup from the UC functions, vector search indexes and Genie spaces in the schema you point it at; it can also be deployed onto Databricks Apps with databricks bundle or databricks apps, where it is reached over Streamable HTTP at a URL that must end in /api/mcp/ including the trailing slash. Two caveats worth knowing before you build on it: Databricks has marked that Unity Catalog server deprecated in favour of the managed servers, and the developer-tools server in the same repo is still labelled under construction and not usable. The separate databricks-mcp package on PyPI is a client-side helper library from databricks/databricks-ai-bridge (OAuth provider and MCP client plumbing for notebooks, Model Serving and local runs), not a server.

Google's official BigQuery MCP integration ships as part of the MCP Toolbox for Databases (googleapis/mcp-toolbox, 15,800+ stars, formerly published under the genai-toolbox repo name before Google renamed it), a single Go-based server binary that speaks the Model Context Protocol for over a dozen Google Cloud and third-party databases. Rather than a BigQuery-only package, you run the shared toolbox binary with a `--prebuilt=bigquery` flag to instantly load BigQuery-specific tools — schema/table discovery (`list_dataset_ids`, `list_table_ids`, `get_table_info`), running arbitrary SQL via `execute_sql`, and dry-run query validation for cost estimation before executing — over stdio or as an HTTP/SSE server. The quickest install is `npx -y @toolbox-sdk/server --prebuilt=bigquery --stdio` in your MCP client config; it also ships as a downloadable binary and Docker image for teams that prefer not to run via npx. Authentication uses standard Google Cloud credential chains (Application Default Credentials, service account keys, or Workload Identity) rather than embedding a project-specific key. Toolbox also underlies Google's official SDKs for Python, JS/TS, Go, and Java, so the same server config can back both ad hoc AI-assistant queries ("show me the schema for the events table and the row count for last week") and production agent tools built with LangChain, LlamaIndex, or ADK. For teams that want a fully managed remote option instead of self-hosting, Google Cloud also offers managed MCP servers for its databases including BigQuery.

Query and analyze data with MotherDuck and local DuckDB.

The official Pinecone Developer MCP Server (pinecone-io/pinecone-mcp) connects coding assistants like Cursor, Claude Desktop, Windsurf, and the Gemini CLI directly to Pinecone's vector database platform. Once connected, an AI client can search live Pinecone documentation to answer setup and API questions accurately, recommend and configure index settings (dimension, metric, pod vs. serverless type) based on an application's embedding model and scale, generate code for common patterns like batch upserts, hybrid search, and metadata filtering, and — when a `PINECONE_API_KEY` is supplied — directly upsert and query vectors in a live index so a developer can test retrieval quality without leaving their editor. It targets developers building with Pinecone as part of their stack, distinct from Pinecone's separate Assistant MCP, which instead surfaces context from a hosted knowledge base for end-user-facing AI assistants. Install with `npx -y @pinecone-database/mcp` (requires Node.js 18+); without an API key the server still works for documentation search, but index management and querying require one from the Pinecone console. A community alternative, sirmews/mcp-pinecone (150+ stars), offers a lighter Python-based server focused purely on index read/write operations for teams that don't need the documentation-search or code-generation tooling.

Weaviate's Model Context Protocol support has moved from a separate add-on into the core Weaviate database itself: as of v1.37.1, every Weaviate instance ships a built-in MCP server that AI assistants like Claude Desktop, Cursor, and Windsurf can connect to directly, with no standalone process to install or maintain. Enabling it is a single environment variable, `MCP_SERVER_ENABLED=true`, on the Weaviate server; the MCP endpoint then listens on the same port as the existing REST API at `/v1/mcp`, reuses Weaviate's existing API-key authentication, and respects the same RBAC permissions already configured for the cluster — so there is no separate credential or trust boundary to manage. Exposed tools cover the core vector-database workflow an AI agent needs: `weaviate-collections-get-config` inspects collection schemas, `weaviate-tenants-list` enumerates tenants in multi-tenant collections, `weaviate-query-hybrid` runs combined vector-plus-keyword hybrid search, and `weaviate-objects-upsert` creates or updates objects. The earlier standalone Go implementation that used to live in the weaviate/mcp-server-weaviate repository is now deprecated and unmaintained — its git history is kept only for reference — so teams should configure MCP through the main weaviate/weaviate server rather than looking for a separate package to install. Full setup, environment variables, and per-tool RBAC permission mapping are documented at docs.weaviate.io/weaviate/configuration/mcp-server.

The official Qdrant MCP server (qdrant/mcp-server-qdrant) turns the Qdrant vector search engine into a semantic memory layer for AI assistants like Claude Desktop, Cursor, and Windsurf. Built on FastMCP, it exposes two core tools: `qdrant-store`, which embeds and saves a piece of text plus optional JSON metadata into a named Qdrant collection, and `qdrant-find`, which runs a semantic similarity search over a collection and returns the most relevant stored entries. Together they let an AI agent persist facts, code snippets, or past conversation context and recall them later by meaning rather than exact keywords — a lightweight long-term memory that survives across sessions. Configuration is entirely environment-variable driven: point `QDRANT_URL` and `QDRANT_API_KEY` at a Qdrant Cloud cluster or self-hosted instance, or use `QDRANT_LOCAL_PATH` to run against an embedded on-disk database with no server. `COLLECTION_NAME` sets a default collection, `EMBEDDING_MODEL` selects the FastEmbed sentence-transformer used to vectorize text (default sentence-transformers/all-MiniLM-L6-v2), and `QDRANT_READ_ONLY` disables the store tool for query-only deployments. Install with `uvx mcp-server-qdrant` (Python/PyPI) and choose stdio or SSE transport via the `--transport` flag. With 1,450+ GitHub stars it is the reference implementation for giving coding agents durable semantic memory.

Comprehensive tools for managing collections and documents in DataStax Astra DB NoSQL database.

The official PlanetScale MCP server connects AI assistants like Claude, Cursor, and VS Code directly to PlanetScale's serverless MySQL and Postgres database platform. Unlike servers you install as a local package, it is a hosted HTTP server reachable at `https://mcp.pscale.dev/mcp/planetscale`, so any MCP client that supports HTTP-hosted (streamable) transports can connect without a local runtime — in Claude Code, run `claude mcp add --transport http planetscale https://mcp.pscale.dev/mcp/planetscale`, and Cursor and VS Code offer one-click install buttons in the PlanetScale docs. Once connected and authenticated against your PlanetScale organization, an agent can list and inspect databases, branches, and keyspaces, read schema and table structures, run and explain queries, review deploy requests and schema changes, and surface performance insights and query statistics — letting you investigate a production database or plan a migration in natural language from inside your editor. The open-source repo (planetscale/mcp-server) contains the TypeScript tool implementations the team maintains directly; additional production tools are generated from PlanetScale's public API OpenAPI spec and served by the hosted endpoint. Because it targets PlanetScale's Vitess-based horizontal sharding and safe online schema-change workflow (branching and deploy requests), it is especially useful for teams running large MySQL fleets who want AI help without handing an agent raw database credentials.

Turso — the SQLite-compatible edge database built on libSQL — runs a single official hosted MCP server at `mcp.turso.ai`, and tursodatabase/turso-mcp is the repo that packages access to it per-agent and doubles as the plugin marketplace each agent's CLI installs from. Authentication is OAuth 2.1 with PKCE and fully discoverable — a developer runs the install command once, then authenticates in a browser tab where consent (organization, group, and scope) is granted directly on the Turso dashboard, which mints a scoped token; every MCP tool call forwards that token to the real Turso API, so the MCP layer itself holds no standing privilege and all org-binding, roles, and audit logging are enforced server-side, with no API token to generate or paste manually. Because it proxies the full Turso Cloud API, an agent can both manage infrastructure — list organizations and databases, create or delete databases, inspect groups and edge-replica locations — and run SQL directly against a database once it's selected. Claude Code installs it via `/plugin marketplace add tursodatabase/turso-mcp` followed by `/plugin install turso@turso`, then `/mcp` → turso → Authenticate; Codex uses the equivalent `codex plugin` commands; any other MCP-capable client can instead point straight at `https://mcp.turso.ai/mcp` and complete the same OAuth flow. Community alternatives spences10/mcp-turso-cloud and nbbaier/mcp-turso remain options for teams that want a self-hosted server with a manually-supplied API token instead of the hosted OAuth flow.

The official Upstash MCP server (upstash/mcp-server) lets an AI assistant manage and debug your Upstash serverless data infrastructure directly from Claude, Cursor, Windsurf, or any MCP-compatible client. It spans Upstash's product line: serverless Redis databases, the QStash message queue and scheduler, Workflow (durable serverless functions), and Upstash Box. Through it an agent can create and configure Redis databases, run Redis commands and inspect keys, review QStash message logs and scheduled jobs, trace Workflow run logs to debug failures, and read account usage and billing details — turning database provisioning and incident triage into a natural-language conversation inside your editor. Install with `npx -y @upstash/mcp-server@latest --email YOUR_EMAIL --api-key YOUR_API_KEY`, using an email and API key generated at the Upstash Console (Account → API Keys); one-click install configs are provided for Cursor and VS Code. A useful safety feature: when started with a read-only API key, the server automatically disables every state-modifying tool (creating or deleting databases, purging backups, retrying workflows), so an agent can freely read and query your account without any risk of destructive changes. For routine work Upstash also recommends its lighter Skill plus `@upstash/cli` combination, reserving the full MCP server for deeper management and debugging tasks.

Introspect and query your apps deployed to Convex.

Navigate your Aiven projects and interact with PostgreSQL, Kafka, ClickHouse, OpenSearch.

MCP Server for Apache Doris, an MPP-based real-time data warehouse.

Provides AI assistants with a secure way to explore and analyze data in GreptimeDB.

Harper's official MCP component, which exposes data stored in Harper — the composable application platform that merges database, cache, application logic, and messaging into one runtime — to MCP clients as structured Resources. Read this entry with its status in mind: the standalone `mcp-server` repository is archived and read-only, pinned to Harper v4 and preserved for reference only. Harper added a native, first-party MCP feature in v5.1, and that built-in server (documented under the Harper v5 MCP reference) is what you should use on any current release. The archived component still shows how the integration works and remains usable on Harper 4.5.10 or later: it serves a single JSON-RPC 2.0 endpoint at `/mcp`, implements `resources/list` to enumerate every Harper table and custom resource, and `resources/read` to fetch a resource by URI. Resource URIs map cleanly onto the data model — `{HOST}/{table}` for a whole table, `{HOST}/{table}/{primary_key}` for one row, and `{HOST}/{path}/{resource}` for registered custom resources — with query-parameter filtering and limit/start pagination for large tables, plus a static `/capabilities.json` endpoint. Access is read-only by design and is gated by Harper's own role-based, attribute-level security, authenticating via Basic Auth, JWT, or mTLS, so an agent only ever sees rows the calling identity is authorized for. Deployed as a Harper component through the Operations API `deploy_component` call against the published `@harperdb/mcp-server` npm package rather than run as a standalone process.

Build robust data workflows, integrations, and analytics on a single intuitive platform.

Momento Cache for improved performance, reduced costs, and handling load at any scale.

Immutable ledger database with live synchronization.

Postgres re-engineered for B2B apps. Manage databases, tenants, users, auth using LLMs.

Official MCP server for version-controlled Dolt databases.

The official MariaDB MCP Server gives Claude, Cursor, VS Code, and other MCP clients a standardized interface for exploring and querying MariaDB databases, plus a built-in vector store for embedding-based semantic search — so an assistant can inspect schema, run read-only SQL, and retrieve similar documents without a bespoke integration for each task. Core tools cover list_databases, list_tables, get_table_schema and get_table_schema_with_relations (foreign-key-aware), execute_sql (enforces MCP_READ_ONLY by default, restricted to SELECT/SHOW/DESCRIBE), and create_database. When an EMBEDDING_PROVIDER is configured — OpenAI, Gemini, or an open HuggingFace model — the server unlocks a second tool set: create_vector_store and delete_vector_store manage VECTOR-typed tables, insert_docs_vector_store batch-inserts documents with optional metadata, and search_vector_store runs cosine-similarity semantic search over them, effectively turning MariaDB into a lightweight RAG backend alongside its relational data. This dual relational + vector-search design is what differentiates it from a plain read-only SQL wrapper and makes it a fit for teams that want AI-driven analytics and semantic retrieval on the same database without standing up a separate vector store. Built on Python 3.11 and FastMCP, install by cloning the repo and running `uv sync` after installing the `uv` package manager, then configure DB_HOST/DB_USER/DB_PASSWORD/DB_NAME plus optional SSL and embedding-provider variables in a `.env` file before pointing your MCP client at the server entry point. Supports stdio, HTTP, and SSE transports, with FastMCP-based auth recommended for any non-localhost deployment.

Interact with the data stored in Couchbase clusters.

FalkorDB graph database server with schema and read/write-cypher.

Query your data in Memgraph graph database.

Enable LLMs to inspect database schemas and execute queries on Kuzu graph database.

Search data assets, traverse lineage, write SQL queries using DataHub metadata.

Unlock the power of enterprise Data Catalog with tools provided by Alation MCP server.

Interact with your database through Prisma ORM. Query data, run migrations, explore schema, and generate code using AI-directed Prisma operations.

The MySQL MCP Server connects AI assistants directly to MySQL databases, enabling natural-language SQL workflows without a GUI client or hand-written queries. **Install the scoped package, `@f4ww4z/mcp-mysql-server`, not the unscoped one.** The bare name `mcp-mysql-server` on npm belongs to a different author (enemyrr) and a different, smaller project — a name collision, not a mirror — so `npx mcp-mysql-server` installs software other than the repository linked from this page. That distinction is the single most common way this server is installed wrong. Built by f4ww4z (168 stars), it exposes MySQL as callable MCP tools: execute arbitrary SQL, inspect table schemas and column definitions, list databases and tables, describe indexes and constraints, run stored procedures, and manage transactions with commit and rollback control. Typical prompts are "show me the 10 most recent orders," "describe the users table including its indexes," "find customers with no order in 90 days," or "insert a test row into staging and roll it back after I check it." Authentication uses ordinary MySQL connection parameters — MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE — set as environment variables in your client config, so it works against local instances and managed databases alike (Amazon RDS, PlanetScale, DigitalOcean Managed MySQL). Treat the credentials you hand it as the permissions you are handing the model: it can run whatever that user can run, including writes and DDL, so point it at a read-only account for exploration work. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

Query and manage AWS DynamoDB tables using natural language. Supports single-table design patterns, GSIs, and batch operations.

Query and manage Amazon OpenSearch Service clusters. Full-text search, log analytics, and vector search support.

Interface with Apache Cassandra NoSQL clusters. CQL query execution, keyspace management, and wide-column data operations.

Query time-series data stored in TimescaleDB. Analyze IoT metrics, financial data, and application telemetry with SQL and time-series functions.

Distributed SQL database MCP server. Execute transactions, manage schemas, and query CockroachDB with full PostgreSQL-compatible SQL.

Multi-model database MCP server. Query SurrealDB using SurrealQL for graph, document, relational, and time-series data in one system.

High-performance time-series database MCP. Execute SQL queries on QuestDB for real-time analytics on IoT sensor data, financial ticks, and metrics.

Multi-model graph and document database MCP server. Query ArangoDB with AQL, traverse graphs, and manage collections with natural language.

Document database MCP server for CouchDB. Manage documents, views, and design documents. Full MapReduce and Mango query support.

Time-series database MCP for InfluxDB. Write and query metrics using Flux or InfluxQL. Ideal for monitoring, IoT, and observability data.

Business intelligence and analytics MCP for Metabase. Run native SQL queries, access dashboards, create questions, and explore data from any connected database.

Fast open-source full-text search engine MCP. Index documents, run full-text, boolean, and percolate queries. Drop-in SphinxSearch/Elasticsearch alternative.

Open-source data integration platform MCP. Manage connectors, sync data between 300+ sources and destinations, inspect job runs, and debug pipeline failures.

Automated data movement MCP for Fivetran. Manage connectors, schedule syncs, inspect data pipeline status, and analyze data freshness across warehouses.

The dbt MCP Server is dbt Labs’ own first-party server, and it is unusually large: 61 tools across nine toolsets, covering dbt Core, dbt Fusion and the dbt platform from one process. The Discovery toolset reads your project’s metadata graph — get_all_models, get_lineage, get_node_details, get_model_health and get_model_performance answer “what does this model depend on and did it pass last night” without opening the warehouse. The Semantic Layer toolset (list_metrics, query_metrics, get_dimensions, get_metrics_compiled_sql) is the one that makes governed numbers possible: the agent queries your defined metrics rather than inventing SQL against raw tables. The dbt CLI toolset runs build, run, test, compile, parse, show and list against a local project, and the Admin API toolset triggers, retries, cancels and inspects platform job runs. Codegen (generate_source, generate_staging_model, generate_model_yaml), Fusion column-level lineage, and product-docs search round it out. It ships in two flavours. Self-hosted runs beside your client via `uvx dbt-mcp` and is the only flavour that can execute dbt CLI commands or Codegen; the remote server at /api/ai/v1/mcp/ on your dbt platform host needs no install but is consumption-only. Auth is either DBT_TOKEN or an interactive OAuth login that caches its context in ~/.dbt/mcp.yml — and the fallback between them is silent, which is the single most common way a first run appears to hang. Python 3.12 or 3.13 only; 3.14 is blocked on pyarrow wheels.

Open, interoperable map data from the Overture Maps Foundation. Query global geographic features, buildings, transportation networks, and places via AI.

Query and manage Databricks SQL warehouses and Unity Catalog. Run SQL queries, manage tables, inspect job runs, and analyze lakehouse data via AI.

Petabyte-scale data warehouse MCP for Amazon Redshift. Execute SQL queries, analyze query plans, manage clusters, and monitor Redshift Serverless workloads.

Serverless analytical database MCP for MotherDuck (cloud DuckDB). Run OLAP queries on large datasets, query Parquet and CSV files, and share data workspaces.

Unified analytics engine MCP for Apache Spark. Submit jobs, query DataFrames via Spark SQL, inspect execution plans, and analyze large-scale distributed data.

Distributed SQL query engine MCP for Starburst/Trino. Query across multiple data sources including S3, databases, and APIs with federated SQL.

Subscribe to real-time database changes in Supabase via MCP. Listen to row-level changes, broadcast messages, and build live collaborative features.

Manage data pipelines with Google Dataform (BigQuery SQL transformations). Run workflows, manage repositories, and orchestrate data transformation with version control.

Serverless PostgreSQL with branching MCP for Neon. Create database branches for dev/test, auto-scale compute, and manage connection pooling for modern apps.

Manage and query databases through Prisma's ORM MCP. Run Prisma Studio queries, manage migrations, inspect schema, and generate type-safe database access code.

TypeScript ORM MCP for Drizzle. Run type-safe queries, manage schema migrations, explore database structure, and generate SQL for multiple database backends.

AI-native vector database MCP server. Store and query embeddings at scale, perform semantic search, manage vector indexes, and build RAG pipelines using LanceDB's columnar storage engine.

Serverless database platform MCP server. Query and manage Xata databases with built-in search, file attachments, and branching support. Postgres-compatible with AI-optimized features.

Connect to Fauna's distributed serverless database from your AI assistant. Run FQL queries, manage documents and collections, handle relationships, and work with temporal data.

Full-stack backend platform MCP server. Manage Appwrite databases, authentication, storage, and functions from your AI assistant. Create documents, manage users, and trigger serverless functions.

Open-source backend in a single file — now accessible via MCP. Manage collections, records, auth users, and file storage in your PocketBase instance directly from your AI assistant.

AI-native vector database MCP integration. Perform semantic search, manage vector collections, import objects, and run GraphQL queries on your Weaviate instance from any MCP-compatible AI assistant.

Edge SQLite database MCP server. Access Turso databases at the edge with sub-millisecond latency. Query, insert, and manage your Turso database instances — including multi-tenant group databases — from your AI assistant.

HL7 FHIR healthcare data server for querying patient records, clinical resources, and interoperability endpoints. Supports FHIR R4 and SMART on FHIR authentication for HIPAA-compliant healthcare integrations.

Epic EHR FHIR API integration for accessing patient data, clinical notes, lab results, and medications from Epic systems. Uses OAuth 2.0 and SMART on FHIR for secure healthcare access.

Medplum healthcare platform MCP server for clinical workflows, FHIR resource management, and healthcare automation. Query patients, encounters, observations, and clinical documents.

SAP Business Application Studio MCP server for querying SAP ERP data, OData APIs, ABAP objects, and business processes. Access SAP S/4HANA, SuccessFactors, and BTP services.

Microsoft Dynamics 365 MCP server for querying CRM and ERP data via Dataverse Web API. Access accounts, contacts, opportunities, leads, cases, and business data.

InfluxDB time-series database MCP server for querying IoT sensor data, metrics, and time-series records. Execute Flux queries, explore measurements, and analyze trends.

Adobe Commerce / Magento 2 MCP server for querying products, orders, customers, inventory, and store configuration via Magento REST API. Automate catalog management and reporting.

PrestaShop e-commerce platform MCP server for accessing products, orders, customers, and store statistics via the PrestaShop Web Services API.

Oracle Health Cerner EHR integration via FHIR R4 APIs. Access patient demographics, clinical notes, medications, lab results, and care plans from Cerner Millennium systems using SMART on FHIR OAuth2.

Veeva Vault MCP server for pharma and life sciences document management. Query clinical trial documents, regulatory submissions, quality records, and safety data from Veeva Vault repositories.

OpenEMR open-source electronic health records MCP server. Manage patient records, clinical encounters, prescriptions, billing, and reporting via OpenEMR REST and FHIR APIs for self-hosted healthcare systems.

Keystone.js headless CMS and application framework MCP server. Query and mutate content via GraphQL, manage lists and relationships, access Keystone Admin UI data, and run custom hooks via Keystone API.

Oracle Database connectivity via MCP. Execute SQL queries, manage stored procedures and packages, run PL/SQL blocks, inspect schemas, and connect to Oracle ATP, Exadata, or on-premises instances.

Distributed SQL database via TiDB Cloud. Run MySQL-compatible queries at scale, manage multi-region clusters, inspect execution plans, export data to S3, and access TiDB Serverless through the MCP integration.

Distributed SQL database for time-series and documents via CrateDB. Execute SQL queries against machine data, IoT sensor streams, and JSON documents using PostgreSQL-compatible syntax at petabyte scale.

Manage WooCommerce stores via REST API. Query products, orders, customers, and inventory from any WordPress e-commerce site.

Connect to CockroachDB distributed SQL databases. Run queries, manage schemas, and monitor cluster health across regions.

Query time-series data from TimescaleDB. Analyze sensor data, metrics, IoT streams, and time-series analytics at scale.

ClickHouse MCP server maintained by ClickHouse itself, giving an assistant read access to a ClickHouse cluster so it can answer questions against billions of rows without an analyst writing the SQL by hand. Repository corrected 4 August 2026: this listing previously pointed at AminKhorramii/mcp-clikchouse-ts, an unrelated 1-star personal TypeScript project whose name is a typo of "clickhouse", while carrying a 489-star count that belonged to neither repo. The official server is Python, Apache-2.0, and exposes three tools — run_select_query, which executes read-only SELECT statements inside a session where readonly is forced and a row and byte limit is applied, plus list_databases and list_tables for schema discovery so the model can orient itself before querying. Connection settings come from environment variables (CLICKHOUSE_HOST, CLICKHOUSE_PORT, CLICKHOUSE_USER, CLICKHOUSE_PASSWORD, CLICKHOUSE_SECURE, CLICKHOUSE_DATABASE); pointing it at ClickHouse Cloud or the public play.clickhouse.com demo cluster is the fastest way to try it. The same package additionally ships a chDB mode for querying local files and object storage without a server at all. Because every query runs as the credentialed user, the documented practice is a dedicated read-only user with quotas rather than reusing an application account.

Monitor and manage Apache Flink streaming jobs. Submit jobs, check job status, inspect metrics, manage savepoints, and query stateful stream processing pipelines.

Manage Benthos (Redpanda Connect) stream processing pipelines. Create, modify, and monitor data pipelines that process, transform, and route messages between systems.

Query and manage Snowplow behavioral data platform. Access event-level data, build tracking schemas, and analyze customer journeys across web, mobile, and server sources.

Query and manage Turso edge SQLite databases. Execute SQL queries, manage database replicas, handle schema migrations, and work with embedded SQLite at the edge.

Manage Kestra data orchestration workflows. Trigger flows, monitor executions, manage namespaces, and inspect task outputs in this open-source workflow automation platform.

Interact with OpenMRS open-source medical records system. Query patient records, encounters, observations, diagnoses, and medications. Supports FHIR and legacy REST API for healthcare data workflows.

Connect to athenahealth healthcare API for EHR and practice management data. Query appointments, clinical notes, patient demographics, lab results, and billing records from athenaNet.

Integrate with Lightspeed Retail POS and inventory management. Query products, categories, customers, orders, and inventory levels. Manage purchase orders, supplier data, and multi-location stock.

Query Apache Druid real-time analytics database. Run native and SQL queries on time-series data, inspect segment metadata, manage data sources, and analyze ingestion status for high-throughput event streams.

Query Apache Pinot OLAP datastore for real-time analytics at scale. Execute SQL queries, browse schemas, inspect table segments, manage ingestion jobs, and monitor cluster health via REST API.

Query StarRocks high-performance analytical database. Run ANSI SQL on massive datasets, analyze materialized views, inspect table schemas, manage partitions, and monitor query execution plans.

Connect to Acumatica cloud ERP for financial and business data. Access accounts, transactions, inventory, purchase orders, and project records. Automate business workflows via Acumatica REST API.

Connect to Microsoft SQL Server databases via MCP. Execute T-SQL queries, manage stored procedures, inspect schemas, and retrieve data from MSSQL instances including Azure SQL Database and SQL Server on-premises.

Connect to Epicor ERP via MCP. Access manufacturing orders, BOMs, inventory, purchasing, financials, and customer data. Automate shop floor operations, production scheduling, and supply chain workflows for discrete and process manufacturing.

Integrate with Infor CloudSuite ERP via MCP. Access financials, supply chain, manufacturing, HR, and CRM modules. Query BODs (Business Object Documents), trigger workflows, and extract industry-specific data for distribution, healthcare, and manufacturing verticals.

Integrate with AdvancedMD practice management and EHR via MCP. Access patient demographics, appointments, clinical notes, e-prescriptions, billing, and revenue cycle management. Automate scheduling, claim submission, and eligibility verification workflows.

Connect to NextGen Healthcare EHR and practice management via MCP. Access patient charts, clinical workflows, lab results, prescriptions, scheduling, and billing. Query FHIR-compliant data for ambulatory care, behavioral health, and specialty practices.

Integrate with WebPT physical therapy EMR via MCP. Access patient records, evaluations, SOAP notes, treatment plans, billing, outcomes tracking, and scheduling. Automate documentation workflows and compliance reporting for outpatient rehab practices.

Connect to Vendure headless e-commerce framework via MCP. Access products, collections, orders, customers, inventory, promotions, and payment methods via GraphQL. Automate catalog management, order processing, and storefront data workflows for custom e-commerce builds.

Integrate with Alation data intelligence platform via MCP. Search the enterprise data catalog for tables, columns, queries, and business glossary terms. Access data quality scores, stewardship assignments, lineage graphs, popularity rankings, curation status, and policy tags. Automate data discovery and compliance classification workflows.

Connect to Atlan modern data catalog via MCP. Query assets across databases, BI tools, dbt models, and Airflow DAGs. Access business context annotations, data quality dimensions, column-level lineage, ownership assignments, PII classification tags, and collaboration activity. Automate data contract validation and governance policy enforcement.

PointClickCare API — access EHR and billing data for skilled nursing, assisted living, and home health settings. Retrieve resident care plans, manage MDS assessments, track medication administration records, and integrate with LTPAC financial workflows.

Netsmart myEvolv and CareFabric API — manage behavioral health and human services EHR data, retrieve treatment plans, track community-based care episodes, manage IDD service records, and access HIPAA-compliant patient engagement workflows.

Airbyte open-source data integration platform API — manage 300+ connectors, trigger ELT sync jobs, monitor connection health, view sync logs, and orchestrate data pipeline runs between sources (SaaS, databases, APIs) and destinations (warehouses, lakes).

Hightouch reverse ETL and audience platform API — sync data warehouse segments to 200+ business tools (CRMs, ad platforms, email tools), manage audience definitions, trigger sync runs, monitor sync health, and operationalize warehouse data for marketing and sales.

Meltano open-source DataOps platform MCP — manage Singer taps and targets, orchestrate ELT pipelines, configure extractors and loaders, run data integration jobs, and track pipeline state across your data stack.

Marqo tensor search and vector database MCP — index and search multimodal content (text, images), manage indexes, perform semantic search, run hybrid lexical-vector queries, and build AI-native search experiences.

YugabyteDB distributed SQL database MCP — run queries on PostgreSQL-compatible distributed clusters, manage universes, inspect node health, scale clusters, and leverage YSQL and YCQL APIs for multi-region deployments.

SingleStore real-time analytics database MCP — run SQL queries, manage workspaces, inspect pipeline status, query vector data alongside relational data, and leverage SingleStore Kai MongoDB API compatibility.

Payload CMS headless content management MCP — query and mutate collections, manage globals, handle media uploads, run access control queries, and interact with your TypeScript-native headless CMS REST and GraphQL APIs.

Estuary Flow real-time data streaming MCP — manage CDC (change data capture) pipelines, inspect catalog specs, monitor collection health, query data flow status, and orchestrate streaming ETL between databases and data warehouses.

Vitess MySQL-compatible distributed database clustering MCP — run queries on Vitess clusters, inspect shard topology, manage keyspaces, query VTAdmin API, and operate MySQL at scale with horizontal sharding and connection pooling.

Redash open-source data visualization MCP — run SQL queries against connected data sources, browse existing dashboards, retrieve query results, manage data source configurations, and share analytical insights across your team.

Lightdash open-source BI for dbt — an MCP server that lets an assistant query the metrics and dimensions defined in your dbt project, run Lightdash explores, retrieve chart and results data, list spaces and dashboards, and bring governed, version-controlled analytics into AI workflows. It talks to your Lightdash instance with an API key plus project UUID, so answers stay grounded in the same metric definitions your team already trusts rather than ad-hoc SQL. Install the maintainer's package with `npx lightdash-mcp-server` (repo syucream/lightdash-mcp-server). Note: the shorter npm name `lightdash-mcp` is a different, unaffiliated project (timeleft-dev) — use `lightdash-mcp-server` for the server documented here.

Holistics self-service BI platform MCP — run reports, query semantic layer datasets, access dashboard data, manage data models, and retrieve analytical results from your Holistics workspace for AI-powered business analysis.

Great Expectations data validation MCP — run expectation suites against data assets, retrieve validation results and data docs, manage checkpoints, query expectation store configurations, and surface data quality failures across your pipeline for AI-assisted debugging.

Feast open-source feature store MCP — retrieve feature values for online inference, query historical feature data for training, manage feature views and entities, browse the feature registry, monitor feature freshness, and inspect feature statistics for ML pipelines.

WSO2 FHIR MCP Server — expose any FHIR-compliant healthcare API as an MCP server. Supports HL7 FHIR R4/R5, CRUD operations on Patient, Observation, Condition, Medication, and all standard FHIR resources. Enterprise-grade with OAuth 2.0.

Apache IoTDB's official MCP server — interact with Apache IoTDB time-series database for IoT workloads. Execute SQL queries, manage time-series data, access device telemetry, run IoTDB SQL and tree-model dialects for industrial IoT applications.

Official Redis Cloud MCP server — create, configure, and manage Redis Cloud databases via natural language. Manage subscriptions, databases, security rules, and access control. Built by Redis to bring AI-native control to the Redis Cloud platform. It is a control-plane server, not a data server: it manages subscriptions, databases, payment methods, modules, regions and long-running tasks through the Redis Cloud API, and cannot read or write keys inside a database — that is the separate redis/mcp-redis server. There is no published npm package; the documented setup is to clone the repository, run npm run build, and point your client at node dist/index.js with API_KEY and SECRET_KEY set to Redis Cloud API credentials.

Local-first MCP server for Microsoft Fabric analytics platform. Access lakehouses, warehouses, pipelines, Power BI reports, and Spark notebooks via AI agents. Query item definitions, manage workspaces, and leverage Fabric REST APIs for unified analytics.

MCP server to query Azure Resource Graph for AI-powered infrastructure analysis. Retrieve and filter information about Azure resources across subscriptions using KQL, manage ARM deployments, and explore resource relationships with natural language queries.

MCP server for Elastic Security SIEM and observability. Query indices, search security events, manage detection rules, analyze endpoint alerts, and run EQL/KQL searches across Elasticsearch clusters. Integrates with Elastic's security analytics and threat hunting workflows.

MCP server for Senzing entity resolution and data matching engine. Resolve duplicate records, match entities across disparate datasets, query entity relationships, and run probabilistic matching via Senzing REST APIs. Essential for KYC, fraud detection, and master data management workflows.

This is the same official pinecone-io/pinecone-mcp server viewed through its RAG-pipeline and production-index angle. Beyond documentation search, teams use it to script batch upserts of embeddings into Pinecone indexes, run similarity queries with metadata filters and namespace scoping to test retrieval quality for a RAG application, and manage serverless vs. pod-based index configuration directly from an AI coding assistant — useful when iterating on chunking strategy, embedding model choice, or reranking logic without leaving the editor. Supports namespaces for multi-tenant applications and metadata filtering for hybrid structured/vector search. Install with `npx -y @pinecone-database/mcp` and a `PINECONE_API_KEY` from the Pinecone console (Node.js 18+ required); documentation-search tools work even without a key, but index read/write requires one. Maintained directly by Pinecone at 70+ GitHub stars.

Open-source embedding database for AI applications. Store and query embeddings with metadata filtering for RAG workflows. Supports multiple embedding functions and runs locally or in the cloud.

High-performance vector database for billion-scale similarity search via Milvus MCP. Manage collections, insert vectors, run ANN search, and build production RAG systems with hybrid search combining dense and sparse vectors.

Real-time data analytics at scale via Tinybird's API. Query billions of rows with sub-second latency, publish data APIs, and build streaming analytics pipelines. Query your Tinybird workspace with natural language via MCP.

Serverless analytics with DuckDB in the cloud via MotherDuck MCP. Run analytical SQL queries on local and cloud data, create hybrid local-cloud databases, and leverage DuckDB's powerful OLAP capabilities at scale.

Automated data integration via Fivetran's API. Manage connectors, trigger syncs, monitor replication status, and inspect schemas across 500+ data sources. Automate ELT pipeline operations from your AI assistant.

SQL transformation framework with semantic understanding via SQLMesh MCP. Run plans, evaluate models, view lineage, inspect virtual data environments, and manage deployment lifecycle for modern data stacks.

Fast vector search database optimized for cold starts and serverless workloads. Full-text and vector search with metadata filtering. Ideal for RAG applications requiring sub-millisecond query performance at low cost.

Enterprise search and vector database via Vespa's APIs. Deploy applications, feed documents, run queries combining BM25 and vector search, and manage ML models. Powers recommendation, RAG, and hybrid search at scale.

IBM watsonx.data lakehouse integration via MCP. Query document libraries, run natural language analytics against IBM's data lakehouse platform, retrieve structured data using the watsonx.data AI-powered retrieval service, and interact with enterprise data stored in watsonx.

IBM MDM (Master Data Management) integration via MCP. Search and retrieve master data records, manage customer/product/supplier MDM entities, query cross-reference data, and perform entity resolution operations via Claude and other AI assistants.

IBM Data Intelligence unified MCP gateway for the watsonx ecosystem. Exposes and manages MCP tools across microservices in IBM's Data Intelligence platform, enabling AI agents to access data catalogs, lineage information, quality metrics, and enterprise data governance tools from a single endpoint.

Cloudflare Workers development MCP server for on-the-fly application building with D1 databases, R2 object storage, KV stores, and other Workers bindings. Create tables, query data, upload objects, and manage Workers primitives directly from AI tools as you build Cloudflare applications.

Salesforce Data 360 MCP server (Developer Preview, May 2026). Access unified customer data across Salesforce clouds, query Data Cloud segments and profiles, run identity resolution lookups, retrieve calculated insights, and connect AI agents to Salesforce's real-time customer data platform.

Inductive Automation Ignition SCADA/MES gateway MCP server. Browse OPC-UA tags, read historian data, and interact with Ignition projects via AI.

Nhost open-source Firebase alternative MCP server. Interact with Hasura GraphQL APIs, authentication, storage, and serverless functions on your Nhost backend.

Back4App managed Parse Server platform MCP integration. Query and mutate Parse objects, manage users, and trigger cloud functions on your Back4App backend.

Self-hosted Parse Server MCP connector. Perform CRUD operations on Parse collections, manage files, push notifications, and run cloud code functions.

The Graph Protocol indexing MCP server. Query blockchain data from thousands of subgraphs on Ethereum, Polygon, Arbitrum, and other EVM chains via GraphQL.

CMS Blue Button 2.0 API MCP server. Access Medicare beneficiary claims data, Part A/B/D information, and FHIR R4 health records with patient consent.

Veradigm (formerly Allscripts) clinical data MCP server. Access ambulatory EHR data, e-prescribing, and practice management via Veradigm APIs.

ElectricSQL local-first sync MCP server. Sync SQLite data between clients and Postgres server in real-time. Query local replicas, manage sync rules, and monitor replication state.

PowerSync offline-first sync MCP server. Query synced SQLite databases, manage sync rules, monitor client sync state, and build offline-capable apps with Postgres or MongoDB backends.

Evolu local-first SQLite MCP server built for privacy and data ownership. Query your Evolu database, manage CRDT-based sync, and work with end-to-end encrypted local data.

CR-SQLite conflict-free replicated SQLite MCP server. Run multi-master SQLite with CRDTs, merge concurrent writes without conflicts, and build collaborative local-first applications.

A dedicated Cloudflare D1 MCP server could not be confirmed to exist. Cloudflare publishes a suite of official MCP servers at cloudflare/mcp-server-cloudflare, but as of the 2026-08-18 check that repository contains no D1 application and the d1.mcp.cloudflare.com endpoint does not resolve. The npm package this entry previously advertised has never been published, and the repository it linked was cloudflare/workers-mcp, a different product. The closest working options are the official Workers Bindings server, which reaches D1 through a Worker binding, or a small community project such as semanticintent/semantic-d1-mcp — neither is a Cloudflare-published D1 server. This entry is kept unresolved rather than deleted so the claim is on the record and can be corrected the moment Cloudflare ships one.

Metabase open-source BI and analytics MCP server. Run questions and dashboards, query your Metabase data, manage collections, and access business intelligence programmatically.

Query and manage Google Firestore collections, documents, subcollections, and real-time listeners.

Connect to Google AlloyDB for PostgreSQL-compatible queries, connection pooling, and cluster management.

Execute SQL queries and manage schemas on Google Cloud Spanner — global distributed relational database.

Read and write Google Cloud Bigtable rows, manage column families, and run time-series queries at scale.

Django web framework integration — inspect models, run management commands, query ORM, and manage migrations.

Ruby on Rails integration — inspect models, run console commands, manage migrations, and explore routes.

Laravel PHP framework integration — artisan commands, Eloquent ORM queries, route inspection, and queue management.

Apache Superset data visualization — query datasets, explore charts, and retrieve dashboard metrics via MCP.

HIPAA-compliant secure data vault API — store, encrypt, and retrieve Protected Health Information (PHI) with full audit logging. Supports BAA agreements, de-identification workflows, and consent management for healthcare applications.

Cerner Millennium FHIR API connector — access patient demographics, clinical data, encounters, and orders from Oracle Health EHR systems.

HAPI FHIR open-source server integration — manage FHIR resources, run CQL queries, and interact with self-hosted or public FHIR endpoints.

QuestDB high-performance time-series database — ingest sensor data, run SQL queries on time-series data, and visualize real-time metrics.

The KDB-X MCP Server is maintained by KX themselves (KxSystems/kdb-x-mcp-server) and lets an LLM query KDB-X data in natural language. One expectation to correct up front: despite kdb+ being a q database, the query tool here takes SQL, not q — `kdbx_run_sql_query` executes a SQL SELECT and returns JSON capped at 1,000 rows. That cap is a guardrail, not a limitation to work around; the server is built to keep a model inside safe, bounded reads. Two other tools cover retrieval: `kdbx_similarity_search` runs vector similarity over a KDB-X table, and `kdbx_hybrid_search` combines dense-vector and sparse-text search on the same table, both taking an optional result count. Alongside the tools it exposes MCP resources rather than leaving schema discovery to guesswork — `kdbx://tables` returns every table with schema information and sample rows, and `file://guidance/kdbx-sql-queries` ships KX-authored SQL syntax guidance and examples straight into the model context. Prompts such as `kdbx_table_analysis` generate statistical or data-quality analysis plans for a named table. The framework auto-discovers anything you drop into the tools/resources/prompts directories, and includes `_template.py` starters, so extending it with in-house tools does not mean forking the request plumbing. Setup needs uv, a running KDB-X (or KDB+) instance, and npx if you use streamable-http transport with Claude Desktop; stdio is also supported.

Access and query HL7 FHIR-compliant healthcare APIs for patient records, clinical data, and medical resources.

Access Veeva Vault and CRM for life sciences, pharma commercial data, and clinical content management.

Connect to ScyllaDB, the high-performance Cassandra-compatible database, for ultra-low latency NoSQL queries and data operations at scale.

No maintained, adopted MCP server for Apache HBase exists as of August 2026. What is out there: CDataSoftware/apache-hbase-mcp-server-by-cdata, a read-only Java connector that reaches HBase through CData's JDBC driver (so it carries a commercial driver dependency, and it sits at zero stars), and j1187049781/phoenix-mcp-server, which targets Apache Phoenix — the SQL layer over HBase — rather than HBase directly, and is likewise unproven. Neither is something we can recommend as a default. If you need an assistant to query HBase now, the pragmatic path is usually Phoenix plus one of the mature generic SQL MCP servers rather than a bespoke HBase integration, since Phoenix presents HBase as JDBC-addressable tables that a general database server can already speak to. Worth knowing for context: the well-known Python client library for HBase, happybase, was marked unmaintained by its authors — it is a library, not an MCP server, and a catalog entry that links to it is describing the wrong kind of thing. This entry deliberately records no github_url until a real, maintained HBase MCP server appears.

Query VictoriaMetrics for fast, cost-effective time-series data storage and analytics — compatible with Prometheus and Graphite.

Scale PostgreSQL horizontally with Citus — run distributed queries, shard management, and parallel analytics through AI-driven data workflows.

Query EdgeDB — the next-generation graph-relational database with a built-in type system, schema migrations, and EdgeQL through AI agents.

Baserow MCP Server connects MCP clients like Claude Desktop, Cursor, and Windsurf to Baserow, the open-source no-code database platform, so AI assistants can manage workspaces, databases, tables, and rows through plain-English requests instead of clicking through the Baserow UI. The server exposes 21 tools across five groups: authentication (login with username/password for automatic token refresh, or set a manual JWT/database token directly), workspace management (list/get/create/set-active), database management (list/get/create within a workspace), table management (list/get with full field definitions/create), and row operations (get, create, update, delete, plus batch create/update/delete for bulk edits). Typical use cases include "show me all my Baserow workspaces," "create a Project Tracker database," "add a Tasks row with status In Progress," or "delete all Archive rows older than 30 days." Authentication supports both self-hosted and cloud Baserow instances via a configurable API URL. Built in TypeScript for Node.js 22+, distributed as source (clone + npm install + npm run build, then point your MCP client at the compiled start.sh script) rather than a published npm package. MIT licensed, actively maintained by an independent developer.

Connect to SAP Business One ERP for SME business management including accounting, inventory, sales orders, purchase orders, and production workflows via DI API.

Query and manage Apache Cassandra distributed NoSQL database with CQL support, keyspace management, table operations, and data modeling assistance.

The Graph MCP server gives an AI assistant read access to indexed blockchain data through The Graph, the decentralized indexing protocol that turns on-chain events into queryable GraphQL subgraphs. It exposes two tools. getSubgraphSchema fetches the schema of a subgraph by its ID and can return it either as JSON or as human-readable GraphQL, which matters because it is what lets the model discover the entities and fields available before it writes a query — without it the assistant is guessing at field names. querySubgraph then executes a GraphQL query against that subgraph ID; queries are normally generated by the model from the schema it just read, but hand-written queries work identically. Together they let you ask questions like "top five tokens by 24h volume in this subgraph" or "all pairs with liquidity above $1M" in natural language, against DeFi, NFT-marketplace, or any other indexed protocol data, with no archive node and no local indexing stack. The server is Python (3.10+) and is run from a checkout rather than a package: clone the repo and point your client at it with uv, supplying a THEGRAPH_API_KEY from The Graph Studio for gateway access.

Connect to Oracle Health clinical information systems for patient data, clinical workflows, CareAware IoT device integration, and population health management via HL7 FHIR APIs.

Integrate Medidata Rave EDC and Medidata Clinical Cloud for clinical trial data capture, site management, patient recruitment analytics, and regulatory submission workflows.

Connect to OSIsoft PI System (AVEVA) for time-series operational data, PI Web API queries, historian data, asset framework, and industrial data analytics for OT/IT integration.

Query AWS HealthLake FHIR-compliant data lake for clinical analytics, population health management, ML-powered health insights, and HIPAA-eligible healthcare data storage.

Connect to Multiple Listing Service data via RETS/RESO Web API for property listings, sold data, agent rosters, open houses, and real-time IDX feeds.

Manage Apache Kafka clusters — topic management, consumer groups, message production/consumption, schema registry, Kafka Connect connectors, and cluster health monitoring.

Submit and manage Apache Spark jobs, query Spark SQL, monitor job execution, manage DataFrames, and orchestrate batch/streaming data processing pipelines.

Govern Databricks Unity Catalog — data lineage, access controls, table and column-level permissions, data discovery, quality monitoring, and cross-workspace catalog sharing.

Query and manage Elasticsearch, Kibana dashboards, and Elastic APM — search indices, run aggregations, retrieve APM traces, manage indices, and build log analysis workflows.

Connect to Palantir Foundry for enterprise data integration, ontology management, pipeline orchestration, and AI-driven analytics across large-scale datasets and operational workflows.

Interact with Databricks Lakehouse Platform — run Spark jobs, query Delta tables, manage Unity Catalog assets, trigger ML pipelines, and access Feature Store and Model Serving endpoints.

Connect to Neon serverless PostgreSQL — run SQL queries, manage database branches for dev/test/prod isolation, scale to zero automatically, and use point-in-time restore for safe schema migrations.

Manage PlanetScale MySQL-compatible serverless databases — run queries, manage database branches, deploy schema changes with non-blocking DDL, review deploy requests, and monitor query performance.

Interact with YugabyteDB distributed SQL — run YSQL and YCQL queries, manage clusters across cloud regions, monitor replication lag, and handle distributed transactions at scale.

Query data across any source with Starburst Galaxy (Trino-based) — run federated SQL across S3, Snowflake, BigQuery, PostgreSQL, and 50+ connectors without moving data.

Execute distributed SQL queries with Trino (formerly PrestoSQL) — query data across Hive, Iceberg, Delta Lake, and dozens of connectors with ANSI SQL and sub-second interactive analytics.

Run real-time analytics with Rockset — execute SQL on streaming data with sub-second latency, manage collections and query lambdas, and build live dashboards on continuously updating datasets.

Query Firebolt cloud data warehouse — execute sub-second analytics SQL on massive datasets using Firebolt's indexing engine, manage engines and databases, and run workload-optimized queries.

Access Informatica Intelligent Data Management Cloud — run data integration tasks, manage mappings and mapplets, execute data quality rules, and orchestrate MDM and data governance workflows.

Control Stitch data pipelines (Talend) — manage source integrations, trigger sync jobs, monitor replication status, configure extraction schedules, and audit data loads into your warehouse.

Integrate with Informatica PowerCenter for enterprise ETL — start and stop workflows, monitor session logs, manage repository folders, and query domain and service metadata programmatically.

Access Mode data analytics platform — run SQL reports and Python/R notebooks, query report results, manage data connections and schema browsers, share analyses, and embed charts in external dashboards.

Connect to Hex collaborative analytics workspace — run SQL and Python cells, retrieve app outputs and chart data, manage projects and schedules, share results, and trigger automated Hex app refreshes via API.

Run analytics on Google BigQuery — execute SQL queries on petabyte-scale datasets, manage datasets and tables, schedule and monitor query jobs, stream inserts, handle partitioning and clustering, and query billing cost estimates.

Query and write IoT time series data in InfluxDB — execute Flux and InfluxQL queries, write sensor measurements with tags and fields, manage retention policies and downsampling tasks, monitor continuous queries, and build real-time dashboards via API.

Query and mutate Fauna serverless database — run FQL (Fauna Query Language) queries, manage collections, indexes, and documents, handle multi-tenant isolation with database hierarchies, execute transactions with optimistic concurrency, and stream real-time change events.

Interact with Supabase projects — run SQL queries via PostgREST, manage Auth users and permissions, upload and retrieve Storage objects, invoke Edge Functions, query Realtime subscriptions, and access project configuration and database migrations via Supabase Management API.

Access REDCap clinical research databases — export records, retrieve instrument definitions and data dictionary, import data via REDCap API, manage project users and access rights, pull survey responses, and generate reports. HIPAA-ready for institutional IRB-approved research workflows.

Manage distributed in-memory computing via Hazelcast — query and update distributed maps, sets, queues, and lists; execute entry processors; manage distributed locking and semaphores; retrieve cluster member statistics and partition distribution; query SQL over in-memory data; manage near-cache and eviction policies; and monitor WAN replication status via Hazelcast Management Center REST API.

Interact with Apache Ignite distributed computing platform — execute SQL queries over distributed caches, manage cache configurations and eviction policies, retrieve cluster node topology and metrics, run compute tasks on the grid, access persistence store metrics, monitor replication and partition ownership, manage service grid deployments, and query continuous query registrations via Ignite REST API.

Use Momento serverless cache and topics via the Momento API — get and set cache items with TTL, manage cache namespaces, publish and subscribe to Momento Topics for real-time messaging, retrieve collection data types (lists, sets, sorted sets, dictionaries), manage leaderboards, query usage metrics, and handle cache miss callbacks via the Momento HTTP API.

Access Upstash serverless Redis and Kafka via REST APIs — execute Redis commands over HTTP (GET, SET, HSET, ZADD, etc.), manage databases and replicas, subscribe to Upstash Kafka topics, produce and consume messages, query QStash message queues and schedules, access rate limit APIs, retrieve usage and billing data, and manage database configurations via the Upstash REST API.

Query and manage Materialize streaming SQL — create and query materialized views over real-time data streams, manage sources from Kafka and PostgreSQL, retrieve view freshness and replication lag metrics, execute incremental SQL queries, manage clusters and replicas, access audit log data, query system catalog tables, and monitor dataflow operator metrics via Materialize REST and PostgreSQL wire protocol.

Interact with RisingWave distributed streaming SQL database — create materialized views over Kafka and S3 sources, execute real-time analytical queries, manage sources and sinks, retrieve streaming job progress and backfill status, query system tables for metrics, access CDC source connectors, monitor memory and CPU utilization per actor, and export materialized view results via PostgreSQL protocol.

Manage ELT pipelines via Stitch (Talend Cloud) — configure data source connections, manage integration schedules and replication keys, query extraction and loading status, monitor pipeline health and errors, access source schemas and table configurations, manage destination warehouses, pull data freshness metrics, and orchestrate multi-source data consolidation into analytics warehouses.

Orchestrate cloud data transformation via Matillion ETL — manage jobs and pipelines, trigger transformation workflows, query job execution history and logs, manage environment configurations and variables, access component libraries for data transformation, handle API and database source connections, monitor pipeline performance, and build data engineering automation for Snowflake, Redshift, and BigQuery.

Work with Redis Streams for real-time data pipelines — publish events to streams, consume with consumer groups, manage stream trimming and maxlen, query XREAD and XRANGE, handle pending message acknowledgment, manage consumer group offsets, pull stream statistics, integrate with pub/sub channels, and build event-driven architectures using Redis Streams as a message broker.

Integrate IDEXX veterinary diagnostics via their VetConnect PLUS API — retrieve in-clinic and reference lab diagnostic results, CBC and chemistry panels, urinalysis reports, and pathology findings; access SNAP rapid test results, digital radiology images, and ultrasound reports; manage patient records in practice management systems; pull quality control metrics and reference range comparisons.

Access Dynamics 365 Dataverse for CRM, sales, customer service, field service, and ERP data via Power Platform APIs.

Interact with Apache NiFi data flow pipelines via the NiFi REST API — query and manage process groups, processors, and connections, start and stop flow components, retrieve provenance data, monitor queue depths and data lineage, manage controller services, deploy flow templates, and build AI-assisted data pipeline monitoring and orchestration workflows.

Orchestrate and monitor Apache Beam data processing pipelines via the Beam API — submit pipeline jobs to Dataflow, Spark, or Flink runners, retrieve job status and metrics, access pipeline graphs, query transformation outputs, manage job state and cancellations, and integrate Beam pipeline management into AI-driven data engineering workflows.

Query data lakes and lakehouses via Dremio's SQL query engine — run Dremio SQL queries across S3, Azure ADLS, and GCS data sources, reflect and accelerate queries with Dremio Reflections, manage virtual datasets and spaces, access Apache Arrow Flight for fast query results, catalogue and tag data sources, and power AI-driven analytics over petabyte-scale lake storage.