MCP

OpenSearch documents an open-source Model Context Protocol server at docs.opensearch.org/latest/ai-agent-integrations/mcp-server for AI assistants to interact with OpenSearch clusters via MCP tools instead of raw REST. The opensearch-project/opensearch-mcp-server-py package supports stdio (Claude Desktop, Cursor, Kiro) and streaming transports (SSE/Streamable HTTP) with tools for listing indexes, retrieving mappings, running search queries, checking cluster health, and counting documents per docs. Configure single-cluster mode via environment variables or multi-cluster YAML; authentication supports basic auth, IAM, header auth, and mTLS for self-managed OpenSearch, Amazon OpenSearch Service, and Serverless. OpenSearch 3.0+ also ships an experimental in-cluster MCP endpoint at `/_plugins/_ml/mcp` (Streamable HTTP) per ML Commons docs—distinct from the standalone py server for external clients.

The fogx/typesense-mcp project provides a community Model Context Protocol server for querying and managing Typesense search indices via stdio. Configure a TOML file with one or more `[[sources]]` blocks (id, host, api_key, collections patterns, optional readonly, port, protocol) and launch with `npx -y typesense-mcp path/to/typesense-mcp.toml` per the README. Tools include `search` for full-text, vector, or hybrid search; `lookup` for collections, schema, documents, counts, aliases, and synonyms; and `manage` for upserts, deletes, collection/synonym/alias writes when at least one source is not readonly. Collection patterns gate access; readonly sources block writes and hide `manage` when all sources are readonly. A `collection://{source}/{collection}` resource exposes field schemas. Pairs naturally with the Typesense tool entry on this site for agent-driven index exploration.

Algolia documents an official managed Model Context Protocol server at algolia.com/doc/guides/model-context-protocol/productivity-mcp. Connect MCP clients to the remote HTTP endpoint `https://mcp.algolia.com/mcp` with OAuth (enable under Generate AI in the Algolia dashboard; sign in when prompted so the MCP inherits your account permissions). Productivity MCP is user-scoped and read-only per docs—tools cover search (`algolia_search_list_indices`, `algolia_search_index`, `algolia_search_for_facet_values`), Recommend (`algolia_recommendations`), and analytics helpers such as top searches, no-click rates, filter usage, and user counts. Algolia docs distinguish this from Algolia Public MCP for application-scoped, curated index exposure to external agents. Supported clients include ChatGPT, Claude, Claude Code, Cursor, Gemini CLI, VS Code, and OpenAI Playground.

ClickHouse documents a fully managed remote Model Context Protocol server for ClickHouse Cloud at clickhouse.com/docs/cloud/features/ai-ml/remote-mcp. Connect MCP clients to the HTTP endpoint `https://mcp.clickhouse.cloud/mcp` with OAuth 2.0 (browser sign-in with ClickHouse Cloud credentials; no separate API key required per docs). Agents can list databases and tables, inspect schemas, and run scoped read-only SELECT queries; the remote server also exposes richer ClickHouse Cloud integration such as service management, backup monitoring, ClickPipe visibility, and billing data per ClickHouse docs. Enable per service in the Cloud console (Connect → MCP). For self-hosted ClickHouse, ClickHouse maintains the separate open-source mcp-clickhouse project—distinct from this Cloud remote MCP.

Meilisearch maintains an official Model Context Protocol server in meilisearch/meilisearch-mcp, documented at meilisearch.com/blog/introducing-mcp-server. The Python stdio server connects MCP clients to any running Meilisearch instance via `MEILI_HTTP_ADDR` and optional `MEILI_MASTER_KEY`, with `update-connection-settings` to switch hosts mid-session. Tools cover index management, document ingestion, search (filters, sorting, facets, semantic/hybrid), settings, API keys, tasks, and health checks per the README. Install paths include `uvx meilisearch-mcp`, pip, source, and Docker (`getmeili/meilisearch-mcp`). Meilisearch notes the server is development-oriented and that native Meilisearch MCP transport support is coming.

Google Cloud documents remote Agent Platform (Vertex AI) Model Context Protocol servers at docs.cloud.google.com/gemini-enterprise-agent-platform/reference/mcp and docs.cloud.google.com/mcp/supported-products. The managed HTTP endpoints include `https://aiplatform.googleapis.com/mcp` plus toolset-specific paths such as `/mcp/generate`, `/mcp/predict`, `/mcp/notebook`, `/mcp/endpoints`, `/mcp/models`, `/mcp/tuning`, `/mcp/evaluation`, and `/mcp/prompts`. Documented toolsets cover generative AI, prediction, Colab Enterprise notebooks, endpoint management, model registry, finetuning, quality evaluation, and prompt management. Authentication uses OAuth 2.0 with IAM per Google Cloud MCP overview; API keys are not accepted on remote Google Cloud MCP servers.

Google Cloud documents a remote BigQuery Model Context Protocol server at docs.cloud.google.com/bigquery/docs/use-bigquery-mcp, enabled when the BigQuery API is enabled. Connect MCP clients to the managed HTTP endpoint `https://bigquery.googleapis.com/mcp` with OAuth 2.0 and IAM (API keys are not accepted). Documented IAM roles include MCP Tool User (`roles/mcp.toolUser`), BigQuery Job User (`roles/bigquery.jobUser`), and BigQuery Data Viewer (`roles/bigquery.dataViewer`). Tools include `execute_sql` and `execute_sql_readonly` per the use guide; `execute_sql_readonly` allows only read-only operations while `execute_sql` is the sole non-read-only tool. Limitations documented: query processing capped at three minutes by default, results limited to 3,000 rows, and Google Drive external tables unsupported for those SQL tools.

Zep documents an experimental Graphiti Model Context Protocol server at help.getzep.com/graphiti/getting-started/mcp-server, with AI client integration also referenced at `https://help.getzep.com/_mcp/server` per Zep docs. The open-source implementation lives in getzep/graphiti/mcp_server with HTTP transport at `/mcp/` (default localhost:8000) or stdio mode. Tools include `add_episode`, `search_facts`, `search_nodes`, `get_episodes`, `delete_episode`, `clear_graph`, and `get_status` per the Graphiti MCP README; newer README entries also list `add_memory`, `add_triplet`, `search_memory_facts`, `summarize_saga`, `build_communities`, and `get_episode_entities`. Graphiti is Zep's open-source temporal knowledge graph framework for Context Graphs with real-time incremental updates and hybrid retrieval.

LanceDB maintains a reference Model Context Protocol server in the lancedb/lancedb-mcp-server repository (linked from lancedb/lancedb issue #2341), implemented with FastMCP and LanceDB embeddings. Tools include `ingest_docs` (embed and store documents), `query_table` (semantic retrieval with configurable top_k and query_type), and `table_details` (schema and row counts) per the README. Configuration uses `uv run lancedb_mcp.py` with environment variables `LANCEDB_URI` (default `~/lancedb`), `TABLE_NAME`, `EMBEDDING_FUNCTION` (default sentence-transformers), and `MODEL_NAME` (default all-MiniLM-L6-v2). The repo describes itself as a basic serverless MCP reference for building more complex LanceDB agent apps—not a full production managed endpoint.

MotherDuck documents a remote Model Context Protocol server at motherduck.com/docs/sql-reference/mcp hosted at `https://api.motherduck.com/mcp` with OAuth (or Bearer token) and read-write SQL access to MotherDuck cloud databases. Tools include `list_databases`, `list_tables`, `list_columns`, `search_catalog`, `query`, `query_rw`, `ask_docs_question`, Dive tools (`list_dives`, `read_dive`, `view_dive`, `save_dive`, etc.), and Flight scheduling tools (`list_flights`, `create_flight`, `run_flight`, etc.) per MotherDuck MCP docs. For local DuckDB files or custom configs, MotherDuck points to the open-source `mcp-server-motherduck` package (`uvx mcp-server-motherduck --db-path md:`) on github.com/motherduckdb/mcp-server-motherduck.

Mem0 documents an official cloud-hosted Model Context Protocol server at docs.mem0.ai/platform/mem0-mcp, exposed over Streamable HTTP at `https://mcp.mem0.ai/mcp` with no local install required. Setup uses `npx mcp-add --name mem0-mcp --type http --url https://mcp.mem0.ai/mcp` for Claude, Claude Code, Cursor, Windsurf, VS Code, and OpenCode per Mem0 docs. Tools include `add_memory`, `search_memories`, `get_memories`, `get_memory`, `update_memory`, `delete_memory`, `delete_all_memories`, `delete_entities`, `list_entities`, `list_events`, and `get_event_status`. Authentication uses a Mem0 Platform API key (`MEM0_API_KEY`); the legacy mem0ai/mem0-mcp GitHub repo is archived in favor of this hosted server.

Weaviate documents a built-in Model Context Protocol server in the main `weaviate/weaviate` binary from v1.37.1 onward at docs.weaviate.io/weaviate/mcp/mcp-server, exposed as a Streamable HTTP endpoint at `/v1/mcp` on the same port as the REST API (default 8080). Enable with `MCP_SERVER_ENABLED=true`; optional `MCP_SERVER_WRITE_ACCESS_ENABLED=true` registers `weaviate-objects-upsert`. Tools include `weaviate-collections-get-config`, `weaviate-tenants-list`, `weaviate-query-hybrid`, and `weaviate-objects-upsert` (write-gated). Authentication uses existing API keys/Bearer tokens with RBAC permissions `read_mcp`, `create_mcp`, and `update_mcp` per Weaviate 1.37 release notes. The standalone weaviate/mcp-server-weaviate repository is deprecated in favor of this built-in server.

Chroma documents an official Model Context Protocol server in the chroma-core/chroma-mcp repository and docs.trychroma.com/integrations/frameworks/anthropic-mcp, started with `uvx chroma-mcp` over stdio. Tools include `chroma_list_collections`, `chroma_create_collection`, `chroma_peek_collection`, `chroma_modify_collection`, `chroma_delete_collection`, `chroma_add_documents`, `chroma_query_documents`, `chroma_get_documents`, `chroma_update_documents`, and `chroma_delete_documents` per the README. Client types documented: ephemeral (default), persistent (`--client-type persistent --data-dir`), HTTP self-hosted, and Chroma Cloud (`--client-type cloud` with API keys). Embedding function options include default, Cohere, OpenAI, Jina, VoyageAI, and Roboflow per Chroma MCP docs.

PlanetScale documents a hosted Model Context Protocol server at planetscale.com/docs/connect/mcp, reachable at `https://mcp.pscale.dev/mcp/planetscale` with OAuth authentication for organizations, databases, branches, schemas, and Insights data. An insights-only endpoint at `https://mcp.pscale.dev/mcp/planetscale-insights-only` omits read/write query tools. Tools documented include organization/database/branch listing, schema inspection, `planetscale_get_insights`, documentation search, and—when scopes allow—`planetscale_execute_read_query` and `planetscale_execute_write_query` with replica routing, ephemeral credentials, and destructive-query safeguards per the January 2026 changelog. PlanetScale notes the older local CLI MCP path is deprecated in favor of the hosted HTTP server for Cursor, Claude Code, and other MCP clients.

Turso documents a built-in Model Context Protocol server in the Turso CLI (`tursodb`) at docs.turso.tech/cli/mcp-server, started with `tursodb /path/to/database.db --mcp` over stdio JSON-RPC. Tools include `open_database`, `current_database`, `list_tables`, `describe_table`, `execute_query` (SELECT-only), `insert_data`, `update_data`, `delete_data`, and `schema_change` (CREATE/ALTER/DROP) per the Mintlify MCP reference. Turso's launch blog at turso.tech/blog/introducing-the-turso-database-mcp-server shows Claude Desktop and Claude Code configuration via `claude mcp add` with the same `--mcp` flag—no separate npm package required for local embedded databases.

Upstash documents an official Model Context Protocol server at upstash.com/docs/agent-resources/mcp implemented in the `upstash/mcp-server` repository and npm package `@upstash/mcp-server`. Started with `npx -y @upstash/mcp-server@latest --email YOUR_EMAIL --api-key YOUR_API_KEY`, it exposes tools for serverless Redis, QStash, Workflow runs, and Upstash Box so agents can manage and debug account resources from Cursor, Claude Code, VS Code, Codex, and other MCP clients. Read-only API keys automatically disable mutating tools per docs; optional `--transport http`, `--disable-telemetry`, and Upstash Box API key flags are documented for advanced setups.

Convex documents a Model Context Protocol server shipped in the Convex CLI at docs.convex.dev/ai/convex-mcp-server, started locally with `npx -y convex@latest mcp start` over stdio after linking a project via `npx convex dev`. Tools include `status` (deployment selector), `tables` (declared and inferred schemas), `data` (paginated documents), `runOneoffQuery` (sandboxed read-only JS), `functionSpec`, `run` (invoke deployed functions), `logs`, `insights` (72-hour OCC and resource-limit health), and `envList`/`envGet`/`envSet`/`envRemove`. Flags such as `--prod`, `--preview-name`, `--deployment-name`, and `--disable-tools` restrict scope; production writes require `--dangerously-enable-production-deployments` per changelog defaults.

PostHog documents a free hosted Model Context Protocol endpoint at `https://mcp.posthog.com/mcp` per posthog.com/docs/model-context-protocol that lets MCP clients query analytics, manage feature flags, investigate errors, run HogQL, triage support workflows, and configure CDP destinations from natural-language prompts. The PostHog Wizard installs the server into Cursor, Claude Code, Claude Desktop, Codex, VS Code, Windsurf, and Zed via `npx @posthog/wizard@latest mcp add`. Authentication routes to the correct US or EU data region; manual setups can pass a personal API key with the MCP Server preset through `mcp-remote` and an `Authorization` Bearer header. Source lives in the PostHog monorepo at `services/mcp` (the standalone PostHog/mcp repository redirects there).

Weights & Biases documents a hosted Model Context Protocol server at `https://mcp.withwandb.com/mcp` (recommended) and an open-source `wandb/wandb-mcp-server` package for local stdio or HTTP per docs.wandb.ai/platform/mcp-server. Authenticated clients pass a W&B API key in the `Authorization: Bearer` header. Documented tools include `query_wandb_tool` and `get_run_history_tool` for experiment metrics, `query_weave_traces_tool` and `count_weave_traces_tool` for LLM traces, `create_wandb_report_tool` for markdown reports, `search_wandb_docs_tool` for docs.wandb.ai, and `query_wandb_entity_projects` for project listings. Dedicated/on-prem deployments can set `WANDB_BASE_URL` with the local server per README.

Elastic documents the recommended Agent Builder Model Context Protocol endpoint at `{KIBANA_URL}/api/agent_builder/mcp` (or `{KIBANA_URL}/s/{SPACE_NAME}/api/agent_builder/mcp` for custom Kibana spaces) per elastic.co/docs/explore-analyze/ai-features/agent-builder/mcp-server. The MCP server exposes built-in and custom Agent Builder tools to Claude Desktop, Cursor, VS Code, and other MCP clients via `npx mcp-remote` with an `Authorization: ApiKey` header. API keys must include the Kibana application privilege `feature_agentBuilder.read` or clients receive HTTP 403. Elastic notes the legacy `elastic/mcp-server-elasticsearch` project is deprecated in favor of this endpoint on Elastic 9.2+ and Elasticsearch Serverless; docs recommend least-privilege index scopes and API key expiration.

MotherDuck documents a remote Model Context Protocol server at `https://api.motherduck.com/mcp` (fully managed, read-write) that lets Claude, ChatGPT, Cursor, Claude Code, Codex, and other MCP clients query MotherDuck cloud databases via OAuth or Bearer tokens with zero local install per motherduck.com/docs/sql-reference/mcp. Remote tools include read-only `query` and read-write `query_rw` plus schema exploration helpers documented in the MCP workflows guide. For local DuckDB files, S3 paths, or custom limits, the open-source `mcp-server-motherduck` package (motherduckdb/mcp-server-motherduck on GitHub, PyPI `mcp-server-motherduck`) runs via `uvx` with flags such as `--db-path`, `--motherduck-token`, and `--read-write` for self-hosted stdio or HTTP transports.

Langfuse documents two MCP surfaces: a hosted Prompt Management server at `https://cloud.langfuse.com/api/public/mcp` (streamable HTTP, built into the platform per langfuse.com/docs/prompt-management/features/mcp-server) with tools such as `createTextPrompt`, `createChatPrompt`, `getPrompt`, and `updatePromptLabels`; and a public Docs MCP at `https://langfuse.com/api/mcp` for semantic search over Langfuse documentation (`searchLangfuseDocs`) without authentication. The legacy `langfuse/mcp-server-langfuse` Node server remains for local command-based setups with LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY. Langfuse positions MCP for agentic onboarding—IDE agents can add tracing to OpenAI, Anthropic, or LangChain codebases from the Get Started agentic tab.

Anthropic documents remote Model Context Protocol connectors in Claude Help Center and platform.claude.com docs: users add publicly reachable MCP server URLs so Claude clients (claude.ai, Claude Desktop, Cowork, mobile) connect from Anthropic cloud infrastructure rather than the local machine. Team and Enterprise admins add connectors in Admin settings; individuals enable them under Settings > Connectors. The Messages API MCP connector (beta header anthropic-beta: mcp-client-2025-11-20) accepts mcp_servers entries with type url, name, and https URL, paired with mcp_toolset tools entries; servers must support streamable HTTP/SSE and be internet-accessible to Anthropic IP ranges.

dbt Labs documents an official Model Context Protocol server at docs.getdbt.com/docs/dbt-ai/about-mcp (repository dbt-labs/dbt-mcp) that exposes governed access to dbt project metadata, lineage, CLI actions, and dbt Platform APIs for Claude, Cursor, and custom MCP clients. Local mode runs via `uvx dbt-mcp` with environment variables such as DBT_PROJECT_DIR, DBT_HOST, DBT_TOKEN, DBT_PROD_ENV_ID, and DBT_USER_ID; remote mode connects over HTTP/SSE to a managed dbt Platform MCP endpoint with OAuth. Documented tool groups include product-doc search (`search_product_docs`, `get_product_doc_pages`) and server metadata helpers, with additional development and deployment tools synced from the GitHub README per release.

The zilliztech/mcp-server-milvus project (documented at milvus.io/docs/milvus_and_mcp.md) exposes Milvus vector-database operations to MCP clients such as Claude Desktop and Cursor. The recommended launch path is `uv run src/mcp_server_milvus/server.py --milvus-uri http://localhost:19530` without a separate install step, with optional `MILVUS_URI`, `MILVUS_TOKEN`, and `MILVUS_DB` environment variables. Tools listed in Milvus docs include `milvus-text-search`, `milvus-hybrid-search`, `milvus-multi-vector-search`, `milvus-query`, and `milvus-count` for collection management, semantic retrieval, filtered hybrid search, and entity counts.

Mem0 documents a hosted Model Context Protocol server at https://mcp.mem0.ai/mcp that exposes Platform memory tools (`add_memory`, `search_memories`, `get_memories`, `update_memory`, `delete_memory`, `delete_all_memories`, `delete_entities`, `list_entities`, `list_events`, `get_event_status`) to Claude, Claude Code, Codex, Cursor, Windsurf, VS Code, and OpenCode. Setup uses `npx mcp-add` with HTTP transport or manual JSON/TOML client configs; Codex requires `MEM0_API_KEY` as bearer token per docs.mem0.ai/platform/mem0-mcp. The cloud server needs a Mem0 Platform API key from the dashboard and Node.js for the installer—no local vector database required for the hosted path.

The open-source ClickHouse MCP server (PyPI package `mcp-clickhouse`, repository ClickHouse/mcp-clickhouse) exposes MCP tools such as `run_query`, `list_databases`, and paginated `list_tables` against ClickHouse clusters, defaulting to read-only SQL unless `CLICKHOUSE_ALLOW_WRITE_ACCESS` is enabled. Optional chDB extras add `run_chdb_select_query` for embedded queries over files and URLs. HTTP/SSE transports require authentication via `CLICKHOUSE_MCP_AUTH_TOKEN`, FastMCP OAuth/OIDC providers, or explicit `CLICKHOUSE_MCP_AUTH_DISABLED=true` for local dev; a `/health` endpoint supports orchestrator probes without credentials per README guidance.

Datadog documents a remote Model Context Protocol server at docs.datadoghq.com/bits_ai/mcp_server that connects AI agents in Cursor, Claude Code, Codex CLI, VS Code, Gemini CLI, and other MCP clients to observability data across APM, logs, metrics, monitors, dashboards, and security signals. Setup guides describe OAuth-based connection to Datadog's hosted MCP endpoint (distinct from the local-only Code Security MCP Server used for SAST/SCA scans). Fair-use limits listed in docs include 50 requests per 10 seconds burst and 50,000 monthly tool calls; Audit Trail records MCP actions with tool name, arguments, user identity, and client, while metrics `datadog.mcp.session.starts` and `datadog.mcp.tool.usage` tag usage by client and tool.

Composio documents MCP server creation through its SDK and dashboard at docs.composio.dev: developers call `composio.mcp.create()` with toolkit names, auth config IDs, and an `allowed_tools` list, then generate per-user MCP URLs via `composio.mcp.generate(user_id, mcp_config_id)`. Hosted endpoints follow the pattern `https://backend.composio.dev/v3/mcp/{SERVER_ID}?user_id=...` and require an `x-api-key` header when `require_mcp_api_key` is enabled (default for new orgs). Docs show wiring these URLs into OpenAI Responses API, Anthropic MCP client beta, Mastra MCPClient, Claude Desktop, and Cursor. Composio notes that dynamic sessions are recommended for most use cases, while single-toolkit MCP configs suit fixed integration surfaces.

E2B documents an MCP gateway that runs inside cloud sandboxes, exposing 200+ tools from the Docker MCP Catalog (Browserbase, Exa, Notion, Stripe, GitHub, and others) through a unified HTTP endpoint with bearer-token auth. Developers create a Sandbox with an `mcp` configuration map of server credentials, call `getMcpUrl()` / `getMcpToken()`, and attach the gateway to MCP clients such as Claude Code via `claude mcp add --transport http`. Sandboxes provide an internet-connected Linux environment where agents can install packages, run terminal commands, and execute generated code while MCP tools stay type-safe per E2B's overview at e2b.dev/docs/mcp.

LiteLLM Proxy documentation describes an MCP Gateway that exposes list-tools, call-tools, prompts, and resources operations through a fixed endpoint while enforcing access by API key, team, or organization. Supported transports listed on docs.litellm.ai include Streamable HTTP, SSE, and stdio; operators can register HTTP, SSE, or stdio MCP servers through the LiteLLM UI or config.yaml after enabling database storage (`store_model_in_db` / `STORE_MODEL_IN_DB`). Release notes cited in the docs state LiteLLM v1.80.18 aligns with MCP protocol version 2025-11-25 and namespaces tools by MCP server name per SEP-986 naming rules for newly added servers. The gateway is positioned as a way to use MCP tools alongside all LiteLLM-supported chat models from Cursor or other OpenAI-compatible clients pointed at the proxy.

LangChain documents a LangSmith Model Context Protocol server that lets MCP clients read conversation threads, prompts, runs and traces, datasets, experiments, and billing usage from a LangSmith workspace. For LangSmith Cloud, docs recommend the OAuth-authenticated LangSmith Remote MCP (regional endpoints on api.smith.langchain.com and documented EU/APAC/AWS variants) with the same tool surface and no separate deployment. The standalone HTTP server at https://langsmith-mcp-server.onrender.com/mcp remains documented for API-key access via the LANGSMITH-API-KEY header, while self-hosted LangSmith users can run the open-source langsmith-mcp-server package with uvx, Docker HTTP on port 8000, or point LANGSMITH_ENDPOINT at private instances. Tools include get_thread_history, list_prompts, fetch_runs (with FQL filters and character-budget pagination), dataset/example readers, list_experiments, and get_billing_usage per the official tool table.

Snowflake documents a Snowflake-hosted Model Context Protocol (MCP) endpoint that fronts governed Snowflake data and Cortex workloads without provisioning a separate MCP bridge VM. Administrators declare tools with SQL (`CREATE MCP SERVER`)—for example Cortex Search queries, Cortex Analyst chat-style messages, Cortex Agent executions, parameterized SQL runners, or custom tools backed by Snowflake-native functions—and clients authenticate using Snowflake OAuth against the MCP revision pinned in Snowflake release notes.

The MCP Server Trigger is a first-party n8n core node that turns an n8n workflow into a Model Context Protocol server endpoint. Instead of chaining conventional trigger nodes, it connects only to tool nodes so remote MCP clients can list tools and invoke them over long-lived Server-Sent Events or streamable HTTP transports (stdio is explicitly unsupported). Each node exposes separate test and production MCP URLs, optional bearer or header authentication, and documentation explains how to proxy Claude Desktop through `npx mcp-remote` plus queue-mode caveats for multi-replica webhook deployments.

The DuckDB-distributed community extension `duckdb_mcp` embeds MCP client and server capabilities directly inside DuckDB. Installers load it via `INSTALL duckdb_mcp FROM community` followed by `LOAD duckdb_mcp`, after which SQL can attach remote MCP servers (stdio/TCP/WebSocket transports), enumerate resources (`mcp_list_resources`), invoke remote tools (`mcp_call_tool`), and wrap responses with `read_csv`/`read_json`/`read_parquet` URIs routed through `mcp://`. In reverse direction, DuckDB can publish tables, queries, and execution-bound tools (`mcp_publish_table`, `mcp_publish_query`, `mcp_publish_execution_tool`) while `mcp_server_start` exposes them to external MCP-compatible clients.

Official Neon MCP integration exposes Neon Postgres projects to MCP-capable assistants via Streamable HTTP (`https://mcp.neon.tech/mcp`), legacy SSE (`https://mcp.neon.tech/sse`), or a locally launched `@neondatabase/mcp-server-neon` package. Documentation lists tools for project and branch lifecycle, SQL execution, migration rehearsal branches, slow-query diagnostics, Neon Auth provisioning, Data API setup, and embedded Neon docs retrieval—each mapped to Neon API operations.

Apify documents an official Model Context Protocol server hosted at https://mcp.apify.com that speaks Streamable HTTP in line with the current MCP specification; Apify warns that SSE transport was deprecated for removal April 1, 2026. Hosted clients authenticate through browser OAuth or by supplying Bearer tokens sourced from Console → Settings → Integrations (`APIFY_TOKEN`), can pin tool bundles via URL query (`?tools=actors,docs,apify/rag-web-browser` style examples reproduce Apify wording), optionally append `telemetry-enabled=false`, and benefit from inferred structured-output schemas surfaced for Actor tooling on hosted endpoints unlike the default stdio server. When MCP clients refuse remote transports, docs recommend `npx -y @apify/actors-mcp-server` with `APIFY_TOKEN` for stdio, Node.js ≥18, and adherence to documented per-user throughput (Apify cites up to thirty requests per second across Actor runs plus storage/documentation calls). Specialized payment modes (open x402 on Base plus Skyfire) appear as optional adjunct pages inside the broader integration handbook.

Official Qdrant MCP server implementation that gives AI agents a semantic memory layer backed by Qdrant vector search. It exposes MCP tools for storing information and retrieving relevant context, so assistants can persist and recall facts across sessions instead of relying only on short chat history.

Community-maintained Model Context Protocol bridge that exposes Ollama's local HTTP API—model listing, pulls, chat, and OpenAI-compatible completions—to MCP clients such as Claude Desktop and Cursor. Published on npm as `ollama-mcp-server` (maintained fork of NightTrek/Ollama-mcp); requires a running Ollama daemon reachable at `OLLAMA_HOST` (default `http://127.0.0.1:11434`).

Official Shopify Dev MCP server from the Shopify AI Toolkit: connects Claude Code, Cursor, VS Code, Gemini CLI, Codex, and similar clients to Shopify developer documentation, GraphQL schemas, and validation workflows without guessing API shapes. Runs locally via npx using the @shopify/dev-mcp package; Shopify documents that no authentication is required for this developer-resources server. Part of Shopify's broader AI Toolkit alongside plugins and optional skill bundles.

piLoci MCP is a self-hosted memory server for AI agents that exposes project-scoped memory storage and retrieval through the Model Context Protocol. Built to run on Raspberry Pi 5, it provides semantic recall, project listing, and user identity tools. Teams connect Claude Desktop, Codex, and other MCP clients to share persistent context without sending memory data to cloud services.

Connect any LLM to your Webflow sites via the Model Context Protocol. Manage pages, collections, CMS items, e-commerce products, forms, and users through natural language — enabling AI-driven site management and content workflows.

Bridges AI agents to Cloudflare Workers, KV storage, R2 object storage, and D1 databases for edge deployment inspection and management. Agents can check Workers status, inspect KV namespaces, query D1 databases, and monitor R2 buckets directly from the coding environment.

Exposes Grafana dashboards, alerts, and time-series data to AI agents for reading application health and correlating incidents with code changes. Agents can query metrics, inspect alert rules, and fetch panel data for debugging. Supports Grafana Cloud and self-hosted instances.

Implements the Agent Protocol standard enabling MCP clients to coordinate with external agent frameworks using shared task, step, and artifact schemas. Useful when composing multiple agents where one agent hands off work to specialized agents. Supports agent registration and state tracking.

Connects AI agents to Azure resources including App Service, Cosmos DB, Key Vault, and Logic Apps for configuration inspection and diagnostic retrieval. Developers can query Azure settings and logs without Azure Portal. Uses Azure CLI credentials for authentication.

Extends Slack integration with message drafting, channel management, and workflow trigger capabilities for proactive team notifications. Unlike read-only Slack MCP, this enables agents to send summaries, create channels, and initiate workflows on behalf of users. Uses Slackbot token.

Exposes Temporal workflow execution state, namespace management, and search attributes to AI agents for debugging long-running business processes. Agents can inspect workflow history, debug stuck executions, and trigger new workflow runs. Supports self-hosted and Temporal Cloud deployments.

Bridges AWS API operations to AI agents for EC2 instance management, S3 bucket operations, Lambda function inspection, IAM policy analysis, and CloudWatch log retrieval. Uses your existing AWS credentials configured on the machine. Supports multi-account setups via role assumption.

Go-native MCP server that interfaces directly with Kubernetes API for workload inspection, event monitoring, Helm release management, and log retrieval. Agents can debug cluster issues with RBAC-aware toolsets instead of copy-pasting kubectl output. Supports multiple cluster contexts.

Pulls version-tagged library documentation and API references from Context7's database of curated SDK docs. Agents cite current library methods instead of hallucinating from stale training data. Particularly valuable for fast-moving frameworks where docs change frequently.

Provides AI agents access to Prisma schemas, migration planning, and database introspection capabilities. Agents can propose migrations, explore data models, and generate type-safe queries based on your Prisma setup. Works with local projects and remote Prisma Data Proxy deployments.

Exposes Netlify CLI operations to AI agents for site scaffolding, build configuration, deploy triggering, and domain management. Developers can manage Netlify hosting without dashboard access or CLI installation. Agents work within the editor context to automate deployment workflows.

Connects AI agents to Sentry error tracking, stack traces, performance data, and release information through Sentry's hosted MCP endpoint. Debugging starts from actual error context instead of pasted messages. Agents can correlate issues with code changes and deployment events.

Provides AI agents access to Vercel projects, deployments, logs, and documentation through Vercel's official MCP endpoint with OAuth authentication. Developers can debug deployment issues, inspect preview URLs, and manage project settings directly from the IDE.

Exposes Stripe payment objects including customers, invoices, subscriptions, charges, and payouts to AI agents with granular OAuth scopes. Finance and support copilots can look up live billing state, investigate disputes, and generate reports. Useful for SaaS finance operations and merchant reporting.

Enables AI agents to inspect Docker containers, images, volumes, and compose projects through Docker's official MCP server. Debug local development stacks by having the agent query container state, tail logs, and inspect networking. Supports both local Docker and Docker Desktop contexts.

Allows AI agents to run queries, inspect collections, execute aggregation pipelines, and analyze explain plans against MongoDB clusters. Debug document models and performance issues by having the agent explore data structures directly. Supports MongoDB Atlas federated queries and Atlas Search.

Connects AI agents to Exa's hosted search engine with capabilities for web search, code search, company research, and intelligent web crawling. Agents get fresher information than training cutoffs without manually browsing. Exa understands content semantics beyond keyword matching.

Adds Firecrawl's web scraping, crawling, mapping, and content extraction capabilities to MCP clients. Agents can fetch clean page content, map entire websites, and build retrieval datasets without HTML parsing boilerplate. Designed for RAG pipelines and competitive research.

Provides AI agents access to Figma designs, components, variables, frames, and FigJam whiteboards through Figma's official MCP integration. Developers can implement designs without switching to Figma, and designers can sync annotations. Reduces miscommunication between design and code.

Connects AI agents to Hugging Face Hub for discovering models, datasets, papers, and Spaces without leaving the coding environment. Agents can find optimal models for tasks, inspect dataset schemas, and access inference APIs. Accelerates ML development workflows.

Enables AI agents to inspect Pinecone vector database indexes, query vectors, manage collections, and debug retrieval behavior. Useful for teams using vector search in RAG applications who want to understand index statistics and optimize similarity search performance.

Connects AI coding agents to Semgrep static analysis rules and findings so security reviews can start from actual scan results. Agents can look up rule definitions, triage findings, and verify fixes without pasting SARIF outputs. Integrates with CI/CD pipelines.

Exposes Redis key-value store operations to AI agents including GET/SET, list operations, hash manipulation, and pub/sub debugging. Agents can inspect caches, debug session stores, and check feature flags without dumping entire databases. Supports Redis Cluster and Sentinel configurations.

Synchronizes engineering context by allowing agents to read and update Linear issues, comments, and projects directly from the IDE. Keeps issue trackers current without switching between tools. Agents can create bugs, update sprint status, and link PRs to issues.

Exposes Atlassian Jira, Confluence, and Compass through Atlassian's hosted Rovo MCP endpoint for enterprise knowledge access. Agents can retrieve requirements, summarize documentation, create tickets, and navigate organizational knowledge bases. Designed for enterprise teams with existing Atlassian investments.

Provides real-time web search, intelligent content extraction, site mapping, and web crawling capabilities through Tavily's hosted MCP endpoint. Agents can ground responses with fresh, cited web evidence rather than relying on training cutoffs. Typical workflow involves sending a query and receiving structured snippets with source URLs.

Connects agents to Supabase projects for table inspection, Edge Function debugging, database triggers, and real-time subscriptions. Agents can inspect RLS policies, view logs, and manage database types without the Supabase dashboard. Supports both hosted and self-hosted Supabase instances.

Provides cloud-hosted browser sessions for AI agents to navigate websites, interact with DOM elements, fill forms, and execute scripted flows. Eliminates the need to run local Chrome profiles or handle browser automation infrastructure. Agents can perform complex web tasks remotely through a managed browser fleet.

Bridges Make.com's no-code automation platform with conversational AI by exposing existing Make scenarios as callable MCP tools. Agents can trigger workflows, update CRM records, and orchestrate cross-app automations without understanding Make's interface. Ideal for business process automation.

Exposes local file system operations to AI agents with configurable path permissions and sandboxed access controls. Agents can read, write, and search files within explicitly allowed directories. Designed as a reference implementation demonstrating MCP resource patterns and secure file access.

Enables AI agents to fetch PayPal invoices, transaction history, payouts, and merchant reports through PayPal's official MCP integration. Finance operations teams can automate reconciliation, audit transactions, and generate billing summaries. Strict API scoping ensures agents access only permitted data.

Enables AI agents to execute read-only SQL queries against PostgreSQL databases, inspect table schemas, and analyze query performance. Agents can debug data issues or prepare analytics without requiring direct database credentials in the conversation. Supports connection pooling and multiple database targets.

Provides centralized access to Cloudflare services including DNS management, Workers deployments, R2 storage operations, and security settings through a remote MCP endpoint. Infrastructure teams can query and modify Cloudflare resources via AI assistants. Supports zero-trust access policies.

Connects AI agents to Notion workspaces, enabling reading and writing pages, querying databases, search across content, and managing blocks. Meeting notes, specs, and task boards stay synchronized without manual copy-paste. Agents can autonomously update project documentation as work progresses.

Provides GitHub API access for repositories, issues, pull requests, reviews, and code search. Agents can summarize PR diffs, draft code reviews, manage issues, and navigate large organizations using OAuth-authenticated API calls. Supports both github.com and GitHub Enterprise deployments.

Enables AI agents to search Slack message history, retrieve channel content, and understand team conversations within workspace data retention policies. Useful for standup summaries, incident timelines, and reconstructing decisions from threaded discussions. Agents query Slack without sending messages.

Provides file search and content retrieval across Google Drive including Docs, Sheets, Slides, PDFs, and shared drives. Agents can pull policy documents, research archives, and spreadsheets into conversations without downloading files locally. Supports Google Workspace sharing policies and permissions.

Integrates GitLab projects, merge requests, CI/CD pipelines, and group metadata into AI assistants. Agents can review MR diffs alongside code, inspect pipeline failures, and track approval status without leaving the IDE. Supports gitlab.com and self-hosted GitLab instances.

Provides lightweight SQL access to local SQLite database files for quick analytics, schema inspection, and prototyping without database server overhead. Agents can query, analyze, and generate reports from embedded datasets. Ideal for app sandboxes, development databases, and data exploration.

Uses Microsoft Playwright to drive real Chromium, Firefox, and WebKit browsers for automation, accessibility testing, and UI verification. Agents can click, type, navigate, take screenshots, and extract content from dynamic web pages. Suitable for end-to-end testing and web scraping workflows.

Routes search queries through Brave's privacy-respecting search API for web retrieval and local search capabilities. Agents can ground responses with current information without tracking or profiling. Useful for research, compliance-sensitive queries, and users who prefer not to use Google.

pg-mcp-server is a Model Context Protocol server implementation that connects AI agents to PostgreSQL databases. It registers database schemas as MCP resource templates and exposes SQL execution as an MCP tool. Agents can introspect table structures, run parameterized queries, and manage transactions without leaving the chat interface. Designed as a reference implementation for database MCP integrations.