MCP Servers for Windsurf

Reference/test server with prompts, resources, and tools. Perfect for testing MCP implementations.

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Tools to read, search, and manipulate Git repositories. Full Git operations support.

Knowledge graph-based persistent memory system. Store and retrieve contextual information.

a single structured-reasoning tool that lets a model plan, revise and branch its own chain of thought instead of answering in one shot. Published by Anthropic as part of the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it exposes exactly one tool — sequential_thinking — and that tool is the whole product. Each call carries a `thought` string plus bookkeeping fields: `thoughtNumber`, `totalThoughts`, and `nextThoughtNeeded`, which the model flips to false when it is done. The interesting fields are the optional ones. `isRevision` and `revisesThought` let the model go back and correct an earlier step rather than plowing ahead on a bad assumption; `branchFromThought` and `branchId` let it fork into an alternative line of reasoning and carry both forward; `needsMoreThoughts` lets it extend past its own original estimate when a problem turns out to be deeper than it looked. In practice you never call the tool by hand. You connect the server to an MCP host and ask a question that deserves more than one pass — plan a PostgreSQL 14 to 16 migration and revise if downtime exceeds five minutes, work out why a deploy only fails in production, compare three architectures and branch when an assumption breaks. You can tell it is working when the host inspector shows repeated sequential_thinking calls with a rising `thoughtNumber` rather than a single response. Install with `npx -y @modelcontextprotocol/server-sequential-thinking` — note the hyphenated package name, which differs from both the `sequentialthinking` directory in the repo and the Docker image `mcp/sequentialthinking`, a mismatch that breaks a lot of copied configs. A Docker image is published alongside the npm package, and the README carries one-click VS Code install buttons for both transports. Set `DISABLE_THOUGHT_LOGGING=true` if you do not want every thought written to the server log.

Time and timezone conversion capabilities for AI assistants.

The Apify MCP server gives AI agents access to 6,000+ ready-made cloud scrapers, crawlers, and automation tools on the Apify Store — no infrastructure required. Connect to Apify Actors that extract data from social media platforms (Instagram, TikTok, LinkedIn), search engines (Google, Bing), e-commerce sites (Amazon, eBay), maps (Google Maps), and virtually any website. Each Actor runs in the cloud with managed proxies, browser fingerprinting, and anti-bot bypass built in. Use the Apify MCP server to query Actors by task, stream results directly into your AI context, run custom scraping Actors from your Apify account, and chain multiple data extraction steps in a single workflow. Supports tool filtering to expose only the Actors you need, and integrates with Apify's RAG web browser Actor for retrieval-augmented generation use cases.

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

a first-party MCP endpoint built into the GitLab instance itself — there is no package to install, because the server ships inside GitLab and answers at https://<your-gitlab>/api/v4/mcp (gitlab.com exposes the same path, so https://gitlab.com/api/v4/mcp works for SaaS projects). It landed as an experiment in GitLab 18.3 and moved to beta in 18.6. Authentication is the part that makes it different from every community GitLab server: it uses OAuth 2.0 Dynamic Client Registration, so the first time a client connects it registers itself as an OAuth application on your instance and is issued an access token — no personal access token pasted into a config file. Administrators who do not want one OAuth application per tool can pre-create a shared application instead. Three prerequisites are what actually block most first connections: GitLab Duo must be set to Always on or On by default, beta and experimental features must be enabled, and MCP access must be switched on at the group or instance level. The tool surface covers issues and merge requests (create_issue, get_issue, create_merge_request, get_merge_request, list_merge_requests, get_merge_request_commits, get_merge_request_diffs, get_merge_request_pipelines, create_merge_request_note, get_merge_request_notes), CI/CD (manage_pipeline for list/create/delete/retry/cancel, get_pipeline_jobs, get_job_log), work items (create_workitem_note, get_workitem_notes, link_work_items, get_saved_view_work_items), search (search across the instance, search_labels, semantic_code_search), list_wiki_pages, and attach_scan_profile. HTTP is the recommended transport — claude mcp add --transport http GitLab https://gitlab.com/api/v4/mcp — and clients that only speak stdio can wrap it with npx mcp-remote <url> on Node 20+. Send the X-Gitlab-Mcp-Server-Tool-Name-Prefix header if generic names like search collide with another connected server. If your instance predates 18.3 or Duo is not available to you, the community alternative most teams land on is zereight/gitlab-mcp (1,889 stars as of 2026-08-16, npm @zereight/mcp-gitlab), which authenticates with a plain personal access token and ships 217 tools — including merge_merge_request, approve_merge_request, execute_graphql and full CI/CD variable management, none of which the built-in server exposes — behind GITLAB_PERMISSION_MODE=readonly/modify and GITLAB_TOOLSETS/GITLAB_TOOLS filtering. One further change worth noting: MCP server access moved from GitLab Premium to GitLab Free in 19.2 and became a setting of its own.

AWS Labs maintains a monorepo of specialized, open-source MCP servers that bring AWS best practices directly into AI-assisted development workflows, spanning infrastructure, data, AI/ML, cost management, and healthcare/life-sciences domains. Rather than one monolithic server, the project ships dozens of focused servers you install individually depending on the task: the AWS Documentation MCP Server for real-time official docs and API references, dedicated servers for Terraform/CDK/CloudFormation infrastructure-as-code, container and serverless platforms (ECS, EKS, Lambda), SQL/NoSQL databases (DynamoDB, RDS, Aurora), search and analytics (OpenSearch), messaging (SQS/SNS), and cost/billing analysis. Most servers install via uvx with a package name like awslabs.aws-documentation-mcp-server, run locally over stdio, and use standard AWS credential chains (IAM roles, profiles, or access keys) rather than exposing raw account credentials to the model. AWS also now offers a managed, remote "AWS MCP Server" (in preview) that combines full API coverage with pre-built agent SOPs, syntactically validated API calls, and complete CloudTrail audit logging for teams that want centralized governance instead of running servers locally. The Getting Started with Kiro/Cursor/VS Code/Claude Code sections in the repo provide one-click install configs for each server, making it straightforward to wire up only the AWS services a given project actually touches.

Cloudflare ships two different things under this name. The mcp-server-cloudflare repo provides 16 remote, domain-specific MCP servers rather than one monolith — Documentation, Workers Bindings (storage/AI/compute primitives), Workers Builds, Observability (logs/analytics), Container sandboxes, Browser Rendering (fetch pages, convert to markdown, screenshots), Logpush health, AI Gateway (prompt/response search), AI Search, Audit Logs, DNS Analytics, Digital Experience Monitoring, Cloudflare One CASB, Radar, GraphQL analytics and the Agents SDK docs server, each on its own `*.mcp.cloudflare.com/mcp` hostname. Separately, the Cloudflare API MCP server at mcp.cloudflare.com/mcp (repo: cloudflare/mcp) exposes the whole 2,500+ endpoint Cloudflare API through just two tools, `search` and `execute`, using the Code Mode pattern — model-written JavaScript runs in an isolated Dynamic Worker, costing ~1,000 tokens of context against the ~1.17M an equivalent native-tool server would need. Pick a domain server when you want a readable, curated tool list for one product area; pick the API server for breadth or for endpoints nobody wrote a tool for. All endpoints are Streamable HTTP on `/mcp` and support the MCP 2026-07-28 spec; the historical `/sse` URLs remain as aliases for the same Streamable HTTP handler but no longer serve the deprecated HTTP+SSE transport, so clients pinned to SSE must switch. Auth is OAuth on connect, or a scoped Cloudflare API token as a bearer header for CI. Clients without native remote-MCP support bridge via `npx mcp-remote https://<subdomain>.mcp.cloudflare.com/mcp`.

Browserbase MCP and Stagehand MCP are the same server under two names, and this catalog lists both because people search for both — this page is the platform view, /servers/stagehand covers the natural-language automation layer that runs inside it. What Browserbase supplies is the browser itself: a headless Chrome session running in Browserbase's cloud rather than on the machine your agent is on, which is the reason to use it at all. The session is a real, addressable browser with its own residential-proxy and stealth configuration and a recorded replay you can watch afterwards, so an agent's browsing survives being run from a datacenter IP, and a failed run is debuggable after the fact instead of being a black box. Nothing renders on the developer's machine, so a long-running agent is not tied to a desktop staying awake. Browserbase's recommendation is the hosted server at https://mcp.browserbase.com/mcp over streamable HTTP — they operate it and absorb the model inference that the instruction-following tools require. Clients without HTTP transport connect via npx mcp-remote https://mcp.browserbase.com/mcp. Self-hosting installs @browserbasehq/mcp-server-browserbase from npm and needs BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID from your dashboard. Six tools are exposed — start and end for session lifecycle, navigate, act, observe and extract — and they are documented in detail on the Stagehand entry, because the act/observe/extract trio is Stagehand's model rather than Browserbase's. One thing to know before self-hosting: the browserbase/mcp-server-browserbase repository was archived on 2026-07-20 and its README now says it is kept for historical reference and should not be read as representative of the current production service. The npm package still installs and the star count on this page belongs to that archived repo; the hosted endpoint is the path Browserbase actually maintains.

The Firecrawl MCP server gives your AI assistant the ability to crawl, scrape, and extract structured data from any website — turning raw HTML into clean, LLM-ready Markdown or JSON in seconds. Built by the Firecrawl team, it exposes tools for single-page scraping, deep site crawls (following internal links), and batch URL extraction, all with JavaScript rendering handled automatically so dynamic content is never missed. Developers use it to automate competitive research, build live knowledge bases, extract pricing tables, monitor documentation changes, or feed structured web data into RAG pipelines — all through natural-language prompts without writing a single scraper script. The Firecrawl MCP server handles rate limiting, retries, and proxy rotation behind the scenes. Authentication requires a Firecrawl API key (free tier available). Install with: npx firecrawl-mcp. Works with Claude Desktop, Cursor, VS Code, and any MCP-compatible client. With Firecrawl, any public webpage becomes a structured data source your AI can reason over, compare, and act on — making it the go-to MCP server for web data extraction workflows.

Exa's official MCP server connects AI assistants to a search engine purpose-built for AI, using neural embeddings to match on meaning rather than keywords so agents get clean, ready-to-use content instead of a page of blue links to re-parse. The default tool set covers web_search_exa for quick topical lookups and web_search_advanced_exa for full control over domains, date ranges, and content filters, plus specialized tools for code_search (searching real-world code and GitHub), company_research (building company profiles, competitor lists, and financials), crawling/web_fetch (pulling clean content from a specific URL), people_search and linkedin_search (public professional-profile lookups), and deep_researcher_start/check for long-running multi-step research tasks backed by Exa's Research API. The server is hosted at https://mcp.exa.ai/mcp — no local process to run — and connects via one-line setup in Cursor, VS Code, Claude Code, Claude Desktop (available as a native Connector), Codex, OpenCode, Windsurf, and Antigravity, authenticated with an EXA_API_KEY from the Exa dashboard. Tool exposure is tunable per client via a ?tools= query parameter on the endpoint URL, letting teams ship narrow, purpose-built configurations (e.g. company-research-only or LinkedIn-only agents) instead of exposing the full surface, and Exa ships ready-made Claude Skills/agent definitions for common patterns like company research and people search with built-in query-variation and token-isolation guidance.

The Brave Search MCP Server is the official server from Brave that gives AI assistants privacy-first web search through the independent Brave Search API — no tracking, no profiling, and results drawn from Brave's own web index rather than Google or Bing. It exposes five distinct tools that map directly to the Brave Search API endpoints: brave_web_search for general queries with pagination, freshness filters, and safe-search controls; brave_local_search for businesses, restaurants, and points of interest with automatic location filtering; brave_news_search for recent articles and current events; brave_image_search for image discovery; and brave_video_search for finding videos across the web. Authentication uses a single BRAVE_API_KEY (free tier available at brave.com/search/api) or a mounted BRAVE_API_KEY_FILE for Docker-secret setups. Install in Claude Desktop, Cursor, Windsurf, or VS Code with one npx command and choose stdio or streamable-HTTP transport. Because Brave operates its own crawler and index, the Brave Search MCP server is a strong choice for developers who want an alternative to Google-dependent search tools, need reproducible non-personalized results, or care about data privacy in agent workflows — Claude can pull fresh web context, verify facts, and research topics without leaking queries to ad-tech pipelines.

The Notion MCP Server is the official integration from Notion that connects AI assistants directly to your Notion workspace via the Notion REST API. With 4,580+ GitHub stars, it is the canonical MCP tool for bringing Notion's knowledge management capabilities into Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. The server exposes a rich set of tools: search your entire workspace by keyword and return matching pages and databases; retrieve full page content and block trees; create new pages inside any parent page or workspace section; update, append, or delete block content on existing pages; list all databases your integration has access to; query database entries with filter and sort parameters; retrieve individual blocks or nested children by block ID; and add comments to pages. Authentication uses a Notion integration token — create an internal integration at notion.so/my-integrations, share specific pages or databases with it, and set NOTION_TOKEN in your environment (the older OPENAPI_MCP_HEADERS form still works). Install with a single npx command. The Notion MCP Server is especially powerful for AI workflows that span documentation retrieval, project planning, and knowledge capture — Claude can read product specs from Notion, draft new pages from conversation output, log structured data into databases, and search across thousands of notes without any manual copy-paste.

The Linear MCP server connects your AI assistant directly to Linear's project management platform via an officially hosted remote endpoint at mcp.linear.app — no local installation required. This is Linear's own first-party server, authenticated with OAuth 2.1 and centrally managed so you always run the latest version without updates. Available tools let you search issues by keyword, team, cycle, or filter; create new issues with title, description, and assignee; update status, priority, labels, and comments; and navigate Linear's project and cycle structure. In Claude Code, add it with: `claude mcp add --transport http linear-server https://mcp.linear.app/mcp`, then run /mcp to complete the OAuth flow. For older clients, use the mcp-remote bridge for backwards compatibility. Claude Desktop and Claude.ai users can connect via Settings > Connectors. Cursor and Codex have native support via their MCP config. Linear is used by thousands of engineering and product teams to plan, track, and ship software — the Linear MCP server brings that data into every AI-powered workflow without copy-paste or context-switching.

The Slack MCP server (built by Ivan Korotovsky) connects AI assistants like Claude, Cursor, and Windsurf directly to Slack workspaces, enabling conversational access to your team communication channels without requiring workspace admin approval for a bot install. Its standout feature is a "no permission" stealth mode — it authenticates using your own personal Slack session tokens (xoxc/xoxd, or a stored browser session) rather than requiring a Slack App with OAuth scopes, so it works even in locked-down workspaces where you cannot create bots. It also supports full OAuth Bot Token auth and Enterprise/GovSlack deployments for teams that prefer a conventional app install. Tools exposed include reading channel and DM/group-DM history with smart pagination, searching messages across the workspace, posting messages and thread replies, listing channels and users, and adding reactions. Common use cases include automating standups by posting summaries directly to team channels, searching past Slack conversations to surface decisions or context, monitoring specific channels for keywords or alerts, and drafting replies to thread discussions — all from natural-language prompts. Supports both Stdio and SSE transports plus proxy configuration for corporate networks. Install with: `npx slack-mcp-server@latest --transport stdio`. A separate official-style integration exists from Zencoder (@zencoderai/slack-mcp-server) for teams that prefer standard Bot Token OAuth over session-token auth. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

The HubSpot MCP Server is HubSpot's hosted, official Model Context Protocol endpoint for Smart CRM data, reachable at https://mcp.hubspot.com and authorised with OAuth 2.0 — there is no package to install and no token to paste into a config file. Access is scoped by a HubSpot user-level app: you create one with read (and optionally write) scopes for the CRM objects you want an assistant to reach, then complete the OAuth flow from inside your client. Read and write coverage spans contacts, companies, deals, tickets, carts, products, orders, line items, invoices, quotes, subscriptions and lists, plus engagements — calls, emails, meetings, notes and tasks — and the associations between them. Organisational context (users, teams, reporting structures, owners, roles, seats) and marketing content (campaigns and their metrics, landing pages, website pages, blog posts) are read-only. Custom Sensitive Data Properties and Personal Health Information are excluded regardless of scopes. Two other things share the name and are commonly confused with this one: the Developer MCP server, installed locally with `hs mcp setup` from the HubSpot CLI and aimed at building HubSpot apps rather than querying CRM records, which requires Developer Platform v2025.2; and the original May 2025 public beta, an npm package configured with a private-app access token, which is what most third-party setup guides still describe. The server remains in beta and HubSpot advises experimenting in a developer sandbox and reviewing every write confirmation, since an LLM will occasionally propose a change to a system of record that it should not.

The Stripe MCP server is Stripe's official Model Context Protocol integration, and the first thing to know is that it is not a package you install — it is a remote server Stripe hosts at https://mcp.stripe.com, and the documented connection mechanism is OAuth, not an API key. For Claude Code that is `claude mcp add --transport http stripe https://mcp.stripe.com/` followed by `claude /mcp` to complete consent; Cursor and VS Code take the bare URL, and ChatGPT accepts it as a custom connector on Pro, Plus, Business, Enterprise and Education accounts. An administrator has to enable MCP access in the Dashboard first, separately for sandbox and for live mode, which is the usual cause of a connection that refuses to authorise. Rather than one tool per endpoint, four generic tools carry most of the surface — stripe_api_search, stripe_api_details, stripe_api_read and stripe_api_write — so the tool schemas do not consume the context window, alongside dedicated create_refund, get_stripe_account_info, stripe_report, stripe_implementation_planner and search_stripe_documentation tools, plus a Treasury balance summary in public preview. Supported API methods span customers, charges, refunds, PaymentIntents, Checkout Sessions, invoices, subscriptions, coupons, promotion codes, products, prices, payment links, disputes, webhook endpoints, balance and balance transactions, payouts, tax settings and registrations, and Issuing. Clients that cannot do OAuth pass a restricted API key as a bearer token; Connect platforms acting as a connected account must use a restricted key plus a Stripe-Account header, since OAuth cannot express that. Sessions are revocable from Dashboard user settings under OAuth sessions, and Stripe recommends human confirmation of tools given prompt-injection risk.

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`.

Agent-driven builds, simulator runs, tests and debugging for iOS and macOS projects, by wrapping xcodebuild, simctl and the device tooling behind MCP. The project is XcodeBuildMCP, and the first thing to know about it is that it moved: the repository that most write-ups still link, `cameroncooke/XcodeBuildMCP`, now redirects to `getsentry/XcodeBuildMCP` — Sentry took stewardship, and the canonical package, docs site and Homebrew tap all live under that org. At 6,172 stars it is the most-adopted Xcode MCP server by a wide margin. It ships as one package with two modes off the same install: an MCP server for agents (`xcodebuildmcp mcp`, or on demand via `npx -y xcodebuildmcp@latest mcp` with no global install) and a plain CLI for terminal use (`xcodebuildmcp simulator build --scheme MyApp --project-path ./MyApp.xcodeproj`, `xcodebuildmcp tools`, `xcodebuildmcp upgrade --check`). Install with Homebrew (`brew tap getsentry/xcodebuildmcp && brew install xcodebuildmcp`) or npm (`npm install -g xcodebuildmcp@latest`); Homebrew is the path that does not require Node. Beyond build-and-run it covers the workflow steps agents usually cannot reach — booting and driving simulators, capturing logs through a per-workspace daemon that auto-starts for stateful operations, and splitting test builds from test runs via `--build-for-testing` and a portable `.xctestproducts` bundle so a prepared build can be executed later against a named simulator. It also installs optional agent Skills (`xcodebuildmcp init`) that prime the model on the tool surface — recommended for the CLI mode in particular. Requirements are strict and worth checking before you file a bug: macOS 14.5+, Xcode 16.x+, and Node 18+ unless you installed through Homebrew. Two behaviours to know up front: it asks xcodebuild to skip macro validation so Swift Macros projects do not fail the build, and device (as opposed to simulator) tools need code signing already configured in Xcode. Sentry is used for runtime error telemetry only, with documented opt-out. MIT licensed, TypeScript, actively maintained.

Turns your GraphQL API into MCP tools, from Apollo GraphQL itself. Rather than exposing a raw schema and hoping the model composes valid queries, the Apollo MCP Server takes a set of GraphQL operations you explicitly define and publishes each one as a named MCP tool, so an AI client calls a curated, tested operation instead of assembling ad-hoc GraphQL. It sits in front of a graph and needs three things configured: the graph itself, the operation definitions that become tools, and a config file describing how the server runs — all documented on the Apollo docs site. There are three ways to run it, which is the practical thing searchers want: the standalone binary (install with `curl -sSL https://mcp.apollo.dev/download/nix/latest | sh` on macOS/Linux, or the PowerShell `iwr` one-liner on Windows, and pin a version by swapping `latest` for e.g. `v1.17.0`); the Rover CLI via `rover dev --mcp <config>` (Rover v0.37+) to run the server alongside a local graph during development; and the Apollo Runtime Container, which can run the MCP server and the Apollo Router together in one container. Because tools map to predefined operations, you get persisted-query-style safety — the model cannot invent expensive or unauthorized queries — plus custom scalar handling, auth passthrough, CORS and error-handling controls covered in the config reference. Built in Rust, MIT licensed, actively maintained (released continuously), and the canonical repo is `apollographql/apollo-mcp-server`. This is the right MCP server for anyone exposing a GraphQL or federated supergraph to Claude, Cursor, or any MCP client. Compatible with all MCP-compliant clients over stdio and HTTP transports.

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.

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.

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.

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

The Vercel MCP server is a powerful Model Context Protocol integration that allows AI assistants like Claude, Cursor, and Cline to interact directly with your Vercel infrastructure. It exposes essential platform capabilities as AI-callable tools, meaning you can manage projects, trigger deployments, inspect build logs, and configure custom domains via natural language prompts. For frontend developers and DevOps teams working within the Vercel ecosystem, this eliminates the need to constantly context-switch between an IDE, terminal, and the Vercel dashboard. You can simply ask your AI agent to "check the status of the latest production deployment", "fetch the build logs for the staging environment and identify the Next.js hydration error", or "list all environment variables for the current project". By bridging the gap between your codebase and your hosting platform, the Vercel MCP server turns your AI assistant into an embedded DevOps engineer capable of diagnosing build failures and managing serverless deployments in real time. Vercel ships this as an official hosted (remote) MCP server at https://mcp.vercel.com — there is no package to install locally. Connect an MCP client to that URL and authenticate through the browser-based OAuth flow, which scopes access to the Vercel teams and projects your account can already reach rather than a long-lived Personal Access Token. For example, add it to Claude Code with `claude mcp add --transport http vercel https://mcp.vercel.com`, then complete the OAuth consent screen; the repo vercel/vercel-mcp-overview is the official public overview of this server, with full docs at vercel.com/docs/mcp/vercel-mcp.

The Netlify MCP Server is Netlify's official Model Context Protocol integration (netlify/netlify-mcp), acting as a bridge between AI coding agents and the Netlify API/CLI so they can create, build, deploy, and manage Netlify projects using natural-language prompts instead of manual dashboard clicks or hand-written API calls. Installed via `npx -y @netlify/mcp` (requires Node.js 22+, and the Netlify CLI installed globally for the best experience), it connects to Windsurf, Cursor, Claude Desktop/Code, VS Code Copilot, Cline, Warp, LM Studio, and any other MCP-compatible client, with one-click install links published for several of them. Core capabilities include creating and managing sites, triggering and monitoring deploys, modifying access controls and team permissions, installing or uninstalling Netlify extensions, fetching user/team/site metadata, and creating or updating environment variables and secrets. Authentication runs through the Netlify CLI's existing login session, so agents inherit whatever account/team access the developer already has rather than requiring a separately scoped token. Typical use: ask Claude to "deploy the current branch as a preview and give me the URL" or "add a STRIPE_SECRET_KEY environment variable to the production site" and the agent executes the equivalent Netlify CLI/API calls directly, which is useful for developers who want deploy and config management folded into an AI pair-programming workflow instead of context-switching to the Netlify dashboard.

The Docker MCP server (ckreiling/mcp-server-docker) gives an AI assistant direct control of a Docker daemon over the Model Context Protocol: containers, images, networks and volumes, as tools rather than shell commands. It is the community server most people mean by "Docker MCP" — distinct from Docker’s own Docker MCP Gateway, which does not manage your containers at all but runs *other* MCP servers inside containers. If you want to ask Claude why the postgres container keeps restarting, you want this one; if you want a single secure endpoint in front of twenty catalog servers, you want the gateway. The tool surface is explicit and small enough to reason about: list_containers, create_container, run_container, recreate_container, start_container, fetch_container_logs, stop_container and remove_container for containers; list_images, pull_image, push_image, build_image and remove_image for images; list_networks / create_network / remove_network and list_volumes / create_volume / remove_volume for the rest. Two resource templates, docker://containers/{id}/logs and docker://containers/{id}/stats, let a client read logs and live stats by container ID or name without a tool call. It also ships a docker_compose prompt that puts the model into a plan-then-apply loop — you describe the containers you want under a project name, the model proposes a concise plan, and nothing runs until you approve it; reopening the prompt with the same project name re-reads the state of everything created under it, which is how you clean up after a lost chat. It runs on the Python Docker SDK’s from_env, so DOCKER_HOST applies: set ssh://user@host and the same server administers a remote engine. Two limits are deliberate and stated by the project — privileged options like --privileged and --cap-add/--cap-drop are not supported, and container configuration passes through the model, so no secrets belong in it.

browser automation over MCP — navigate, click, fill, screenshot and run JavaScript in a real Chromium instance — but the first thing to know is that this server is archived. It was one of Anthropic's original reference servers and now lives in modelcontextprotocol/servers-archived, a repository GitHub reports as archived with no commits since May 2025. The npm package @modelcontextprotocol/server-puppeteer is still installable and still runs, and its last publish is from the same period, so treat it as frozen rather than broken: no new features, no security patches, no dependency bumps on Puppeteer itself. For new work the maintained successors are Microsoft's Playwright MCP server and ExecuteAutomation's Playwright MCP server, both of which cover the same ground with active releases. If you are maintaining an existing integration, the surface is small and easy to reason about. Seven tools: `puppeteer_navigate` (takes an optional `launchOptions` object mirroring PuppeteerJS LaunchOptions — changing it restarts the browser — and an `allowDangerous` flag that must be true before flags like `--no-sandbox` or `--disable-web-security` are accepted), `puppeteer_screenshot` (CSS selector for element shots, 800x600 default, optional `encoded` for a base64 data URI instead of binary content), `puppeteer_click`, `puppeteer_hover`, `puppeteer_fill`, `puppeteer_select`, and `puppeteer_evaluate` for arbitrary JavaScript in the page context. It also exposes two resource types the tools alone do not give you: `console://logs` for the live browser console stream and `screenshot://<name>` for captured PNGs. The README carries an explicit security caution worth repeating — the browser runs on your own machine, so it can reach local files and internal IP addresses, and should not be pointed at untrusted pages while sensitive data is reachable. The npx install opens a visible browser window; the Docker image `mcp/puppeteer` runs headless Chromium instead.

ExecuteAutomation's Playwright MCP Server is a community-maintained browser automation server (5,500+ GitHub stars) distinct from Microsoft's official microsoft/playwright-mcp — it leans further into test generation and visual workflows rather than pure accessibility-tree navigation. Beyond standard navigate/click/fill/screenshot tools, it can generate Playwright test code from a live browsing session, scrape full page content and structured data, execute arbitrary JavaScript in the page context, and drive API testing (GET/POST/PUT/PATCH/DELETE requests) alongside the browser tools. A standout feature is 143 real device presets for responsive testing — a single call like playwright_resize({ device: "iPhone 13" }) swaps in the correct viewport, user-agent, touch support, and device pixel ratio, and natural-language prompts like "test on iPad landscape" work directly through Claude. Install via `npm install -g @executeautomation/playwright-mcp-server`, Smithery, mcp-get, or the one-line `claude mcp add --transport stdio playwright npx @executeautomation/playwright-mcp-server` for Claude Code; VS Code one-click installers are also published. No API keys are required — it launches and drives a local Chromium/Firefox/WebKit browser directly. Choose this over Microsoft's official server when you specifically need auto-generated Playwright test scripts, JS execution, or device-emulation testing; choose Microsoft's for pure lightweight accessibility-tree page navigation. One maintenance fact the listings omit, checked against GitHub and npm on 2026-08-15: this repository has not been pushed since 2025-12-13 and npm 1.0.12 was published 2025-12-12, with 32 issues open. It is neither archived nor deprecated, so nothing warns you at install time — it installs, connects and works while its Playwright dependency drifts, whereas Microsoft's server ships continuously. Weigh the codegen, 143-preset device emulation and HTTP request tools against running an eight-month-old build. Note also that headless defaults to false on playwright_navigate, so it opens a visible browser window unless told otherwise, and that stdio-mode logging goes only to ~/playwright-mcp-server.log to keep the JSON-RPC stream clean.

The Sentry MCP Server is Sentry's official Model Context Protocol integration, purpose-built for human-in-the-loop coding agents like Claude Code, Cursor, and Windsurf. Rather than exposing every Sentry API endpoint, it focuses tightly on developer debugging workflows: searching and triaging issues, pulling stack traces and event details, inspecting performance traces, and querying project/team/org metadata in natural language. The primary deployment is a hosted remote MCP server at mcp.sentry.dev, built on Cloudflare's remote-MCP infrastructure, so most users connect with zero local setup — just add the remote URL to their client. For self-hosted Sentry instances or local development, a stdio transport is also available via npx @sentry/mcp-server, authenticated with a Sentry User Auth Token scoped to org:read, project:read, project:write, team:read, team:write, and event:write. AI-powered search tools (search_events, search_issues) translate natural-language queries into Sentry's query syntax, but require a configured LLM provider (OpenAI, Azure OpenAI, Anthropic, or OpenRouter) — all other tools work without one. Claude Code users can also install it as a plugin (claude plugin install sentry-mcp@sentry-mcp) for automatic subagent delegation whenever a conversation touches Sentry errors, issues, or traces. This turns "why did this deploy break in production" into a direct conversational debugging session instead of tab-switching into the Sentry dashboard.

The Datadog MCP Server is Datadog's official, vendor-hosted Model Context Protocol endpoint — not a package. Each Datadog site has its own URL of the form https://mcp.<your-site>/api/unstable/mcp-server/mcp (US1: mcp.datadoghq.com, EU1: mcp.datadoghq.eu), and OAuth 2.0 is the recommended way in; a Personal or Service Access Token as an Authorization bearer header is the documented fallback for CI, with DD_API_KEY plus DD_APPLICATION_KEY headers as a third option. Datadog ships first-party client integrations rather than expecting hand-written config: a Claude Code plugin (/plugin install datadog@claude-plugins-official, then /ddsetup and /ddtoolsets), a Claude connector from the Connectors Directory, plugins for Cursor, VS Code/Copilot, JetBrains and OpenCode, and a ChatGPT app in Preview for US1. Tools are grouped into toolsets selected with a ?toolsets= query parameter, and only `core` — logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, notebooks — loads by default; two dozen more cover alerting, DBM, DDSQL, RUM, profiling, security, Kubernetes, error tracking, feature flags, cost management and data observability, with apm, cases, code-exec and remote-actions in Preview and excluded from toolsets=all. Access requires the mcp_read or mcp_write role permission in addition to the normal resource permission, which is why a working connection can still return no data. Limits at time of writing are 50 requests per 10 seconds of tool-call burst and 50,000 tool calls per month, and the server is not GovCloud compatible.

The official Grafana MCP server connects Claude and other AI assistants directly to your Grafana instance and its surrounding observability ecosystem, turning natural-language questions into dashboard lookups, incident investigations, and datasource queries. Dashboard tools cover search, retrieval, JSONPath-scoped property extraction, patch-based editing, and per-panel query/datasource introspection, with context-window-aware helpers like get_dashboard_summary so an agent never has to pull a full multi-megabyte dashboard JSON just to answer a simple question. Query tools speak PromQL against Prometheus (including histogram-percentile helpers), LogQL against Loki, and native query languages for InfluxDB, ClickHouse, CloudWatch, Graphite, Athena, Snowflake, Elasticsearch/OpenSearch, and Quickwit datasources — most gated behind opt-in --enabled-tools flags to keep the default tool surface lean. It also wraps Grafana Incident for creating and updating incidents, Sift for automated error-pattern and slow-request investigations, full alerting CRUD (rules, contact points, notification policies) across Grafana-managed and external Alertmanager sources, Grafana OnCall schedule/shift/alert-group management, RBAC-gated admin tools for teams/users/roles, deeplink generation so the LLM never has to guess a dashboard URL, annotations, snapshots, PNG rendering via the Grafana Image Renderer, and provisioning-repo validation for git-sync workflows. Authentication is a Grafana service account token (Editor role, or granular RBAC scopes) passed as GRAFANA_SERVICE_ACCOUNT_TOKEN alongside GRAFANA_URL, and every tool category can be individually disabled to control context-window usage. On install, the recommended route is uvx: `uvx mcp-grafana` pulls the PyPI package mcp-grafana, which is published by Grafana Labs from this same repository — so despite the server being written in Go, the copy-paste command most Claude Desktop and Cursor configs use is a Python-tooling one, not a binary download. The alternatives are `go install github.com/grafana/mcp-grafana/cmd/mcp-grafana@latest` for a real binary, or the grafana/mcp-grafana container — `-t stdio` for local clients, or the default HTTP mode on :8000 (add `-t streamable-http`) with MCP_GRAFANA_SERVER_TOKEN set to authenticate callers when you expose it.

Query and analyze your Axiom logs, traces, and all other event data in natural language.

OpenAI does not publish a dedicated, first-party "MCP server" for its own API — a `openai/mcp-server` repo does not exist. Instead, OpenAI's official open-source contribution to the MCP ecosystem is on the client side: openai/openai-agents-python (27,000+ stars), a lightweight framework for building multi-agent workflows with the OpenAI API that ships native support for connecting to MCP servers as a tool source, letting an OpenAI-model-powered agent call out to any MCP server (filesystem, GitHub, databases, etc.) the same way a Claude-based agent would. In other words, OpenAI's MCP investment is "consume MCP tools from an OpenAI agent," not "expose OpenAI itself as an MCP server." Teams that specifically want to call OpenAI's chat, embeddings, or image-generation endpoints as MCP tools from Claude, Cursor, or another MCP client instead rely on small community-built wrapper servers around the OpenAI SDK, authenticated with an `OPENAI_API_KEY`, exposing tools like generate_completion, generate_embedding, or generate_image. Typical use of the Agents SDK side: build a Python agent that uses GPT models for reasoning while pulling live context through an MCP filesystem or web-search server. Update this entry if OpenAI ships a genuine first-party MCP server for its own API in the future.

The official Hugging Face MCP Server connects any MCP client to the Hugging Face Hub and thousands of Gradio AI Spaces. It is a hosted, remote server — there is no local install to run day to day, just a one-click connector at huggingface.co/mcp. Built-in tools cover hub_search, model_search, dataset_search, space_search, and paper_search, plus dynamic Gradio proxy tools that let you call individual Hugging Face Spaces as first-class MCP tools once you enable them from your account settings at huggingface.co/settings/mcp. Requests are authenticated with a Hugging Face access token passed as an Authorization: Bearer header (or via the OAuth login flow at /mcp?login), so tool access respects your account permissions and any gated-model/dataset agreements you have already accepted. One-click install is supported for Claude Desktop and claude.ai (via the Connectors gallery), Claude Code (claude mcp add hf-mcp-server -t http https://huggingface.co/mcp?login), Gemini CLI, VS Code, and Cursor, and the server also ships a companion Gemini CLI extension bundling a context file and custom commands. For self-hosting or local development, the underlying open-source implementation (huggingface/hf-mcp-server) can be run via npx @llmindset/hf-mcp-server in STDIO mode or as a Streamable HTTP / Streamable HTTP JSON-RPC service, and supports a HF_SKILLS_DIR option that exposes a shared skills catalog as skill:// MCP resources. Add ?no_image_content=true to the hosted URL to strip ImageContent blocks from Gradio-backed tool results.

Open-source tool for collaborative editing, versioning, evaluating, and releasing prompts.

The E2B MCP Server connects Claude Desktop and other MCP clients to E2B's cloud-hosted code sandboxes, giving an AI assistant a safe, isolated place to actually execute code instead of only reasoning about it. Each sandbox is a full Firecracker microVM with a real filesystem, package manager, and network access, so an agent can install dependencies, run scripts in Python, JavaScript, or other languages, read back stdout/stderr/exceptions, and iterate on failures the same way a human developer would in a REPL — a strong fit for data-analysis agents, coding assistants that need to verify generated code actually runs, and any workflow where letting the LLM execute arbitrary shell commands directly on the host would be unsafe. The server ships in two editions in the same repo: a JavaScript/Node package and a Python package, both wrapping the underlying E2B SDK and code-interpreter API. Install via `npx -y @e2b/mcp-server` (Node 18+) or the equivalent Python entry point, then set an E2B_API_KEY environment variable from the E2B dashboard; a Smithery one-click installer (`npx @smithery/cli install e2b --client claude`) is also documented. IMPORTANT: this repository is explicitly marked deprecated/no-longer-actively-maintained by E2B (last meaningful update several months ago) — it still installs and runs, and remains the highest-starred E2B-authored MCP entry point, but teams building new integrations should check E2B's current docs for whether a newer first-party server or their Code Interpreter SDK directly is now the recommended path before committing to long-term production use.

There are three different Figma MCP servers and the install command on most listings belongs to the one Figma no longer leads with, so start with which you are choosing. **Figma's recommended server is now the hosted remote one at `https://mcp.figma.com/mcp`** — nothing to install, OAuth in the client, attached with `claude mcp add --transport http figma https://mcp.figma.com/mcp`. It is also the only one with the write and cross-file tools (`use_figma`, `generate_figma_design`, `generate_diagram`, `create_new_file`, `search_design_system`, asset upload and download). **The Dev Mode desktop server ships inside the Figma Desktop app** — enable it in Dev Mode (Shift+D) from the MCP server section of the inspect panel and the app opens a local endpoint at `http://127.0.0.1:3845/mcp`. Figma's docs now describe the desktop server as being for specific organisation and enterprise cases and recommend the remote one instead. Because it runs in the app, it reads whatever you have selected on the canvas: exact colors, typography, spacing, auto-layout constraints, component variants, and — the part a token-based reader cannot do — your Code Connect mappings, so it emits your component names rather than generic divs. It requires a Dev or Full seat on a paid plan and the desktop app must be open. The repository linked here is `figma/mcp-server-guide`, Figma's own setup guide; Figma does not publish the server's source. **The community alternative is Figma-Context-MCP by GLips** (15,500+ stars), installed as `npx figma-developer-mcp --figma-api-key=YOUR_FIGMA_ACCESS_TOKEN`. It authenticates with a Personal Access Token from Figma Settings → Personal Access Tokens and calls the REST API, so it needs no desktop app, works headlessly in CI, and can read any file your account can open — including from a free plan. It exposes the document JSON, node lookup by ID, component listing, text extraction, and rendered-image download. The practical split: pick the official server when design-to-code fidelity and Code Connect matter and you are already paying for Dev Mode; pick GLips when you need automation, a free plan, or a machine with no Figma app installed. Both let an assistant translate a frame into accurate React, Tailwind, or plain HTML/CSS instead of guessing from a screenshot.

Twilio's official MCP server, built by the Twilio Alpha team and published as @twilio-alpha/mcp, exposes the entirety of Twilio's public API surface to AI assistants over the Model Context Protocol. Rather than hand-writing tool wrappers, the server auto-generates MCP tools directly from Twilio's OpenAPI specs, so it stays in sync with new Twilio products (Voice, Messaging/SMS, Verify, Lookup, Conversations, and more) as they ship. Because a full API surface can blow past an LLM's context window, the server supports --services and --tags flags to scope which Twilio products are loaded into a given session, keeping tool lists small and relevant. Authentication uses a Twilio Account SID paired with an API Key/Secret pair (created in the Twilio Console), passed as a single credential string at launch rather than long-lived account credentials. The monorepo also ships a companion openapi-mcp-server package that can turn any OpenAPI spec into an MCP server using the same generator, useful for teams building on top of Twilio's partner or vertical APIs. Twilio's security guidance explicitly recommends against running community MCP servers alongside the official one to reduce the risk of a compromised third-party tool touching production SMS, voice, or verification workflows tied to real phone numbers and customer data.

There is no official SendGrid MCP server, and that is the first thing worth knowing if you searched for one. Twilio owns SendGrid and does publish an official MCP server at twilio-labs/mcp, but that server is generated from Twilio's own Public API specs and covers none of SendGrid's v3 email endpoints — connecting it will not give an assistant a way to send an email or touch a contact list. Twilio's own developer blog acknowledges the gap by publishing a walkthrough on building a SendGrid MCP server yourself rather than shipping one. This entry therefore tracks the most established community implementation, Garoth/sendgrid-mcp (TypeScript, 29 stars), which wraps the SendGrid v3 Marketing API. Its tool surface is broader than most email servers: contact management (list_contacts, add_contact, delete_contacts, get_contacts_by_list), list management (list_contact_lists, create_contact_list, delete_list, add_contacts_to_list, remove_contacts_from_list), sending (send_email for one-off transactional mail with optional dynamic-template data, and send_to_list which creates a SendGrid Single Send against one or more list IDs), dynamic templates (create_template, list_templates, get_template, delete_template), plus get_stats, validate_email, list_verified_senders and list_suppression_groups. Those last two exist because SendGrid rejects sends from unverified senders and requires either a suppression_group_id or a custom_unsubscribe_url on a Single Send, so an agent has to look both up before it can complete a campaign. The README is explicit that only v3 APIs are supported — legacy templates will not work. Install is from source: git clone, npm install, then point your client at the built entrypoint with SENDGRID_API_KEY in the environment. Two cautions. The npm package named sendgrid-mcp is a different project (deyikong/sendgrid-mcp, 3 stars, which does offer a READ_ONLY mode) — do not assume npx installs the repo described here. And this server exposes delete_contacts, delete_list and delete_template, which are irreversible against a live marketing database; scope the API key narrowly rather than granting full access.

The Resend MCP Server is Resend's official Model Context Protocol integration, letting AI assistants send and receive transactional email, manage contacts, broadcasts, and domains directly from Claude, Cursor, or any MCP-compatible client. Resend offers two ways to connect: a fully hosted remote server at mcp.resend.com (Streamable HTTP, no local install, OAuth login on first connect) that works well for Claude web/desktop and Cursor, or the same open-source code run locally via `npx resend-mcp` (published to npm as `resend-mcp`) using stdio or HTTP transport for CI, headless agents, or self-hosted setups. Authentication is either OAuth (hosted mode, browser-based) or a Resend API key passed as a Bearer token — handy for servers where a browser login isn't possible. Setup is documented for Claude Code, Claude Desktop/web, Cursor, Windsurf, Codex, and GitHub Copilot in VS Code. Typical use: ask Claude to "send a welcome email to this new signup using our verified domain" or "list contacts added to the newsletter audience this week," and the MCP server routes the request through your existing Resend account — no custom SMTP or REST integration code required. With 546+ GitHub stars, it's one of the most widely adopted first-party MCP servers in the email/transactional-messaging category.

Anthropic's reference Model Context Protocol server for Google Drive — and a retired one, which is the first thing to know about it. The repository moved to modelcontextprotocol/servers-archived and was archived on 2025-05-28 with no commits since, while the npm package @modelcontextprotocol/server-gdrive stays published at 2025.1.14, so `npx @modelcontextprotocol/server-gdrive` still installs and runs without warning you. It is also much smaller than its reputation. The server exposes exactly one tool — `search`, which takes a query string and returns matching file names and MIME types. Everything else is MCP resources: files are addressed as `gdrive:///<file_id>`, with Google Workspace formats exported automatically (Docs to Markdown, Sheets to CSV, Presentations to plain text, Drawings to PNG) and all other file types served in their native format. Clients that do not surface resources well therefore look like the server is broken when it is behaving exactly as documented. Authentication is read-only by construction: the setup asks for the `https://www.googleapis.com/auth/drive.readonly` scope on an OAuth Client ID of type Desktop App, which means there is no tool here that can create, edit, move or reshare anything. The flow is manual — create a Google Cloud project, enable the Drive API, configure the consent screen, download the client key file, rename it to `gcp-oauth.keys.json` in the repo root, then run `node ./dist auth` once to write `.gdrive-server-credentials.json` beside it; a Docker path exists that mounts the key file and persists credentials in an `mcp-gdrive` volume. For maintained Drive access with writes, sharing controls and shared-drive support, the community server most teams move to is taylorwilsdon/google_workspace_mcp (PyPI `workspace-mcp`), which covers Drive as one of twelve Google Workspace services on a single connection. See the setup guide on this page for the full comparison.

Location services, directions, and place details from Google Maps Platform.

dbx-mcp-server (amgadabdelhafez/dbx-mcp-server) is a community-built MCP server that gives AI assistants full read/write access to a Dropbox account through Dropbox's public API. Tools cover core file operations (list, upload, download, copy, move, and safe-delete with recycle-bin support so nothing is destroyed permanently), folder creation, metadata lookups, and content search across an account, letting a client answer "find my Q3 budget spreadsheet" or "move all screenshots from this month into an Archive folder" without a human digging through folders manually. Authentication uses OAuth 2.0 with PKCE: register a Scoped-Access app in the Dropbox App Console, grant the specific permission scopes needed (files.metadata.read, files.content.read/write, sharing.write, account_info.read), and supply `DROPBOX_APP_KEY`, `DROPBOX_APP_SECRET`, `DROPBOX_REDIRECT_URI`, and a `TOKEN_ENCRYPTION_KEY` for secure local token storage with automatic refresh. Install by cloning the repo, running `npm install && npm run build`, then `npm run setup` to complete the OAuth flow. Note this is not affiliated with or endorsed by Dropbox — Dropbox itself ships a separate, narrower official MCP server (dropbox/mcp-server-dash) scoped specifically to Dropbox Dash search and AI-assistant integration rather than general file management.

Microsoft MCP (elyxlz/microsoft-mcp) is a community-built MCP server that wraps the Microsoft Graph API to give AI assistants access to OneDrive files alongside Outlook mail, Calendar, and Contacts in a single unified integration — useful since most OneDrive usage happens inside the same Microsoft 365 account as email and scheduling. The file toolset covers list_files (paginated OneDrive browsing), get_file (download content), create_file (upload), update_file, delete_file, search_files, and a cross-surface unified_search tool that searches emails, events, and files together in one call, letting a client answer "find the contract I emailed myself last week" without knowing whether it lives in Mail or OneDrive. The server supports multiple simultaneous Microsoft accounts (personal, work, school) via list_accounts/authenticate_account/complete_authentication tools using device-code OAuth. Setup requires a free Azure App Registration (Microsoft Entra ID → App registrations, public client flow enabled) with delegated Files.ReadWrite, Mail.ReadWrite, Calendars.ReadWrite, Contacts.Read, and People.Read permissions, then an MICROSOFT_MCP_CLIENT_ID environment variable. Install via `uvx --from git+https://github.com/elyxlz/microsoft-mcp.git microsoft-mcp`, or `claude mcp add microsoft-mcp -e MICROSOFT_MCP_CLIENT_ID=your-app-id -- uvx --from git+https://github.com/elyxlz/microsoft-mcp.git microsoft-mcp` for one-line Claude Code setup. Not an official Microsoft release.

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.

Asana ships an official MCP server, and it is a hosted remote one: the V2 endpoint at https://mcp.asana.com/v2/mcp, documented in Asana's own developer docs. There is nothing to install, but there is something to create — V2 requires OAuth 2.0 against a client ID and secret you register yourself at app.asana.com/0/my-apps, with a redirect URL that matches your client exactly (http://localhost:8080/callback for Claude Code, cursor://anysphere.cursor-mcp/oauth/callback for Cursor, http://localhost:3334/oauth/callback for most others). MCP apps in Asana do not use permission scopes: authorising grants the full tool set, and what it can actually reach is bounded only by what your Asana account can already see. Read tools include search_objects, get_task, get_tasks, get_my_tasks, get_project, get_portfolio, get_status_overview and get_workspace_agents; write tools include create_tasks and update_tasks (up to 50 per call), create_project, delete_task, add_comment and create_project_status_update; Claude and ChatGPT additionally get interactive preview tools that show a confirmation UI before committing. One documented plan limit matters: search_tasks is Premium-only, and non-Premium workspaces must use get_tasks instead. The community alternative, roychri/mcp-server-asana (npm @roychri/mcp-server-asana), runs locally on a personal access token and is the option to pick when you want READ_ONLY_MODE=true, which the official server has no equivalent of.

The Jira MCP server is Atlassian's official Remote MCP Server, giving AI assistants like Claude and Cursor direct, enterprise-grade access to Jira Software project management through natural-language interactions. Powered by Atlassian's Teamwork Graph and hosted on Cloudflare infrastructure, it requires no local process to run — authentication is handled via OAuth 2.1, making it the most secure way to connect AI to Jira in corporate environments. With this MCP server, product managers, engineers, and team leads can ask their AI to create and update Jira issues, transition ticket statuses through workflow stages, search with JQL (Jira Query Language), summarize sprint progress, view open epics and their child issues, retrieve assignee workloads, and bulk-triage backlogs. AI assistants can connect sprints to related Confluence documentation through Atlassian's graph layer, giving richer context for planning and retros. Enterprise customers including AT&T, NVIDIA, and Pfizer use Atlassian's MCP integration in production. Connect from Claude Desktop via Settings > Connectors, or add it to Claude Code with: `claude mcp add --transport http atlassian https://mcp.atlassian.com/v1/mcp/authv2`. Cursor and Windsurf users add the remote URL to their MCP config file. No install command needed — it's a fully hosted remote MCP server.

The Atlassian Remote MCP Server brings Confluence and Jira into any MCP-compatible AI assistant, IDE, or agent platform through a centrally hosted, enterprise-grade connection backed by Atlassian's Teamwork Graph. Launched in May 2025 with Anthropic as the first official partner and hosted on Cloudflare infrastructure, authentication is handled via OAuth 2.1 — no local server process to deploy or maintain. For Confluence specifically, available operations include summarizing pages and spaces, creating new pages from AI-generated content, searching across your wiki with natural language, and performing multi-step knowledge retrieval across Confluence spaces. Jira operations include creating, updating, and triaging work items, summarizing sprint state, and linking knowledge to in-flight issues. Atlassian's Teamwork Graph underpins every response — connecting people, services, knowledge, and work items into a unified context for richer AI answers. Enterprise customers at AT&T, NVIDIA, Pfizer, Booking.com, and Visa use the integration in production. Connect from Claude Desktop via Settings > Connectors, or from Claude Code with: `claude mcp add --transport http atlassian https://mcp.atlassian.com/v1/mcp/authv2`. Cursor and Windsurf users can add the remote URL directly to their MCP config.

The Todoist MCP Server is Doist's own first-party integration (doist/todoist-mcp) that lets Claude, Cursor, and other MCP clients read and modify a Todoist account on the user's behalf using natural language. It exposes tools for the full task lifecycle — add tasks, find tasks by date or filter query, update, complete, and reopen tasks, and manage projects, sections, labels, and comments — so an assistant can act on requests like "add 'file taxes' to my Finance project due next Friday" or "what's overdue across all my projects?" without leaving the chat. The recommended setup is the hosted, streamable-HTTP server at https://ai.todoist.net/mcp, which runs OAuth in the browser the first time a Todoist tool executes, so there are no API keys to manage. For Claude Code the fastest path is the official plugin: `/plugin marketplace add doist/todoist-mcp` then `/plugin install todoist@doist`; you can also wire it up manually with `claude mcp add --transport http todoist https://ai.todoist.net/mcp`, or point Cursor and VS Code at the same URL via mcp-remote. The underlying tools are additionally published as an npm package (`@doist/todoist-mcp`) that can be imported directly into a custom AI SDK agent for embedding Todoist actions in your own conversational interface. Being maintained by Doist, the maker of Todoist, this is the canonical, officially supported server rather than a community reimplementation.

CircleCI's official MCP server exists to close one specific loop: a build fails, and the person who has to fix it is already in an editor with an AI assistant open, not in the CircleCI web UI reading logs. get_build_failure_logs pulls the actual failure output for a branch or pipeline into the conversation, which is enough for an assistant to propose a patch against the real error rather than a guessed one. get_latest_pipeline_status answers whether the branch is currently green, and get_job_test_results returns test metadata so a model can distinguish a genuine regression from an environment problem. Beyond triage, the server covers the workflows around a build. find_flaky_tests analyses execution history to name the tests that pass and fail without a code change — the single most valuable tool here, because flakiness is exactly the kind of pattern that is obvious across hundreds of runs and invisible in any one of them. find_underused_resource_classes reports jobs provisioned larger than their actual compute use, which is a direct cost lever on a CI bill, and download_usage_api_data pulls raw Usage API data for the same analysis. config_helper validates a .circleci/config.yml and explains what is wrong with it, so an assistant can iterate on config without pushing commits to find out. Control tools cover run_pipeline, rerun_workflow (from the start or just from the failed job), run_rollback_pipeline, list_artifacts, list_followed_projects and list_component_versions. Installation is npx -y @circleci/mcp-server-circleci@latest with CIRCLECI_TOKEN in the environment, and there is an official Docker image (circleci/mcp-server-circleci) plus a self-managed remote-server mode documented for teams that would rather run one shared instance than a process per developer. CIRCLECI_BASE_URL is optional and only needed by on-prem customers. Note that rerun_workflow, run_pipeline and run_rollback_pipeline are write operations against real infrastructure — a rollback pipeline in particular ships to production — so a token scoped to the projects you want an agent touching is worth setting up before you connect it.

Exposing Buildkite data (pipelines, builds, jobs, tests) to AI tooling.

MCP support for Jenkins delivered as a Jenkins plugin rather than a standalone server — you install it from the update centre (plugin id mcp-server, currently 0.188, requires Jenkins 2.533 or newer) and the controller itself starts answering MCP over HTTP with no further configuration. Three transports are exposed and all are on by default: Streamable HTTP at <jenkins-url>/mcp-server/mcp (recommended), SSE at /mcp-server/sse with /mcp-server/message, and a session-free /mcp-server/stateless endpoint for clients that make independent one-shot requests. Authentication reuses Jenkins credentials: generate an API token under your user Security page and pass username:token as HTTP Basic auth. The default tool set is genuinely operational rather than read-only — getJob, getJobs, triggerBuild and getQueueItem for job management; getBuild, updateBuild, getBuildLog, searchBuildLog, rebuildBuild, getReplayScripts, replayBuild and getTestResults for builds; getJobScm, getBuildScm, getBuildChangeSets and findJobsWithScmUrl for SCM; whoAmI and getStatus for instance health. getBuildLog is the one worth reading about before you wire this into an agent: it paginates with a cursor tied to a specific (job, buildNumber), supports end-relative reads with negative skip/limit, and reads a non-blocking snapshot so it returns promptly against a build that is still running. Two deployment gotchas the README calls out: Jenkins runs Winstone with a 30-second httpKeepAliveTimeout that races the plugin's 30-second MCP keep-alive, so start Jenkins with --httpKeepAliveTimeout=600000, and behind Nginx you need proxy_buffering off with 600s read/send timeouts on the /mcp-server/ paths. Origin header validation is off by default so agents that omit the header still work; enable it with the requireOriginMatch system property. The plugin is extensible — implement McpServerExtension and annotate methods with @Tool to add your own, or set override = true to replace a built-in.

The Kubernetes MCP server (mcp-server-kubernetes, built by Flux159) brings cluster management capabilities into AI assistant workflows, letting developers and platform engineers query and manage Kubernetes resources through natural-language interactions with Claude, Cursor, and other MCP-compatible clients. It loads your existing kubeconfig automatically, so it works with any cluster — local minikube and kind setups, Amazon EKS, Google GKE, Azure AKS, or on-premises deployments — with no separate credential setup required. Core tools exposed by the server include: listing pods, deployments, services, and namespaces; describing individual resources and their status; fetching pod logs for debugging; applying and updating manifests; scaling deployments; checking rollout status and history; and querying resource utilization and cluster events. A built-in non-destructive mode can disable delete/scale-down operations entirely, making it safe to point at production clusters for read-only diagnostics. DevOps engineers use it to debug failing deployments by asking Claude to inspect pod logs and recent events, identify resource constraints causing OOMKilled pods, or summarize the current state of a namespace before a production release. For SREs responding to incidents, it enables rapid triage through conversational commands — no memorizing kubectl flags or switching terminal windows mid-incident — and optional OpenTelemetry integration adds observability into what the AI agent actually did against the cluster. Install with: `npx mcp-server-kubernetes`. Pairs well with the GitHub MCP server for full GitOps review workflows.

live Terraform Registry data — provider schemas, module inputs and outputs, policy libraries — plus full HCP Terraform and Terraform Enterprise workspace management, so an AI assistant writes HCL against the real resource arguments instead of inventing attribute names from memory. HashiCorp distributes it as a Go binary and a Docker image, not as an npm package: `@hashicorp/terraform-mcp-server` returns 404 on the npm registry, so npx configurations copied from older write-ups cannot work. The supported install is the hashicorp/terraform-mcp-server image on Docker Hub (v1.1.0, released 2026-07-14), run with `docker run -i --rm hashicorp/terraform-mcp-server:1.1.0`, or the release binary invoked as `terraform-mcp-server stdio`. Both transports are supported: stdio for local clients, and streamable-http via `terraform-mcp-server streamable-http --transport-port 8080 --mcp-endpoint /mcp` for shared deployments. Registry lookups need no credentials at all — only the HCP Terraform and Terraform Enterprise tools do, via TFE_TOKEN plus TFE_ADDRESS (which must include the protocol, e.g. https://app.terraform.io, and in streamable-http mode can only be set as an environment variable, never supplied by a client header). Two flags matter before you expose it to a team: ENABLE_TF_OPERATIONS is false by default and gates the tools that mutate infrastructure, and the HTTP server defaults to strict CORS with 10:20 global and 5:10 per-session rate limits, an MCP_ORGANIZATION_ALLOWLIST for restricting which HCP organisations can connect, and required MCP_TLS_CERT_FILE / MCP_TLS_KEY_FILE for any non-localhost bind. Server instructions live in cmd/terraform-mcp-server/instructions.md and are meant to be replaced with your own conventions if the default answers do not match how your organisation writes Terraform.

Discover, extract, and interact with the web - one interface powering automated access across the public internet.

The Algolia MCP Server is Algolia's official remote MCP endpoint at https://mcp.algolia.com/mcp, authenticated with OAuth. It is a hosted service rather than a package you install, so there is no public server repository to clone — the closest public source is algolia/skills, the companion Agent Skills marketplace whose algolia-mcp skill documents the tool surface. Access is user-scoped and READ-ONLY across every Algolia application and index the signed-in account can reach; for writes (imports, exports, backups, index settings, synonyms, rules, API key management) Algolia points you at the separate Algolia CLI instead. Before connecting, enable the server in the Algolia dashboard under Generate AI → MCP Servers → Productivity; disabling it there cuts off all connected workflows immediately. Add it in Claude Code with `claude mcp add --transport http algolia https://mcp.algolia.com/mcp`, in Codex with `codex mcp add algolia --url https://mcp.algolia.com/mcp` followed by `codex mcp login algolia`, or as an http server entry in ~/.vscode/mcp.json or ~/.cursor/mcp.json; leave any OAuth client ID and secret fields blank and let discovery handle it. The tools split three ways. Search: algolia_search_index, algolia_search_list_indices (call this first — it enumerates accessible applications and returns exact index names), and algolia_search_for_facet_values. Analytics: algolia_analytics_top_searches, searches_no_results, no_results_rate, click_positions, no_click_rate, top_searches_without_clicks, number_of_searches, top_search_results, number_of_users, top_filters, top_filters_no_results, and top_countries. Recommendations: a single algolia_recommendations tool switched by a `model` parameter across bought-together, related-products, trending-items, trending-facets, and looking-similar. Search calls accept Algolia's native filter syntax — facetFilters arrays (inner arrays OR, outer arrays AND), numericFilters strings such as `price < 100`, and Unix-timestamp ranges for dates — with 0-indexed pagination, a default hitsPerPage of 5, and a 1000 maximum.

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).

Payments MCP is Coinbase's official npm-installed MCP server and companion wallet app that combines wallets, onramps, and payments via the x402 protocol into a single solution for agentic commerce. It lets AI agents autonomously discover and pay for services without requiring API keys, seed phrases, or manual intervention — install with `npx @coinbase/payments-mcp` and the installer walks through client setup (Claude Desktop, Claude Code, Codex, Gemini CLI, or other MCP-compatible tools) with optional automatic configuration. Full docs live at docs.cdp.coinbase.com/payments-mcp. Separately, developers wanting broader onchain/crypto-portfolio tooling should note the Coinbase Developer Platform also published `base-mcp-legacy` (Base network + Coinbase API tools for LLMs), though it has since been archived in favor of the newer AgentKit-based tooling.

Official CoinGecko API MCP Server for Crypto Price & Market Data, across 200+ Blockchain Networks.

Plaid's official AI Coding Toolkit ships a local sandbox MCP server (in `/sandbox`) that speeds up building Plaid integrations with AI coding assistants — it generates mock financial data, searches Plaid documentation, issues sandbox access tokens, and simulates webhooks, so a developer can test an integration end-to-end without touching real bank data. The repo also bundles product-specific `/rules` guides meant to be dropped into CLAUDE.md, AGENTS.md, or Cursor rules so an AI assistant has Plaid integration context automatically. It complements two other first-party Plaid AI tools referenced in the same repo: the Plaid CLI (terminal access to financial data) and the Plaid Dashboard MCP (runtime dashboard access, docs-hosted at plaid.com/docs/resources/mcp). For read-only personal-finance use cases spanning multiple providers, elcukro/bank-mcp is a community alternative that supports Plaid alongside Teller, Enable Banking, and Tink.

The Shopify MCP Server (GeLi2001/shopify-mcp) gives AI assistants full CRUD access to a Shopify store through the GraphQL Admin API, turning natural-language requests into store operations. It exposes tools across five areas: product management (create, update, delete products, variants, and options — 8 tools), customer management (lookups, merges, address management — 8 tools), order management (smart lookup, cancel, close/open, mark as paid, fulfillment, and refunds — 10 tools), metafields (get/set/delete on any resource), and inventory (set absolute quantities per location), plus tagging and cursor-based pagination with Shopify's native query syntax on every list endpoint. Authentication supports two paths: the modern Dev Dashboard flow (required for new apps created after January 2026), which uses OAuth client credentials that the server automatically exchanges and refreshes, or a legacy static shpat_ access token for existing custom apps. Install via `npx shopify-mcp` (package name shopify-mcp, published to npm) with either --clientId/--clientSecret or --accessToken/--domain flags passed in your MCP client config — no separate server process to manage. Typical use: ask Claude to "find all orders over $500 from the last week and tag the customers as VIP," and the server handles the GraphQL queries and mutations directly against the store's Admin API. Shopify itself also publishes an official shopify-dev-mcp for app/theme developers working against Shopify's documentation and APIs, which is a separate, docs-focused tool from this store-data server.

Search Packrift packaging supplies, check product and inventory context, and create ecommerce cart URLs.

The YouTube MCP Server by Zubeid Hendricks connects AI assistants to the full YouTube Data API v3, letting Claude search videos, pull transcripts, manage content, and run analytics without leaving the conversation. It is one of the most complete community YouTube MCP servers, exposing tools across several areas: video management (search by keyword, retrieve metadata, get statistics, and list a channel's uploads), transcript retrieval (fetch full captions for any public video for summarization or Q&A), channel operations (look up channel details, subscriber and view counts, and recent activity), playlist tools (list and inspect playlist contents), Shorts creation workflows, and advanced analytics for creators tracking performance. Authentication uses a single YOUTUBE_API_KEY obtained free from the Google Cloud Console by enabling the YouTube Data API v3 — read-heavy operations fit comfortably inside the daily quota. Install globally with npm as zubeid-youtube-mcp-server, run it directly with npx (no install required), or add it through Smithery for one-click Claude Desktop setup; a Docker image is also provided for HTTP transport. The YouTube MCP Server is ideal for content research, competitive analysis, transcript-based summarization, and automated creator workflows — Claude can, for example, find the top videos on a topic, fetch their transcripts, and synthesize a briefing in a single pass.

Marcel Marais's Spotify MCP Server is a lightweight TypeScript bridge between AI assistants and the Spotify Web API, letting Claude control playback and search a listener's library through natural language. It exposes tools for searching tracks/albums/artists/playlists, controlling playback (play, pause, skip, queue management), reading and modifying the current queue, and browsing a user's playlists and saved library. Authentication uses standard Spotify OAuth (client ID/secret from the Spotify Developer Dashboard) with a one-time login flow to obtain a refresh token, after which the server runs locally via the MCP stdio transport. Typical use: ask Claude to "queue up some upbeat workout music" or "what's currently playing," and it calls the Spotify API directly rather than requiring the user to switch to the Spotify app.

Exposes Cloudinary's media upload, transformation, AI analysis, management, optimization and delivery.

The official ElevenLabs MCP server (elevenlabs/elevenlabs-mcp) connects AI assistants like Claude Desktop, Cursor, Windsurf, and OpenAI Agents directly to ElevenLabs' text-to-speech and audio-processing APIs. Once installed, an AI client can generate natural-sounding speech from text in dozens of voices and languages, clone a voice from a short audio sample, design and save new synthetic voices to a personal voice library, transcribe spoken audio with automatic speaker diarization, isolate vocals from background noise, and compose layered soundscapes (e.g. "a thunderstorm in a dense jungle with animals reacting") from a text prompt. It also exposes ElevenLabs' Conversational AI agent-creation tools, so a client can spin up a voice agent with a defined persona and have it answer questions in character. Install via PyPI/uv with `uvx elevenlabs-mcp` and an `ELEVENLABS_API_KEY` from the ElevenLabs dashboard — the free tier includes 10k credits/month, enough for testing. Optional environment variables (`ELEVENLABS_MCP_BASE_PATH`, `ELEVENLABS_MCP_OUTPUT_MODE`) control whether generated audio is saved to disk, returned as base64-encoded MCP resources for containerized/serverless environments, or both, and `ELEVENLABS_API_RESIDENCY` supports enterprise data-residency requirements. With 1,450+ GitHub stars, it is the most widely adopted way to give an AI coding assistant real audio-generation capabilities without hand-rolling API calls.

The Discord MCP Server (SaseQ/discord-mcp) is a Java-based Model Context Protocol integration built on JDA (Java Discord API) that turns a Discord bot into a set of tools AI assistants can call directly. It lets Claude, Cursor, and other MCP clients read and send channel messages, manage threads, create and moderate channels and categories, manage roles and permissions, look up server (guild) members, and pull message history — enabling AI-driven community moderation, automated announcements, and Discord-native workflows without hand-writing bot code. The recommended install is Docker: set DISCORD_TOKEN (from a bot registered in the Discord Developer Portal) and an optional DISCORD_GUILD_ID as environment variables, then run the saseq/discord-mcp:latest image with SPRING_PROFILES_ACTIVE=http, which exposes the MCP endpoint at http://localhost:8085/mcp for remote/HTTP-transport clients. A Docker Compose path and a stdio-transport mode are also documented for local, per-client setups like Claude Desktop. Because it wraps JDA (Spring Boot underneath), it handles Discord's gateway/rate-limit quirks for you rather than requiring a hand-rolled REST client. This is the most-starred dedicated Discord MCP implementation; other community servers like v-3/discordmcp and hanweg/mcp-discord cover similar ground with lighter Node/Python stacks if a non-JVM runtime is preferred.

A Telegram MCP server that connects Claude, Cursor, and other MCP-compatible clients directly to a Telegram user account via the Telethon library, exposing 80+ tools grouped into accounts, chats/groups, messages, contacts, media, profile/privacy, and folders/drafts. It supports multi-account setups (list accounts and route tool calls by label), full group and channel administration (create/join/leave, invites, bans, admin roles, slow mode, topics), rich messaging (send, schedule, edit, delete, forward, pin, reply, search, polls, reactions, inline button inspection and press), contact management (add/remove/block/import/export), and media handling (files, voice notes, stickers, GIFs, downloads/uploads). All tool results containing Telegram user-controlled content are sanitized before being returned as structured JSON, and a device-identity feature lets the session appear as a distinct, labeled client rather than a generic script. Authentication uses a Telegram API ID/hash from my.telegram.org plus a generated session string — no bot token required, since this operates as a full user account. A `TELEGRAM_EXPOSED_TOOLS=read-only` mode is available to restrict the MCP surface to read-only tools when write access is not needed. The project explicitly warns against installing the unrelated `telegram-mcp` package from PyPI, which is owned by a different, unaffiliated project — always install from source via `uv sync`.

The WhatsApp MCP server connects Claude and other MCP clients directly to your personal WhatsApp account so an AI assistant can search, read, and send messages, contacts, and media through natural language. Unlike hosted bots that require the paid WhatsApp Business API, this community server (lharries/whatsapp-mcp, the most-adopted WhatsApp MCP server on GitHub) links to your regular account via the WhatsApp Web multidevice API using the Go whatsmeow library — you authenticate once by scanning a QR code, then re-authenticate roughly every 20 days. It runs as two components: a Go bridge that maintains the WhatsApp connection and stores your full message history in a local SQLite database, and a Python MCP server that exposes tools to the agent. Messages stay on your machine and are only sent to the LLM when a tool explicitly reads them, so you control what the model sees. Available tools cover searching contacts and chats, reading individual and group conversations (including images, video, documents, and audio), sending text messages to people or groups, and sending media — with optional FFmpeg-based conversion to play audio as native WhatsApp voice notes. Note the "lethal trifecta" caution in the README: because it combines private data, tool access, and external content, prompt injection could risk data exfiltration.

Connect to the Cal.com API to schedule and manage bookings and appointments.

Calendly MCP Server connects an AI assistant to Calendly's scheduling platform — Calendly itself doesn't publish an official MCP server, so the top community implementation is meAmitPatil/calendly-mcp-server, runnable instantly via `npx calendly-mcp-server`. It covers the core Calendly API surface (fetch the current authenticated user, list and retrieve scheduled events, manage invitees, cancel events, list organization memberships) plus the newer Scheduling API, which lets the assistant book meetings programmatically without redirecting the user to a Calendly link: discovering available event types, checking real-time availability for any event type, and completing an end-to-end booking with calendar sync and notifications across Zoom, Google Meet, Teams, physical locations, or custom locations. Authentication supports either a Personal Access Token generated from the Calendly Integrations page (simplest, for single-user/internal use) or full OAuth 2.0 with client ID/secret for multi-user public applications. Setting optional user-context environment variables improves performance by supplying sensible defaults instead of requiring a lookup call on every request. For teams that want an AI assistant to check availability and schedule meetings conversationally instead of copy-pasting Calendly links, this server closes that gap despite the lack of an official vendor-maintained option.

The Obsidian MCP server connects AI assistants to your local Obsidian vault through the Obsidian Local REST API community plugin, enabling read, write, and search operations on your personal knowledge base. With 4,280+ GitHub stars, mcp-obsidian by MarkusPfundstein is the most widely adopted Obsidian MCP integration available. The server exposes seven tools: list_files_in_vault (enumerate all vault files and directories), list_files_in_dir (browse a specific folder), get_file_contents (read any note by path), search (full-text search across all vault notes), patch_content (insert text relative to a heading, block reference, or frontmatter field), append_content (add text to a new or existing note), and delete_file (remove a note or folder). Install via a single uvx command; set OBSIDIAN_API_KEY, OBSIDIAN_HOST, and OBSIDIAN_PORT environment variables (default port 27124). You must first install and enable the Obsidian Local REST API community plugin inside your vault settings — it exposes the HTTP endpoint this server bridges. Works with Claude Desktop, Cursor, Windsurf, Cline, and any MCP-compatible client. Ideal for summarizing meeting notes, searching research across hundreds of Markdown files, drafting new pages from AI output, or building second-brain workflows where Claude reads and writes your full knowledge base.

The Roam Research MCP Server is the official, first-party Model Context Protocol server for Roam Research, published by the Roam Research team itself and covering the full read/write surface of your Roam graph. It connects to Roam's local HTTP API, which runs inside the Roam desktop app (not the web version) — if Roam isn't open when a tool is called, the server automatically launches it via deep link and retries. Setup runs through an interactive `connect` flow (`npx @roam-research/roam-mcp connect`) that walks you through selecting a graph, choosing an access level (full, read-append, or read-only), and approving a local API token inside Roam's Settings > Graph > Local API Tokens screen; a non-interactive flag-based mode is also available for scripted or agent-driven setup. Multiple graphs can be connected simultaneously, each addressable by a short nickname. The tool surface spans six areas: graph management (list_graphs, setup_new_graph), graph guidelines (get_graph_guidelines reads a special `[[roam/agent guidelines]]` page for user-defined AI instructions), content mutation (create/update/delete for pages and blocks, append_to_daily_note, move_block, add_comment/get_comments), read/search (search, roam_query for `{{query:}}` blocks, datalog_query for raw Datomic queries, get_page, get_block, get_backlinks), navigation (get_open_windows, get_selection, open_main_window, open_sidebar), and file handling (file_get/file_upload/file_delete, including encrypted-graph decryption). The README flags this as alpha software and explicitly warns that write operations are difficult or impossible to fully undo since Roam lacks bulk-operation undo history — back up your graph before granting full write access. A companion CLI (`@roam-research/roam-cli`) is available for terminal-driven graph interaction outside an MCP client. Works with Claude Desktop, Claude Code, Cursor, and any MCP-compatible client. Ideal for daily-note capture, backlink-driven knowledge retrieval, and agent-assisted graph restructuring for second-brain / networked-note workflows.

There is no official, Snyk-published Model Context Protocol server as of this writing — a commonly referenced `snyk/mcp-server` repo does not exist. The most active real alternative is sammcj/mcp-snyk, a community-built, MIT-licensed MCP server that wraps Snyk's API and CLI for agentic security scanning (marked alpha by its author, so expect rough edges). It exposes tools to scan a GitHub or GitLab repository by URL for vulnerabilities, scan an existing Snyk project by ID, and verify that a configured API token is valid, returning the associated user and organization info. Authentication uses a Snyk API token and an org ID, supplied via `SNYK_API_KEY`/`SNYK_ORG_ID` environment variables, falling back to the locally configured Snyk CLI org if one isn't set explicitly. Install with `npx -y github:sammcj/mcp-snyk` in your MCP client config (Claude Desktop, Cursor, etc.). Typical use: ask Claude to "scan https://github.com/org/repo for security vulnerabilities using Snyk" and get back a structured findings summary instead of switching to the Snyk web console. Snyk's own engineering org separately maintains snyk/agentic-integration-wrappers, a set of wrappers for plugging Snyk scanning into agentic workflows more broadly — worth checking if this community MCP server doesn't cover your use case, since it isn't an official Snyk product and has no guaranteed support or roadmap.

The official SonarQube MCP Server, built and maintained by SonarSource, connects AI agents like Claude, Cursor, and VS Code Copilot to SonarQube Server or SonarQube Cloud so code quality and security become part of the agent's workflow rather than a separate CI step. Through it an assistant can pull the projects a token can see, retrieve open issues and code smells, inspect quality gate status and project metrics, and — notably — analyze a code snippet directly inside the agent context without the code first being committed and scanned by a pipeline, which lets Claude check its own just-written code against SonarQube's rules before you ever push. Authentication is a SonarQube user token supplied via the `SONARQUBE_TOKEN` environment variable; SonarQube Cloud users also set `SONARQUBE_ORG` (organization key), and self-hosted SonarQube Server users set `SONARQUBE_URL` to point at their instance (SonarQube Cloud US uses `https://sonarqube.us`). The server is distributed as a Java-based OCI container image at `sonarsource/sonarqube-mcp` on Docker Hub — run it with `docker run --pull=always -i --rm -e SONARQUBE_TOKEN -e SONARQUBE_ORG sonarsource/sonarqube-mcp`, or pin a version tag for reproducible deployments — and works with any OCI-compatible runtime such as Podman or nerdctl. SonarSource also provides an interactive Configuration Generator at mcp.sonarqube.com that emits ready-to-paste client config. Ideal for teams that want AI-assisted code review grounded in the same rules and quality gates their SonarQube project already enforces.

Connects AI agents with the CrowdStrike Falcon platform for intelligent security analysis.

The official Auth0 MCP server lets Claude, Cursor, and Windsurf manage an Auth0 tenant end-to-end through natural language instead of the dashboard — create applications, deploy Actions, debug logs, and manage resource servers just by asking. Its standout feature is the guided onboarding flow: the auth0_onboarding tool detects your project framework, creates a correctly configured Auth0 application, writes credentials straight into a .env file (auto-added to .gitignore), and hands off to auth0_get_quickstart_guide, which resolves callback URLs and returns framework-specific SDK integration code — taking a project from zero to a working Auth0 login in one guided conversation. Beyond onboarding, the tool surface spans Applications (list/get/create/update, plus credential export), Resource Servers/APIs (create and manage scopes, token lifetimes, signing algorithms), Application Grants (authorize M2M apps against specific APIs with defined scopes), Actions (create, update, and deploy post-login/pre-token logic), Logs (search and inspect authentication events, e.g. failed logins from a given IP), and Forms (build and publish branded login/signup/password-reset forms). Installs via npx with a device-authorization OAuth flow that stores credentials in your system keychain, supports Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Gemini CLI, and Codex, and exposes --tools/--read-only flags to scope down which operations an AI agent can perform — important given its Beta status and full read/write tenant access by default.

Retrieval from AWS Knowledge Base using Bedrock Agent Runtime.

Access to key Azure services and tools like Azure Storage, Cosmos DB, the Azure CLI, and more.

Google Cloud's official MCP server enables AI agents (like Claude Desktop, Cursor, Gemini CLI, and Windsurf) to securely interact with GCP services and deploy applications directly to Cloud Run. It exposes essential deployment and observability tools: `deploy-file-contents` (deploys files directly), `list-services`, `get-service`, and `get-service-log`. When running locally, it additionally provides `deploy-local-folder`, `list-projects`, and `create-project` (which creates a new GCP project and attaches it to the first available billing account). The server supports natural language prompts like 'deploy' and 'logs' for faster workflows. It respects standard Google Cloud SDK authentication (`gcloud auth login`) and can be configured via environment variables like `GOOGLE_CLOUD_PROJECT`, `GOOGLE_CLOUD_REGION`, and `DEFAULT_SERVICE_NAME`. It also includes an anti-DNS-rebinding security feature (`ENABLE_HOST_VALIDATION`).

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.

The Heroku MCP Server is the official Model Context Protocol implementation from Heroku, giving Claude, Cursor, Zed, Windsurf, Cline, and VS Code direct LLM-driven control over Heroku Platform resources without leaving the chat. Application-management tools cover list_apps/get_app_info/create_app/rename_app/transfer_app plus deploy_to_heroku (deploys straight from an app.json manifest, including team and private-space targets) and deploy_one_off_dyno for running sandboxed one-off scripts or tests. Process tools (ps_list/ps_scale/ps_restart) handle dyno scaling and restarts, while add-on tools list, inspect, and provision add-ons per app. A dedicated Postgres toolset — pg_psql, pg_info, pg_ps, pg_locks, pg_outliers, pg_credentials, pg_kill, pg_maintenance, pg_backups, pg_upgrade — lets the model run SQL directly against Heroku Postgres and diagnose slow queries or blocking locks. Pipeline tools (pipelines_create/promote/list/info) and team/space tools (list_teams, list_private_spaces) round out CI/CD and org-management coverage, alongside maintenance-mode toggles and app log retrieval. The recommended install is `heroku mcp:start` via the Heroku CLI (v10.8.1+), which reuses your existing CLI login so no HEROKU_API_KEY needs to be set; an `npx -y @heroku/mcp-server` path is available for clients that need a directly configured API-key auth flow instead. The project is explicitly labeled early-development by Heroku, so tool coverage is still evolving.

DigitalOcean MCP Server gives Claude, Cursor, and other MCP clients direct access to your DigitalOcean cloud infrastructure. The actively maintained community server lives at digitalocean-labs/mcp-digitalocean, built on the official godo Go SDK and the mark3labs/mcp-go framework — the earlier @digitalocean/mcp npm package under the digitalocean org has been archived in favor of this project. It exposes tools for managing Droplets, Kubernetes clusters, App Platform deployments, Spaces object storage, databases, VPCs, load balancers, and DNS records, letting an AI assistant provision, inspect, and tear down cloud resources through natural-language prompts instead of the doctl CLI or web console. Authentication uses a DigitalOcean Personal Access Token supplied via the DIGITALOCEAN_API_TOKEN environment variable — the README explicitly warns against hardcoding it into client config files, since committing a token to GitHub triggers automatic revocation. Typical workflows include deploying an app from a GitHub repo, redeploying with the latest changes, tailing logs, restarting components, and auditing which regions and droplet sizes are available before provisioning. Because it operates directly against billable cloud infrastructure, DigitalOcean recommends scoping tokens narrowly and reviewing any destructive action (deleting droplets, dropping databases) before confirming it in your MCP client.

Real User Monitoring data from Datadog.

Mixpanel MCP server for read-only product analytics. Mixpanel itself publishes no MCP server — its agent tooling ships as the mixpanel-headless Python CLI and a set of Claude Agent Skills — so the de-facto server for this API is dragonkhoi/mixpanel-mcp, the community project with the most adoption at 19 stars and 19 forks. It exposes 19 tools over Mixpanel's Query API and nothing over the ingestion API, so an assistant can read your data but cannot write events or edit profiles. Coverage is broad for a single-file server: saved Insights, Funnel and Retention reports (query_insights_report, query_funnel_report, query_retention_report, plus list_saved_funnels and list_saved_cohorts to find the IDs), five segmentation tools including numeric bucketing and per-unit-time sum and average, event and property discovery (get_top_events, get_today_top_events, top_event_properties, top_event_property_values), profile lookup via query_profiles and profile_event_activity, and custom_jql for anything the typed tools do not cover. Authentication is a Mixpanel Service Account username and password plus a project ID, sent as HTTP Basic on every request. There is no published npm package: the project's package.json claims the name mcp-mixpanel, but that name was unpublished from npm in April 2025 and has not existed since, so install is either a git clone and build or the Smithery bundle. Every API URL is hardcoded to mixpanel.com, which means EU- and India-residency projects are not supported. Last commit March 2025.

Search, analyze, and query charts, dashboards, experiments, and feature flags.

The PostHog MCP Server is PostHog's official Model Context Protocol integration, giving AI assistants direct access to product analytics, feature flags, session replay, experiments, and error tracking without leaving the chat. It's hosted remotely at mcp.posthog.com (Streamable HTTP) and authenticated with a personal PostHog API key passed as a Bearer token — the quickest setup is `npx @posthog/wizard@latest mcp add`, which auto-configures Cursor, Claude, Claude Code, VS Code, or Zed in one command; manual setup adds an `mcp-remote` proxy entry with the `Authorization` header for clients without native remote-MCP support. Tools cover the full PostHog surface: creating and toggling feature flags with percentage rollouts and targeting rules, running trends/funnel/retention queries via `query-run`, inspecting session recordings, pulling error-tracking issues, and managing experiments — all scoped to the project tied to your API key. Typical use: ask Claude to "create a feature flag for the new checkout flow at 20% rollout" or "how many unique users signed up in the last 7 days, broken down by day?" and the assistant executes the query or mutation against your live PostHog project and returns formatted results. Originally shipped as the standalone PostHog/mcp repo (150 stars), that repository is now archived on GitHub — last pushed 2026-01-19 — with the source moved into the main PostHog monorepo under `services/mcp`. The archive is a relocation, not a retirement: the hosted server and the wizard install are both current, so the link here is a pointer to history and the docs at posthog.com/docs/model-context-protocol are the live reference.

Segment (Twilio Segment) does not currently ship a first-party Model Context Protocol server — repos claiming to be an "official Segment MCP" (like segmentio/mcp-server) don't actually exist, and no Twilio-published MCP package has shipped as of this writing. The closest authoritative reference is Segment's own actively-maintained analytics-next SDK (400+ stars), the JavaScript library that powers Segment's client- and server-side tracking calls (track, identify, page, group) across web and Node. In practice, teams that want an AI assistant to read or write Segment data build a thin MCP wrapper around Segment's public HTTP Tracking API using a per-source write key, exposing tools like track_event, identify_user, and group_account so an assistant can execute requests such as "log a purchase event for this user in Segment" or "identify this contact with these traits" without a human touching the dashboard. Segment's Engage and Unify APIs (audience management, profile lookups) are also reachable this way with a workspace access token. Until Twilio ships (or a well-maintained community project emerges for) a dedicated Segment MCP server, this entry points at the SDK repo that actually documents the underlying event schema and auth model any wrapper would need — update this entry if a real one ships.

Zapier MCP is Zapier's official hosted Model Context Protocol server, giving AI assistants natural-language access to the 9,000+ apps in the Zapier ecosystem — Gmail, Slack, HubSpot, Salesforce, Google Sheets, Airtable, and thousands more — without writing custom API integrations for each one. Instead of installing a local binary, you create a server at mcp.zapier.com, pick the tools (Zapier calls them "actions") you want exposed, and connect over Streamable HTTP (SSE is not supported). Setup guides are published for Claude (Web, Desktop, and Code — requires an org owner), ChatGPT (Developer Mode, manual tool refresh required), Cursor, VS Code (via GitHub Copilot Agent mode), Windsurf, and Microsoft Copilot Studio, plus a generic path for any MCP client built with the Python or TypeScript SDK. Authentication is OAuth-based per client; disconnecting a client is a one-click delete of the server in the mcp.zapier.com dashboard, which immediately revokes access. Tool bundles let you group related actions (e.g. "CRM updates" or "team notifications") so the AI only sees relevant tools per context, and usage is billed against your existing Zapier plan's task quota. The official client plugin — which onboards you with guided setup inside Claude Code, Cursor, and GitHub Copilot CLI — lives in the zapier/zapier-mcp repo and ships through the Claude Code, Cursor, and Kiro plugin marketplaces. Typical use: ask Claude to "add this lead to HubSpot and notify #sales on Slack" and Zapier MCP routes both actions through your existing Zap connections.

Turn your Make scenarios into callable tools for AI assistants.

n8n-MCP gives an AI assistant deep knowledge of n8n rather than a remote control for it: 2,412 nodes (829 core plus 1,583 community, 1,340 of them verified) with 99% property coverage and 66.5% operation coverage, 86% documentation coverage, a library of 2,352 workflow templates, and validators that check a node config or a whole workflow before anything is deployed. Seven documentation tools always load — search_templates, get_template, search_nodes, get_node, validate_node, validate_workflow and tools_documentation — and get_node is deliberately tiered because full node detail costs 3,000-8,000 tokens. Supplying N8N_API_URL and N8N_API_KEY unlocks a further sixteen management tools that create, partially update, validate, autofix, deploy and inspect workflows on your own instance, plus executions, credentials, folders, data tables and health checks; without credentials the server cannot execute anything at all. MCP_MODE=stdio is required for stdio clients, or log output corrupts the JSON-RPC stream; WEBHOOK_SECURITY_MODE=moderate is required when N8N_API_URL points at localhost or host.docker.internal, because the default SSRF gate rejects loopback. Install with npx n8n-mcp, the ghcr.io/czlonkowski/n8n-mcp Docker image, or the maintainer's hosted instance at dashboard.n8n-mcp.com (100 tool calls/day free). This is a community project by Romuald Czlonkowski under MIT, not published by n8n, and it is distinct from n8n's own MCP Server Trigger node, which does the reverse — exposing an n8n workflow as an MCP server over SSE or Streamable HTTP. The project's own headline warning is never to let an AI edit production workflows directly.

No official Retool MCP server currently exists, but starigade/retool-mcp-server is a focused community implementation that gives Claude and other MCP clients read access to a Retool workspace via the Retool REST API. Once configured with a `RETOOL_API_TOKEN`, it exposes tools to list every app the token can see (`retool_list_apps`, with optional search filtering), pull the full structure, queries, and components of a specific app (`retool_get_app`), extract the underlying SQL or REST/GraphQL queries embedded in an app for review (`retool_get_queries`), enumerate the database and API resources connected to the workspace (`retool_list_resources` / `retool_get_resource`), browse the folder hierarchy (`retool_list_folders`), and export a full app configuration for deep, offline analysis (`retool_export_app`). That combination is aimed squarely at low-code audits and migrations: a developer can ask Claude to summarize what a given internal tool does, trace which database a query hits, or flag apps that share a risky resource connection, all without opening the Retool editor. It supports both Retool Cloud and self-hosted instances — self-hosted deployments add a `RETOOL_BASE_URL` environment variable alongside the API token. Install by cloning the repository, running `npm install && npm run build`, then pointing an MCP client at the built `dist/index.js` entry point with `node`.

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.

PagerDuty MCP Server is PagerDuty's official, actively maintained local MCP server (github.com/PagerDuty/pagerduty-mcp-server) for managing incident response directly from an MCP-enabled client like Claude, Cursor, or VS Code. Beyond the standard tool surface for incidents, services, on-call schedules, and event orchestrations, it ships embedded React 'MCP Apps' that render interactive UIs inside supporting IDEs: an Incident Command Center with a real-time incident feed, timeline/notes/alert inspection, one-click acknowledge/escalate/resolve, and AI-powered similar-incident detection; an On-Call Manager for schedule overrides and escalation-policy edits; an On-Call Compensation Report tracking hours worked, interruption rates, and EU Working Time Directive compliance with CSV export; a Service Dependency Graph visualizing upstream/downstream impact; and an Onboarding Wizard for first-time account setup. The server runs as a single Python process via `uv run pagerduty-mcp`, avoiding a separate HTTP server to manage. Authentication uses a PagerDuty User API Token generated from My Profile → User Settings → API Access (Freemium accounts have role-based limits on who can generate one), used subject to PagerDuty's Developer Agreement. This combination of deep incident-lifecycle tooling and embedded operational dashboards makes it one of the more feature-complete official vendor MCP servers for on-call/DevOps teams.

The OpsGenie MCP Server bridges MCP-capable clients like Claude Desktop and Cursor to OpsGenie's alerting and on-call platform, so an on-call engineer can triage incidents from an AI assistant instead of switching to the OpsGenie web console. Alert tools cover list_alerts (with OpsGenie's powerful filter-query syntax for scoping by status, priority, tag, or team), get_alert for full detail, and acknowledge_alert/unacknowledge_alert for actually working an incident from chat. Team tools (list_teams, get_team) let an agent resolve who owns a given alert, and heartbeat tools (list_heartbeats, get_heartbeat) expose the health of OpsGenie's dead-man's-switch monitors — useful for an agent answering "is our nightly batch heartbeat still healthy?" without a dashboard. The server is written in Go, ships as a single binary installable via `go install`, and supports stdio, SSE, and streamable-HTTP transports plus a built-in self-update command. Authentication uses an OpsGenie API token set via the OPSGENIE_TOKEN environment variable (or a custom var name via --token-env-var). Important context: this is a community project, not an Atlassian first-party release — no official Atlassian OpsGenie MCP server exists, and Atlassian has been folding OpsGenie's alerting/on-call features into Jira Service Management's roadmap, so teams already on JSM should also check the Jira MCP Server entry on this site. The repo itself is now archived (last updated 2026-05) but the built binary remains functional for existing OpsGenie accounts.

Observability and monitoring with New Relic.

Dynatrace MCP Server connects AI assistants to the Dynatrace observability platform so an agent can pull live problems, Davis AI root-cause findings, logs, metrics, traces, entity relationships and security findings into a coding session instead of making you leave the editor for the Dynatrace UI. Read the deprecation notice before you install: dynatrace-oss/dynatrace-mcp is now deprecated and 2.1.2 was its final release, with no further updates planned. Dynatrace splits the replacement in two. For local development in VS Code, IntelliJ, Claude Code or Cursor, the maintained path is the Dynatrace-for-AI toolkit together with the dtctl CLI. For agent-to-agent and remote use — Atlassian Rovo, the GitHub Coding Agent, and other hosted clients — Dynatrace now runs a Remote MCP Server listed on the Dynatrace Hub that needs no local setup at all. The deprecated local server still runs if you need it: Node.js 24 or newer, `npx -y @dynatrace-oss/dynatrace-mcp-server` over stdio, and a DT_ENVIRONMENT pointing at a Dynatrace Platform URL such as https://abc12345.apps.dynatrace.com (classic abc12345.live.dynatrace.com URLs are not accepted). Authentication runs an Authorization Code Flow in the browser on first start rather than requiring a Platform Token or OAuth client up front, and the resulting token is stored in the OS keychain — macOS Keychain, Windows Credential Manager or Linux Secret Service — and reused, so the browser opens once per token lifetime. In headless or container environments where no keychain is available, set DT_MCP_TOKEN_STORAGE=file to persist tokens under ~/.config/dynatrace-mcp/ instead. One correction worth making explicitly: although the repository lives under the dynatrace-oss organisation, its README states the project is not officially supported by Dynatrace, so it is listed here as community rather than official.

Query and analyze data, alerts, dashboards, and cross-reference production behavior with codebase.

Lightstep was a distributed-tracing and observability platform built on OpenTelemetry, acquired by ServiceNow in 2021 and folded into the ServiceNow Cloud Observability product line; its GitHub org still hosts the legacy OpenTelemetry Launcher and tracer SDKs for Go, Java, Python, Node.js, and C++, but none of those repos are MCP servers. Neither ServiceNow nor the community has shipped an MCP server exposing Lightstep/Cloud Observability trace and metric data to AI assistants — repeated GitHub and web searches across review cycles turn up zero results for "lightstep mcp" or "servicenow observability mcp" with any real implementation. If you need AI-agent access to distributed tracing data today, check this directory's Honeycomb or Grafana entries, which do have real, actively maintained MCP servers covering similar observability workflows. This entry is kept as a placeholder so the "lightstep mcp" search term stays discoverable and will be updated the moment ServiceNow or a community project ships a real server.

Feature flags as a service for continuous delivery.

Split.io was acquired by Harness and rebranded to Harness FME (Feature Management & Experimentation) — a `splitio/mcp-server` repo does not exist, and Harness has not published a first-party MCP server for it. The best available option is kud/mcp-harness-fme, a community-built, MIT-licensed TypeScript server exposing 30 tools across workspaces, environments, feature flags, flag definitions, segments, rule-based segments, and change requests. It supports a zero-config startup that reads the `MCP_HARNESS_FME_API_KEY` environment variable and exits immediately if it is missing, plus a "kill & restore" flow that instantly forces all traffic to a flag's default treatment (or restores it) with a single tool call. Every destructive operation — delete, kill, archive, disable — requires an explicit `confirm: true` argument, preventing accidental changes from an agent acting on ambiguous instructions. It also supports the full change-request flow for rule-based segments, letting teams submit segment-definition changes with optional approvers for orgs that require approval gates. Install with `npx --yes @kud/mcp-harness-fme@latest`, or add it directly via `claude mcp add --transport stdio --scope user harness-fme --env MCP_HARNESS_FME_API_KEY=your_api_key -- npx --yes @kud/mcp-harness-fme@latest` in Claude Code. An optional `get_flag_url` deep-link tool activates when `MCP_HARNESS_FME_ACCOUNT_ID` and `MCP_HARNESS_FME_ORG_GUID` are also set. Works with any stdio MCP client — Claude Desktop, Claude Code, Cursor, Windsurf, Cline, Zed.

The Flagsmith MCP Server is Flagsmith's official, Speakeasy-generated Model Context Protocol server for its Core and SDK APIs, letting AI assistants read and manage feature flags, remote config values, and environment/identity segmentation directly from a conversation. It ships as an installable Desktop Extension (`mcp-server.mcpb`) for Claude Desktop — drag-and-drop install with no additional setup — and as an npm package (`flagsmith`) for CLI-based clients, started with `npx flagsmith start --token-auth <your-api-token>` and wired into Claude Code, Cursor, Gemini, and Windsurf via each client's standard MCP config or one-line `mcp add` command. Progressive discovery keeps the tool surface manageable across the full Flagsmith API rather than dumping every endpoint into context at once. Typical use: ask Claude to "list all feature flags enabled for the beta segment in production" or "toggle the new-checkout-flow flag off for the EU environment," with the assistant calling the live Flagsmith API instead of requiring a dashboard visit. NOTE: as of this writing the repo carries an explicit "not yet ready for production use" notice from its Speakeasy-generated setup flow — expect rough edges and check the repo before depending on it for anything mission-critical.

The Intercom MCP Server is Intercom's official, hosted Model Context Protocol integration, giving AI assistants secure access to conversations and contacts in a company's Intercom workspace (currently US-hosted workspaces only). Rather than a local binary, it runs as a remote server at `mcp.intercom.com`, reachable over Streamable HTTP (`https://mcp.intercom.com/mcp`, recommended) or a legacy SSE endpoint kept for backwards compatibility. It exposes six tools: a universal `search` tool that queries either conversations or contacts via a field-based query DSL (operators like eq, neq, gt, lt, contains, plus free-text `q:` search and pagination), a matching `fetch` tool for pulling full resource detail by ID, and four direct-API tools — `search_conversations`, `get_conversation`, `search_contacts`, and `get_contact` — for more targeted lookups by state, source type, author, custom attributes, or email domain. Authentication supports either an automatic browser-based OAuth flow (recommended) or a static Bearer API token, configured in the client as an `mcp-remote` proxy entry pointing at the hosted URL. Typical use: ask Claude to "find all open conversations mentioning a refund from the last week" or "pull the full history and custom attributes for this contact by email," and the assistant queries live Intercom data instead of requiring a CSV export or manual dashboard search — useful for support triage, customer research, and drafting responses grounded in real conversation history.

The Zendesk MCP Server by community maintainer reminia (114★, Apache-2.0, Python) is the most-used Model Context Protocol integration for Zendesk Support — there is no first-party Zendesk MCP server, so this is the one the query usually means. It talks to Zendesk through the zenpy client and exposes six tools: `get_tickets` (paginated list, sortable by created_at, updated_at, priority or status), `get_ticket` by ID, `get_ticket_comments` for a full thread, `create_ticket_comment` with a `public` flag so an assistant can post either a customer-visible reply or an internal note, `create_ticket` (subject, description, requester/assignee IDs, priority, type, tags, custom fields) and `update_ticket` for status, priority, assignee, tags, custom fields and due_at. Alongside the tools it registers one MCP resource, `zendesk://knowledge-base`, which hands the model the whole Help Center article set as read-only context, and two prompts written for support work: `analyze-ticket`, which summarises a thread, and `draft-ticket-response`, which writes a reply grounded in that thread. Authentication is an API token from the Zendesk admin panel plus your subdomain and agent email, supplied as ZENDESK_SUBDOMAIN, ZENDESK_EMAIL and ZENDESK_API_KEY. The published wheel on PyPI installs and runs with a single `uvx zendesk-mcp-server`; the repository also documents a `uv` source build and a Dockerfile that drops to a non-root user for isolated runs. Typical use: "pull ticket #4821, summarise the customer's issue, and draft a reply citing our refund-policy article" — the assistant reads the ticket and its comments, cross-references the knowledge-base resource, and returns a draft you approve before it posts.

The Freshdesk MCP Server connects MCP-capable clients like Claude Desktop and Cursor to Freshdesk's help-desk platform, letting an AI assistant handle support operations through natural language instead of the Freshdesk admin UI. Ticket tools cover the full lifecycle: create_ticket (with subject, description, priority, status, custom fields), update_ticket, delete_ticket, get_ticket, get_tickets with pagination, and search_tickets against Freshdesk's query syntax — plus conversation-level tools for get_ticket_conversation, create_ticket_reply, create_ticket_note, and update_ticket_conversation so an agent can both read a customer thread and post a reply or internal note without a human copy-pasting between systems. A ticket-summary tool set (view/update/delete) exposes Freshdesk's AI-generated ticket summaries directly. Beyond tickets, the server covers agent management (get_agents, view_agent, create_agent, update_agent, search_agents), contacts (list/get/search/update), and companies (list/get/search/find_company_by_name/list_company_fields) — enough surface area to let an agent triage an incoming ticket, look up the requester's company and past tickets, and draft or send a reply in one conversational flow. Example prompts from the maintainer include "list previous tickets of customer A101 in last 30 days" and "update the status of ticket #12345 to Resolved." Authentication uses a Freshdesk API key plus your Freshdesk subdomain, set as FRESHDESK_API_KEY and FRESHDESK_DOMAIN environment variables; install via uvx or the Smithery CLI. This is a community project (not published by Freshworks itself), MIT-licensed and the most-starred Freshdesk MCP implementation on GitHub.

The Salesforce DX MCP Server (npm package `@salesforce/mcp`) is Salesforce's official Model Context Protocol integration, built and maintained by the Salesforce CLI (salesforcecli) team to let AI assistants read, manage, and operate Salesforce orgs securely from Claude, Cursor, VS Code, Windsurf, or Cline. Rather than exposing one flat set of tools, it is organized into configurable toolsets you enable with the `--toolsets` flag: `orgs` (list and inspect the orgs you've authenticated), `data` (run SOQL queries and read/create/update records for standard and custom objects), `metadata` (deploy and retrieve source and metadata), and `users` — plus individually-gateable tools such as `run_apex_test`. This makes it useful both for developers automating deploys and Apex test runs and for RevOps teams asking Claude to "pull all open opportunities closing this quarter over $50K" or "update this deal to Negotiation." A key security design point: the server never takes raw usernames and passwords — instead it operates on orgs you have already authenticated through the Salesforce CLI (`sf org login`), which you reference by alias via the `--orgs` flag, so credentials stay in the CLI's secure store and each MCP session is scoped only to the orgs you explicitly allow. Install with `npx -y @salesforce/mcp --orgs DEFAULT_TARGET_ORG --toolsets orgs,metadata,data,users`. Apache-2.0 licensed. Community CRM-focused alternatives such as tsmztech/mcp-server-salesforce and smn2gnt/MCP-Salesforce exist for teams wanting a lighter SOQL-and-records-only server.

Community-built MCP server that connects Claude, Cursor, and other MCP clients to the Pipedrive API v2 for CRM data access. Exposes deals, persons, organizations, and pipelines — including custom fields — as MCP tools, plus predefined prompts for common CRM operations like pulling pipeline status or filtering deals by owner, stage, date range, or value. Defaults to v2 read tools with optional preview-first writes, so an agent shows a proposed change for confirmation before it touches production CRM records rather than writing blind. Supports both stdio transport for local desktop clients and a built-in HTTP server for networked deployments; the HTTP routes require JWT and the server does not terminate TLS itself, so the docker-compose deployment publishes only on host loopback by default and expects a reverse proxy in front for any remote use. Ships as a published npm package (`pipedrive-mcp-server`) and as a GHCR Docker image (`ghcr.io/willdent/pipedrive-mcp-server`) with docker-compose support, running as the unprivileged `node` user with a `/health` check. Authentication uses a Pipedrive API token set via environment variables. Useful for sales teams wiring an AI assistant into deal review, pipeline forecasting, or account research workflows without building custom API integration code from scratch. Note: a stale `juhokoskela/pipedrive-mcp-server` fork (now transferred to SPLCompanyOy, 0 stars, last touched April 2026) publishes a colliding GHCR image — the maintained project is WillDent's.

Close does not publish an official Model Context Protocol server — a `closeio/mcp-server` repo does not exist. The strongest real option is bcharleson/close-crm-cli, a TypeScript CLI-and-MCP-server hybrid that exposes Close's full REST API (160+ commands across 30 resource groups: leads, contacts, opportunities, tasks, calls, notes, emails, SMS, meetings, pipelines, custom fields, webhooks, outreach sequences, smart views, and analytics reports) both as terminal commands and as MCP tools. Run `close mcp` to start the server, or wire it into Claude Desktop / Cursor / Windsurf via `npx close-crm-cli mcp` with a `CLOSE_API_KEY` env var (generated from Close's Settings → API page). HTTP Basic Auth, offset-based pagination, and automatic exponential-backoff retry on 429/5xx are all handled for you, and JSON output is the default so responses pipe cleanly into an agent or `jq`. Typical use: ask Claude to "list my open opportunities in the demo-scheduled stage" or "log a call and create a follow-up task" without leaving the chat. Not an official Close product — early-stage community project, so expect rough edges and verify write operations before relying on them in production pipelines.

The Monday.com MCP server is the official Model Context Protocol integration built by Monday.com, giving AI assistants like Claude and Cursor direct access to your Monday.com workspace. Teams use it to query board data, create and update items, track project status, and automate workflow updates through natural-language interactions — without opening the Monday.com web interface. Key capabilities include: listing workspace boards and their column configurations, reading item statuses and assignees, creating new items with custom field values, updating existing item statuses across groups, and querying sub-items and dependencies within boards. This makes the Monday.com MCP server particularly useful for project managers who want to ask Claude to summarize overdue tasks, update sprint statuses after standups, or generate a status report for a client from board data. Authentication uses a Monday.com API token, which you generate from your account's Developer section (navigate to Admin → Developers → Create App or use personal API tokens). The server communicates with Monday.com's GraphQL API, so all data is live and real-time. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline. For teams running agile workflows, the server enables AI-assisted sprint planning, velocity reporting, and backlog grooming without context-switching between your AI assistant and the Monday.com dashboard.

ClickUp MCP Server connects AI assistants to your ClickUp workspace so you can manage tasks, docs, and time entries with natural language instead of clicking through the app. This community server (by hauptsacheNet) authenticates with a ClickUp API key and team ID and ships three operating modes — read-minimal for lightweight coding-assistant context, read for full workspace exploration, and write (default) for complete task and document management. Its standout feature is rich task context: getTaskById returns full comment history, status changes, and inline images in a single call, so agentic coding tools can pull a ClickUp ticket, its linked screenshots, and prior discussion without chaining multiple requests. It also supports fuzzy multi-language search across tasks and documents, time-entry logging and retrieval, and append-only description updates that never overwrite existing task content — new notes are timestamped and added rather than replacing history, which keeps ClickUp's own audit trail intact. An official OAuth-based ClickUp MCP also exists for chat-app and Connected Search use cases; this API-key server is better suited to CI/CD, automation, and coding-tool integrations.

The Wrike MCP Server gives MCP-capable clients full CRUD access to Wrike's work-management platform, letting an AI assistant discover, read, and modify tasks, folders, and spaces directly from chat. Its standout feature is a discover_account bootstrap tool that identifies the authenticated user, enumerates every space, lists top-level folders with their workflow assignments, and catalogues account-level and space-scoped workflows plus custom fields and item types — this front-loads the account-structure discovery an agent would otherwise need several manual calls to piece together before it can safely create or move anything. Read tools cover task search by title/status, full task detail (including comments and attachments in one combined call via get_task_full), workflow and custom-field listings, folder browsing, and recursive folder-task listing. Write tools cover task creation with assignees/dates/importance/custom fields, updates to any task field, completion, moving tasks between folders, deletion of tasks/folders/spaces, and file attachment uploads. Authentication uses a Wrike Permanent Access Token generated from the Wrike API console, stored either in the system keychain via a bundled wrike-auth CLI or as a WRIKE_ACCESS_TOKEN environment variable. This is an early-stage community project (not an official Wrike release) installed from source with pip — worth noting since Wrike itself has not published a first-party MCP server, so this fills a real gap for teams wanting AI-agent access to their Wrike workspace.

The Basecamp MCP Server connects MCP-capable clients like Claude Desktop, Claude Code, Codex, and Cursor to Basecamp 3 through OAuth-authenticated API calls, letting an AI assistant read and manage a team's projects without leaving the chat. Built on the official mcp.server.fastmcp Python SDK, it exposes 79 tools spanning the full breadth of Basecamp 3: project and to-do list browsing, to-do creation/updates/completion, message board posts (including drafts and categories), Campfire chat reading, card table and card-step management, document reading and drafting, comment creation, inbox forward handling, daily check-in answers, file uploads, event listings, and webhook management. A built-in search tool queries across projects, to-dos, messages, Campfire lines, comments, uploads, and schedules in one call, useful for an agent trying to find "what did the team decide about X" without paging through each tool individually. Setup requires a Basecamp OAuth application registered at launchpad.37signals.com/integrations, then running the bundled oauth_app.py flow once to store a local token; config-generator scripts are included for Codex, Cursor, and Claude Desktop so the MCP entry gets written automatically rather than hand-edited. This is a community project (not published by 37signals/Basecamp itself), MIT-licensed and actively maintained, and is currently the most complete open-source Basecamp MCP integration — competing alternatives top out around 46 tools versus this server's 79.

The Trello MCP server gives AI assistants full read/write access to Trello boards, lists, and cards through the Model Context Protocol. The most widely adopted community implementation is delorenj/mcp-server-trello, a TypeScript server (now Bun-powered for a 2.8-4.4x speed boost over the original Node build) that wraps the Trello REST API with built-in rate limiting, type safety, and dynamic board/workspace switching. Tools cover the full card lifecycle: create, update, move, and archive cards; manage checklists, labels, members, and file attachments pulled in from URLs; add, edit, and delete comments; and export card data as human-readable markdown. Because boardId and workspaceId can be passed per-call instead of hardcoded in the config, one server instance can drive multiple boards and workspaces without a restart, and the active board persists locally between sessions. Setup requires a free Trello API key and token (from trello.com/app-key), configured via TRELLO_API_KEY and TRELLO_TOKEN environment variables, with an optional TRELLO_ALLOWED_WORKSPACES allowlist for restricting agent access in multi-tenant or security-conscious setups. It is commonly paired with agent workflows for sprint planning, kanban automation, and syncing tasks between chat and boards without leaving the AI assistant.

Coda MCP Server (built by TJC L.P., unofficial and not affiliated with Coda) gives AI assistants full read/write access to Coda.io docs through the Coda REST API — install via `uvx coda-mcp-server` with a Coda API token from your account settings, no local Python environment setup required. It covers the whole document model: list, create, read, update, and delete docs; browse and edit pages, including exporting full page content to HTML or Markdown for long-form review; and inspect tables, views, and column formulas. Row operations support querying and filtering table data, upserting rows in bulk, updating single rows, deleting rows, and even pushing button-column actions programmatically — useful for treating a Coda table as a lightweight database an agent can read and write. It also exposes named formulas so an assistant can look up and reason about doc-level calculations. Since v1.1.0 the server uses snake_case field names (e.g. `browser_link`) for cleaner Python-ecosystem compatibility. Best fit for teams that keep specs, trackers, or internal wikis in Coda and want an agent to pull structured data out of docs or automate repetitive table edits without a human opening the app.

Perform queries and entity operations in your Fibery workspace.

A Python-based MCP server that lets Claude, Cursor, and other AI tools interact with X/Twitter through natural-language commands, built on the official Twitter API v2 rather than username/password scraping hacks (which risk account suspension). It exposes tools to fetch user profiles, followers, and following lists; post, delete, and favorite tweets; search tweets and trending topics; manage bookmarks and timelines; and handle rate limits automatically across the v2 endpoint surface. Authentication requires a Twitter Developer Account with API Key, API Secret, Access Token, Access Token Secret, and Bearer Token from the Twitter Developer Portal — there is no keyless or scraping-based mode, so this targets developers who already have (or are willing to apply for) API access rather than casual users. Install options include Smithery (`npx -y @smithery/cli install @rafaljanicki/x-twitter-mcp-server --client claude`) for one-command Claude Desktop setup, PyPI (`pip install x-twitter-mcp`) for a quick manual install, or cloning the source with `uv sync`/`pip install .` for development. The project is a smaller community effort (35 stars) compared to the official Twitter API tooling ecosystem, but is actively maintained and one of the few X/Twitter MCP servers built on the sanctioned API path rather than reverse-engineered browser automation.

X and Twitter automation MCP server for tweet search, profile tweets, follower export, media workflows, webhooks, and confirmation-gated posting.

A clean, LLM-optimized MCP server that lets Claude Desktop and other AI assistants browse Reddit, search posts, and analyze user activity with zero setup and no Reddit API registration required. Core tools include `browse_subreddit` (hot/new/top/rising/controversial sorting across any subreddit, "all", or "popular", with time-range filters), `search_reddit` (query across all of Reddit or a specific subreddit, filterable by author/time/flair, sortable by relevance/hot/top/new/comments), `get_post_details` (fetch a post plus its full comment thread from a Reddit URL in any format — reddit.com, old./new./np./m.reddit.com, or redd.it short links — or from a bare post ID), and `user_analysis` (karma, post/comment history, and active subreddits for any username). A three-tier authentication system scales from 10 requests/minute with zero config up to 100 requests/minute when Reddit API credentials are supplied, so it works instantly out of the box and scales up for heavier use. The project deliberately avoids fabricated "sentiment analysis" or made-up metrics, focusing on clean, structured Reddit data formatted for LLM consumption. Install as a Claude Desktop Extension (.mcpb one-click download), via NPM (`npx -y reddit-mcp-buddy`), or through the official MCP Registry — it is fully TypeScript, actively maintained, and one of the most-starred Reddit MCP integrations available.

The Hacker News MCP server gives Claude, Cursor, and other MCP clients live access to Hacker News so an AI assistant can pull the latest stories, comment threads, and user profiles into a conversation. This community server (paabloLC/mcp-hacker-news, TypeScript) acts as a thin, well-behaved bridge over the official Firebase-backed Hacker News API — it does not scrape the site, so results match what you see on news.ycombinator.com. It exposes standard MCP tools for fetching top, new, best, Ask HN, Show HN, and job stories, retrieving a specific item with its nested comment tree, and looking up a user's karma, bio, and submission history. That makes it useful for tracking what is trending in the developer and startup community, summarizing long comment discussions, monitoring a launch or a topic, or feeding fresh HN context into research and content workflows. Installation is zero-config: point your client at `npx -y mcp-hacker-news` (Node.js 18+ required) and it runs over stdio with no API key or authentication, since the Hacker News API is public and read-only. Note this is a lower-star community project rather than an official Y Combinator release — it is a lightweight, dependency-free option that is easy to audit and self-host if you prefer.

The Product Hunt MCP Server connects Claude, Cursor, and other MCP clients directly to Product Hunt's official GraphQL API, letting an AI assistant look up launches, collections, topics, users, votes, and comments without leaving the conversation. Built with FastMCP for speed, the server exposes tools to fetch detailed post info (tagline, description, vote count, maker list, comments), search and filter launches by topic, date range, or vote threshold, page through paginated comment threads and a user's upvote history, and pull collection and topic metadata. It is a good fit for AI-agent workflows that need to research competitor launches, track a specific topic's daily leaderboard, summarize maker comments, or build a "what shipped today" digest inside an agent pipeline. Authentication uses a personal Product Hunt Developer Token generated from the Product Hunt API Dashboard (any placeholder redirect_uri works, since the MCP server never uses an OAuth redirect flow itself) supplied via the PRODUCT_HUNT_TOKEN environment variable. Install with `pip install product-hunt-mcp` or `uv pip install product-hunt-mcp`; a Docker image and a git+https install path are also documented for teams that prefer container-based MCP deployments. Config for Claude Desktop or Cursor just points the command at the installed `product-hunt-mcp` binary with the token set in the env block.

The arXiv MCP Server bridges AI assistants to arXiv's research repository through the Model Context Protocol, letting Claude, Cursor, VS Code, and other MCP clients search, download, and read academic papers directly inside a conversation. The core workflow is search_papers → download_paper → read_paper: search_papers queries arXiv with boolean, category (cs.AI, cs.LG, cs.CL, cs.CV, stat.ML, quant-ph, and more), and date-range filters while automatically respecting arXiv's 3-second rate limit; download_paper fetches a paper by its arXiv ID (HTML first, PDF fallback) and stores it locally, returning content_length/next_start metadata so clients can safely page through very large papers; read_paper then returns the full text as markdown, with start/max_chars pagination for long documents. list_papers shows everything downloaded locally, and semantic_search searches across that local collection. The server also ships a "deep-paper-analysis" prompt that walks an assistant through executive summary, methodology, results, and future-research-direction analysis for a given paper ID. Install with `uv tool install arxiv-mcp-server` (NOT npm — an unrelated third-party package squats the same name on npm) or via the one-click Claude Desktop .mcpb bundle; a Streamable HTTP transport is available for server deployments. The README explicitly flags that arXiv paper content is untrusted external input and warns about prompt-injection risk (OWASP LLM01/AG01) when feeding raw paper text into agentic pipelines with tool access.

The Semantic Scholar MCP Server is a FastMCP-based Python server that connects Claude, Cursor, VS Code, and other MCP clients to the Semantic Scholar API — the Allen Institute for AI's corpus of 200M+ academic papers — so an assistant can search literature, trace citation networks, and pull author profiles directly inside a conversation instead of guessing from training data. On the paper side it exposes full-text and title-based search with advanced filtering, multi-strategy ranked search, single- and multi-paper recommendations, and efficient batch detail retrieval with customizable field selection. Its citation-analysis tools walk the citation graph in both directions — citations and references — with citation context and influence signals, which is what makes it a strong fit for literature-review and citation-tracing agents rather than one-off lookups. Author tools cover author search, profile details, publication history, and batch author retrieval. It works unauthenticated for light use, but setting a SEMANTIC_SCHOLAR_API_KEY environment variable raises rate limits for heavier workflows; the server handles rate-limit compliance, connection pooling, and graceful shutdown internally. Install with `pip install semantic-scholar-fastmcp` or run it with no install via `uvx semantic-scholar-fastmcp`, then point your client's config at the uvx command. A Smithery one-click install for Claude Desktop and a companion Claude Code skills bundle (expand-references, trace-citations, paper-triage) are also available. Requires Python 3.10+.

This Wolfram Alpha MCP server gives AI assistants a direct line to the Wolfram|Alpha computational knowledge engine, letting them run math, science, unit-conversion, and structured data queries and get back verified answers instead of guessing at arithmetic or facts. It wraps the Wolfram|Alpha API in an MCP-compliant interface with a modular architecture designed to be extended to additional Wolfram APIs and multi-client setups. Beyond the server itself, the project bundles an example MCP client built on Gemini via LangChain, plus an optional Gradio web UI for interacting with both Google AI and the Wolfram Alpha MCP server side by side — useful for testing queries before wiring the server into Claude Desktop, Cursor, or VS Code. Configuration requires a WOLFRAM_API_KEY (a free Wolfram|Alpha AppID) set via a .env file, and an optional GeminiAPI key if using the bundled LangChain client. Install by cloning the repo and running `pip install -r requirements.txt` (or `uv sync`), then point your MCP client at the packaged server.py entry point; a VS Code MCP config template and Docker build files for the client/UI are included in the repo. Because Wolfram|Alpha handles the actual computation server-side, this server is a strong fit for agentic workflows that need reliably correct math or unit conversions rather than LLM-generated approximations.

This Weather MCP Server (the Open-Meteo MCP Server) gives Claude, Cursor, VS Code, and other MCP clients comprehensive access to the free Open-Meteo weather APIs — no API key required — so an assistant can answer forecast, historical, air-quality, and marine questions with live data instead of stale training knowledge. Its core tools cover weather_forecast (7-day forecasts at hourly and daily resolution), weather_archive (historical ERA5 reanalysis data back to 1940), air_quality (PM2.5/PM10, ozone, nitrogen dioxide, pollen, European/US AQI and UV index), marine_weather (wave height/period/direction and sea-surface temperature), elevation, and geocoding to resolve place names or postal codes to coordinates. Beyond the basics it exposes specialized national-model tools — DWD ICON (Europe), NOAA GFS (US/global), Météo-France AROME/ARPEGE, ECMWF, JMA (Asia), MET Norway, and Environment Canada GEM — plus advanced tools for flood forecasting (GloFAS river discharge), seasonal forecasts up to nine months out, CMIP6 climate projections, and ensemble forecasts that surface model uncertainty. The fastest install is zero-config via npx: `npx -y open-meteo-mcp-server` (Node.js 22+), with optional environment variables to point each Open-Meteo sub-API at a self-hosted endpoint; a Docker image and from-source build are also published. If you specifically need a WeatherAPI.com-backed single-tool `current_weather` server instead, ezh0v/weather-mcp-server (Go, ~250 stars) is a lighter API-key-based alternative.

The official Financial Datasets MCP Server gives Claude and other AI assistants direct access to stock market and crypto data through the Financial Datasets API, so an assistant can pull real fundamentals and prices instead of relying on stale training data. It exposes ten tools: get_income_statements, get_balance_sheets, and get_cash_flow_statements for company financial statements; get_current_stock_price and get_historical_stock_prices for equity pricing; get_company_news for recent headlines; and get_available_crypto_tickers, get_current_crypto_price, get_crypto_prices, and get_historical_crypto_prices for crypto markets. It is a Python server built on the official `mcp[cli]` SDK plus httpx, requiring Python 3.10+ and the uv package manager. Setup is clone the repo, run `uv venv && uv add "mcp[cli]" httpx`, then supply a FINANCIAL_DATASETS_API_KEY in a .env file before pointing Claude Desktop's config at `uv run server.py` with the project's absolute path. Once connected, an assistant can answer questions like "what are Apple's recent income statements" or "get historical prices for MSFT from 2024-01-01 to 2024-12-31" using live data rather than guessing.

Connect to 100+ APIs for financial market data from Alpha Vantage.

MiniMax MCP is MiniMax's official, first-party Model Context Protocol server for text-to-image generation, alongside video and audio generation — the highest-starred general-purpose image-generation MCP server on GitHub (1,500+ stars, MIT licensed, actively maintained), a strong signal for the broad "AI image generation MCP" search intent this page targets versus single-model options like Replicate Flux or Stability AI covered in their own dedicated entries elsewhere in this directory. The `text_to_image` tool generates images directly from a prompt; companion tools cover `generate_video` (with the MiniMax-Hailuo-02 model, configurable 6s/10s duration and 768P/1080P resolution), `music_generation` (prompt+lyrics to a full music track via the music-1.5 model), `text_to_audio` plus `voice_clone` and `voice_design` for custom TTS voices, and `query_video_generation` for polling async video jobs. Install via `uvx minimax-mcp -y` (Python/uv-based) with a `MINIMAX_API_KEY` from the MiniMax platform — note the API key and `MINIMAX_API_HOST` must match your account region (Global: api.minimax.io, Mainland China: api.minimaxi.com) or requests fail with an invalid-key error. Supports both stdio (local) and SSE (local or cloud-deployed) transport, with a `MINIMAX_API_RESOURCE_MODE` env var controlling whether generated assets are returned as a URL or downloaded to a local output path. A companion `MiniMax-MCP-JS` package offers an official JavaScript implementation for non-Python environments. Works with Claude Desktop, Cursor, Windsurf, and OpenAI Agents SDK clients — usage incurs MiniMax API costs per generation.

MCP for Replicate Flux Model is a TypeScript server built specifically around Replicate's Flux image-generation models, giving AI assistants a direct tool for generating customized images and SVG assets that match a project's coding vibe or design aesthetic. It streamlines AI-powered visual asset creation for developers — generating illustrations, icons, and mockups on demand from a text prompt without leaving the assistant conversation — using a Replicate API token for auth. Note this server is scoped to Flux image generation rather than Replicate's full model catalog; developers needing broader access to arbitrary Replicate models (video, audio, LLMs, etc.) should look at deepfates/mcp-replicate, a more general-purpose Replicate API server (currently archived but still functional as a reference implementation).

Stability AI has not published a first-party MCP server, but alesurli/mcp-stability-ai is an actively maintained community implementation (npm package `mcp-stability-ai`, MIT licensed, CI-tested) that wires Stability's v2beta image API into Claude Desktop for fully conversational generation and editing — no manual file-path juggling required. On the generation side it exposes three model tiers as separate tools: `generate_image_sd3` (Stable Diffusion 3.5, best overall quality with negative-prompt support, roughly $0.035–$0.065/image), `generate_image_core` (fast generation with built-in style presets, ~$0.03/image), and `generate_image_ultra` (highest photorealistic quality, ~$0.08/image). Editing tools cover the workflows a product or marketing team actually needs: `remove_background` for transparent-PNG cutouts, `replace_background` which swaps and relights a background for product-shot work, `inpaint` for prompt-driven masked-region edits, `search_and_replace` and `search_and_recolor` for maskless object swaps and recoloring by natural-language description, and `outpaint` to extend a canvas in any direction. The author built it specifically as a maintained Stability.ai bridge for people who want the API-based service inside a Claude conversation rather than running a local GPU stack like ComfyUI or Automatic1111 — it is explicitly positioned as a complement to, not a replacement for, those local-first tools. Requires a `STABILITY_API_KEY` from the Stability AI platform; install with `npx -y mcp-stability-ai` and add the key as an environment variable in the Claude Desktop config.

Anthropic does not publish a Model Context Protocol *server* for Claude — a `anthropics/mcp-server` repo does not exist, and Anthropic's own `anthropics/claude-ai-mcp` repo is just an issue tracker for reporting MCP-integration bugs in Claude Desktop and Claude Code, not an installable server. That is because Claude sits on the other side of the protocol: Claude Desktop, Claude Code, and the Claude API are MCP *hosts/clients* that connect OUT to the thousands of servers in this directory (filesystem, databases, GitHub, Slack, and so on) — Anthropic is also the steward of the MCP specification itself, publishing the protocol spec and reference SDKs/servers through the separate `modelcontextprotocol` GitHub org rather than shipping "Claude" as a callable tool server. If you want another AI agent to call Claude as a tool over MCP, no first-party server exists for that today; teams typically wrap the Anthropic Messages API in a small custom MCP server using the official Python/TypeScript SDK. This entry is kept for search/reference purposes — same resolution as the OpenAI, Codeium, and Gitpod entries in this directory, none of which have a first-party MCP server despite the search demand.

Cohere does not ship a dedicated, official Model Context Protocol server — a `cohere-ai/mcp-server` repo does not exist, and the handful of community MCP wrappers found for Cohere's chat/embed/rerank endpoints (e.g. thin single-file projects with zero to a few stars) are early, unmaintained, or unofficial. The closest first-party, actively maintained repo is cohere-ai/cohere-toolkit (3,000+ stars), Cohere's official open-source toolkit for building and deploying RAG and tool-use applications on top of the Cohere platform — it includes reference implementations for connecting retrieval, tool-calling, and agentic workflows to Cohere's Command models, which is the same groundwork any MCP wrapper for Cohere would need. Teams wanting an assistant to call Cohere directly today typically write a small custom MCP server around the Cohere Python or TypeScript SDK, exposing tools like generate_text, embed_documents, or rerank_results authenticated with a `CO_API_KEY`. Typical use once wired up: ask Claude to "embed these 50 support tickets and cluster them by topic" or "rerank these search results by relevance to the user's question," with the assistant calling Cohere's embed/rerank endpoints instead of a generic model. Update this entry if Cohere or a well-adopted community project ships a real dedicated MCP server.

There is no official `mistralai/mcp-server` repo — Mistral AI does not currently publish a first-party MCP server. The most complete real alternative is the community-maintained `mistral-mcp` package (Swih/mistral-mcp, MIT-licensed, published to npm), which exposes the full Mistral API surface as MCP tools, resources, and prompts rather than just chat completions. Unique tools include `mistral_ocr` (Document AI — structured text plus bounding-box annotations from any PDF or image), `voxtral_transcribe` (audio transcription with optional speaker diarization), `codestral_fim` (fill-in-the-middle code completion), and `workflow_execute`/`status`/`interact` for Temporal-backed durable, human-in-the-loop multi-step workflows. It ships four tool-exposure profiles via `MISTRAL_MCP_PROFILE` — `core` (12 tools, default, lean daily use), `admin` (41 tools, full API surface including embeddings, batch, classify, files, agents, TTS), `workflows` (7 tools, pipeline/connector focus), and `metier-docs` (13 tools, document-processing vertical) — plus French-first prompts and skills (meeting minutes, legal summaries, invoice reminders) aimed at European teams evaluating GDPR/DORA-sensitive AI stacks. Install with `npx -y mistral-mcp@latest` (or `claude mcp add mistral -- npx -y mistral-mcp@latest`) and a `MISTRAL_API_KEY`; a Claude Code plugin (`/plugin install mistral-mcp@swih-plugins`) auto-installs and prompts for the key. Typical use: ask Claude to "OCR this invoice PDF and extract the line items" or "transcribe this meeting recording with speaker labels" and the assistant calls straight into Mistral's Document AI and Voxtral models. It is community-built, not an official Mistral integration — nothing here changes Mistral's own data-handling terms.

The Perplexity MCP Server is the official server from Perplexity AI that brings real-time web search, reasoning, and deep research into any MCP-compatible client through the Perplexity Sonar API. Unlike scrapers or search-index wrappers, it taps Perplexity's own answer engine, so Claude gets grounded, citation-backed responses drawn from live web results. The server exposes four purpose-built tools: perplexity_search returns ranked web results with snippets for lightweight lookups; perplexity_ask provides general-purpose conversational answers with real-time search using the sonar-pro model, ideal for quick everyday questions; perplexity_research runs deep, comprehensive investigations with the sonar-deep-research model for thorough analysis and detailed reports; and perplexity_reason handles advanced problem-solving and multi-step analytical tasks with the sonar-reasoning-pro model, with an optional strip_thinking parameter to control chain-of-thought output. Authentication uses a single PERPLEXITY_API_KEY from the Perplexity API dashboard. Installation is a one-line npx command with the official @perplexity-ai/mcp-server package — add it to Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, or Codex, with a Docker image and HTTP transport also supported for server deployments. Because it is Perplexity's first-party implementation (2,300+ GitHub stars), the Perplexity MCP Server is the most reliable way to give an AI agent fresh, sourced answers — perfect for research assistants, fact-checking, and any workflow that needs current information the base model was never trained on.

The Tavily MCP server (tavily-ai/tavily-mcp) is the official, production-ready Model Context Protocol server for Tavily, a search API built specifically for AI agents and RAG pipelines rather than human browsing. It exposes four tools: tavily-search runs real-time web searches tuned for LLM consumption (returning clean, ranked, source-cited results instead of raw HTML), tavily-extract pulls the full clean content out of one or more specific URLs, tavily-map builds a structured map of a site's pages starting from a root URL, and tavily-crawl walks a site to gather content across many pages in a single call. Together these let an assistant answer "search for the latest changelog entries for library X and summarize the breaking changes" or "extract the pricing table from these three competitor pages" with grounded, up-to-date, citation-backed data instead of stale training knowledge. Authentication uses a single `TAVILY_API_KEY` from tavily.com (a generous free tier is available). You can run it locally with `npx -y tavily-mcp@latest` in your Claude Desktop, Cursor, Windsurf, or Cline config, or connect to Tavily's hosted remote server at mcp.tavily.com for a zero-install setup. Typical use: give a coding or research agent live web access so it can verify facts, read documentation it has never seen, and cite real sources — one of the most widely adopted search servers in the MCP ecosystem.

Community-built MCP server that gives AI agents live Google Search and webpage scraping through the Serper API — a fast, low-cost alternative to Google's own Custom Search. Exposes two tools: `google_search`, which returns rich SERP data (organic results, knowledge graph, 'people also ask', related searches) with region and language targeting, pagination, time filters, autocorrection, and full Google advanced-operator support (site:, filetype:, inurl:, intitle:, related:, before:/after: date ranges, exact-phrase, exclusion, and OR alternatives); and `scrape`, which extracts clean plain-text or markdown content from any URL along with JSON-LD structured data and head metadata while preserving document structure. Written in TypeScript and distributed on npm as `serper-search-scrape-mcp-server` (also available via Smithery for one-command Claude Desktop setup). Requires a Serper API key set as the `SERPER_API_KEY` environment variable; Serper's free tier of 2,500 queries makes it popular for prototyping RAG and research agents. Ideal for grounding LLM answers in current web results, competitive research, fact-checking, and building agents that need to both search and read pages without wiring up separate search and scraping providers.

The You.com MCP Server (published as `@youdotcom-oss/mcp`) is a lightweight STDIO bridge that proxies MCP clients to You.com's hosted MCP endpoint at `https://api.you.com/mcp`, rather than running search logic locally — the actual retrieval and ranking happen on You.com's servers. It ships from You.com's own `youdotcom-oss` GitHub organization as part of their dx-toolkit monorepo, not the fabricated `you-com/mcp-server` repo sometimes cited elsewhere. Install by running `npx @youdotcom-oss/mcp` directly in your MCP client config, or add it as a dependency with `bun add @youdotcom-oss/mcp`; authentication requires a `YDC_API_KEY` environment variable, sent as a Bearer token to the hosted endpoint. By default the server exposes three tools: `you-search` for real-time web search grounded in You.com's independent index, `you-research` for deeper multi-step research queries that synthesize across several sources, and `you-contents` for fetching and extracting clean content from specific URLs. A fourth tool, `you-finance`, covers stock/market data but is opt-in only — it must be explicitly added via the `YDC_ALLOWED_TOOLS` environment variable (e.g. `YDC_ALLOWED_TOOLS=you-search,you-finance`) rather than being enabled by default. Typical use: an agent needs current information beyond its training cutoff — "search for the latest news on X" or "research competing products in this space and summarize the differences" — and calls You.com's search/research tools instead of relying on stale internal knowledge or a generic scraping fallback.

Search the web using Kagi's search API.

The Browserless MCP Server is Browserless.io's official Model Context Protocol integration, exposing Browserless's smart-scraper and browser-automation API as tools any MCP-compatible AI assistant can call — Claude Desktop, Cursor, VS Code, and Windsurf among them. The fastest path is the hosted remote server at `https://mcp.browserless.io/mcp`, authenticated with a Browserless API token (a free tier is available), so most users never run anything locally. Core capabilities: a scraping tool that cascades through strategies (plain HTTP fetch, proxy, full headless-browser render, and CAPTCHA solving as needed) and returns content as markdown, HTML, screenshot, PDF, or extracted links; a web-search tool covering web/news/image search with geo-targeting and time-range filters, with optional per-result scraping; a raw Puppeteer-execution tool that runs custom JavaScript against a live page object on Browserless's cloud browsers for cases the built-in tools don't cover; and a stateful agent-loop mode that keeps a persistent browser session alive across multiple tool calls with snapshot/observe/act primitives, instead of forcing one-shot page loads for every step. This makes it a fit for AI research agents that need to click through paginated results, fill and submit forms, or verify a scrape against a live rendered page rather than a static fetch. The github.com/browserless/mcp-server URL sometimes cited for this project does not exist — the real official repo lives at browserless/browserless-mcp; a separate community implementation, Lizzard-Solutions/browserless-mcp, offers a comparable self-hosted alternative for teams that want to run the bridge themselves instead of the hosted endpoint.

The official ScrapingBee MCP Server turns ScrapingBee's managed web-scraping infrastructure into an AI-native data layer, so AI agents register scraping as a formally callable MCP tool instead of guessing at fetch/parse logic inside a prompt. The architecture is a clean pipeline: AI agent → MCP client → ScrapingBee MCP server → ScrapingBee API → target website → structured JSON response injected back into the agent's context. ScrapingBee handles the parts language models cannot reliably do themselves — bypassing anti-bot protection, rotating proxies, rendering JavaScript-heavy pages, and solving CAPTCHA challenges — which makes this a good fit for AI research agents, ecommerce intelligence bots, and market-monitoring pipelines that need live web data rather than stale training data. The fastest path is the hosted remote MCP endpoint: add it to claude_desktop_config.json via `npx mcp-remote https://mcp.scrapingbee.com/mcp?api_key=YOUR_API_KEY` and restart Claude Desktop to get the tools automatically, no local server process required. For self-hosting or custom integrations, clone the repo, run `npm install`, set a SCRAPINGBEE_API_KEY environment variable, and start the server with `npm start`; the repo also documents a custom async Python MCP client for advanced agentic workflows. Requires a ScrapingBee API key (paid service, free trial available).

Web scraping and browser automation library.

Official Oxylabs MCP server that bridges AI models to the open web at scale — letting agents scrape any URL, render JavaScript-heavy pages, bypass CAPTCHAs and anti-bot systems, and reach geo-restricted content across 195+ countries through Oxylabs' proxy and Web Scraper API infrastructure. Exposes two tool sets. The Web Scraper API tools cover `universal_scraper` (general website scraping with automatic content formatting for LLM consumption), `google_search_scraper` (structured Google SERP extraction), `amazon_search_scraper` (Amazon result pages), and `amazon_product_scraper` (individual product detail pages). The Oxylabs AI Studio tools add `ai_scraper` for AI-powered extraction that returns clean JSON or Markdown from any URL without writing selectors. Distributed as the PyPI package `oxylabs-mcp` (installable via uvx) and on Smithery for one-command setup. Authentication uses `OXYLABS_USERNAME`/`OXYLABS_PASSWORD` for the Web Scraper API (1-week free trial) plus an optional `OXYLABS_AI_STUDIO_API_KEY` (1,000 free credits) for the AI extraction tools. Built for agents doing large-scale market research, price monitoring, lead generation, SEO/SERP tracking, and competitive intelligence where residential/datacenter proxies and reliable rendering matter more than a single-page fetch.

Enable AI agents to get structured data from unstructured web.

Official Hyperbrowser MCP server that gives AI agents a managed, scalable cloud browser instead of a locally-driven one. Its scraping layer covers three levels of extraction: `scrape_webpage` pulls a single page as clean markdown, HTML, links, or a screenshot; `crawl_webpages` follows internal links across a site and returns LLM-friendly formatted content for each page; and `extract_structured_data` takes messy HTML plus a schema and returns typed JSON, which is the tool most people reach for when building datasets from listing or catalog pages. `search_with_bing` adds a straight web-query tool so an agent can find pages before scraping them. Beyond scraping, the server exposes three general-purpose browser agents behind one interface — `browser_use_agent` for fast lightweight automation, `openai_computer_use_agent` for OpenAI's CUA model, and `claude_computer_use_agent` for Anthropic computer use — letting you pick the cost/capability tradeoff per task without rewriting the integration. Persistent browser profiles are first-class via `create_profile`, `list_profiles`, and `delete_profile`, so logged-in sessions survive between runs rather than forcing a fresh login on every job. Install with `npx -y hyperbrowser-mcp` and a `HYPERBROWSER_API_KEY` environment variable, or one-click through Smithery; the repo also documents running from source. MIT licensed, with documented configs for Claude Desktop, Cursor, and Windsurf. Note that the Hyperbrowser REST API supports a superset of what the MCP server exposes.

Fast and secure execution of your AI generated code with Daytona sandboxes.

Replit ships an official, vendor-hosted MCP server that lets an external client create, update, and manage full-stack applications on Replit through natural language. It is hosted at https://replit-mcp.com/server/mcp over Streamable HTTP with OAuth 2.1 plus PKCE, handled automatically by MCP clients and SDKs, so there is no package to install and no API key to paste; that also means there is no public source repository, which is why this listing carries no GitHub link. Under the hood the server is a front door to Replit Agent, so a single tool call turns a prompt into a real, running, published app rather than a code snippet. The public tool surface is deliberately small. create_app_from_prompt takes an appDescription plus an app_stack enum (react_website, mobile_app, design, slides, animation, data_visualization, 3d_game, document, or spreadsheet) and optional userSpecifiedAppName, userQuotes, and attachmentSummary; it returns a replId, a replUrl, and a turnId while Agent keeps building asynchronously in the background. update_app_using_prompt takes that replId plus a changeDescription to add features, fix bugs, or iterate on an existing app. ask_question runs Agent in discussion mode against a replId so you can check build status, ask about the tech stack, or relay a question without modifying any files. Add it to Claude Code with claude mcp add --transport http replit https://replit-mcp.com/server/mcp. Builders need a Replit account on any tier including Free. The server is documented as beta, so tools and behavior may change.

Cloud development environments.

Gitpod does not publish a Model Context Protocol server — a `gitpod-io/mcp-server` repo does not exist, and a GitHub search for "gitpod mcp" turns up nothing beyond an unrelated Minecraft joke repo. Gitpod's own product direction has moved toward Gitpod Flex and CDE-as-infrastructure rather than shipping an MCP tool surface, and unlike GitHub Codespaces (which has an official codespaces-mcp) no community project has stepped in to fill the gap either. If you want an AI agent to provision or control a Gitpod workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Gitpod or the community ships one. In the meantime, the closest cloud-dev-environment MCP options are the CodeSandbox and StackBlitz servers listed in this directory, or GitHub Codespaces MCP for a GitHub-native workflow.

An MCP server for reading files and project structure from StackBlitz projects, built by sxzz. Note this is a community project, not an official StackBlitz release — the previously-listed `stackblitz/mcp-server` repo does not exist. It exposes four tools: `resolve_project` looks up a StackBlitz project by ID or full stackblitz.com/edit/ URL and returns metadata (title, description, preset, visibility, file count); `list_files` renders the project's files as an ASCII tree, optionally filtered by a path prefix; `read_file` pulls the raw contents of a single file by path; and `search_files` runs a text or regex search across the project with case-sensitivity and result-limit options. It also exposes two MCP resource URI patterns — `stackblitz://{projectId}/tree` for the file tree and `stackblitz://{projectId}/files/{path}` for individual file contents — so an agent can browse a StackBlitz reproduction repo the same way it would a local directory. The server is read-only (no file writing or sandbox execution) and requires no API key, since it works against StackBlitz's public project data. It's aimed at the common "someone shared a StackBlitz repro link, now debug it" workflow: paste the project ID into Claude/Cursor and let the agent inspect the code directly instead of you copy-pasting files by hand. Install via npm as a global CLI (`stackblitz-mcp`) and wire it into any MCP-compatible client's config.

A Model Context Protocol server that exposes the official CodeSandbox SDK as MCP tools for AI agents, built by techlibs. This is a community project (not an official CodeSandbox release) — the previously-listed `codesandbox/mcp-server` repo does not exist. Unlike simpler read-only sandbox browsers, this server is fully stateless and covers the entire sandbox lifecycle: `createSandbox` (optionally forking a template, with privacy/title/tags/VM-tier/hibernation settings), `resumeSandbox` and `hibernateSandbox` for VM power state, `getSandboxInfo` for metadata without starting the VM, and `updateSandbox` for changing VM tier (Pico through XLarge) or hibernation timeout. File and shell access go through per-call sessions — `createSession`/`resumeSession` (with read/write permission, environment variables, and optional Git identity for commits) back `readFile`, `readdir`, and `writeFile`, all of which connect per call using a sandboxId + sessionId rather than holding open server-side state. A `--read-only` CLI flag disables all mutating tools and defaults new sessions to read permission, which is the recommended mode for agents you don't fully trust with a live VM. Requires a `CODESANDBOX_API_TOKEN` (or `CSB_API_KEY`) from your CodeSandbox account and Node.js 18+. Run via `npx @techlibs/codesandbox-mcp` in any MCP client config; the CLI binary is `mcp-server-codesandbox`.

Codeium does not publish a Model Context Protocol server — a `codeium/mcp-server` repo does not exist, and a GitHub/npm sweep for one turns up nothing beyond unrelated demo and research repos. That is because Codeium's product direction went the other way: the company rebranded its flagship product to Windsurf, an AI-native code editor (parent org Exafunction) that acts as an MCP *client*, letting its built-in Cascade agent call out to external MCP servers (filesystem, databases, GitHub, etc.) the same way Claude Desktop or Cursor do — it does not expose Codeium/Windsurf itself as a tool server. Exafunction's public repos are IDE plugins (windsurf.vim, windsurf.nvim, CodeiumJetBrains, codeium.el) rather than an MCP integration. If you want an AI assistant to read from or control a Codeium/Windsurf workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Codeium ships one.

Tabnine does not publish a Model Context Protocol server — a `tabnine/mcp-server` repo does not exist, and neither GitHub nor npm turn up a real first-party or community MCP integration for it (searches surface only unrelated demo/config repos with 0-3 stars). Tabnine's public engineering effort (org: codota) is entirely IDE-plugin-shaped — clients for VS Code, JetBrains, Vim/Neovim, Sublime, Atom, and JupyterLab that wire Tabnine's completion models into each editor's native autocomplete UI, plus a separate PR-review agent (tabnine-pr-agent). None of these expose Tabnine as an MCP tool server that Claude, Cursor, or another MCP client could call into. This entry is kept for search/reference purposes and will be updated if Tabnine ships a genuine MCP server in the future.

najva-ai's Sourcegraph MCP Server is a Python server that gives AI assistants AI-enhanced code search across large, multi-repo codebases using Sourcegraph's query engine. It exposes three tools: `search` (run Sourcegraph queries with full advanced syntax — regex patterns, `lang:`/`file:`/`repo:` filters, and boolean operators — across sourcegraph.com or a self-hosted instance), `search_prompt_guide` (generate a context-aware guide that helps the model construct effective queries for a stated objective), and `fetch_content` (retrieve file contents or explore directory structures inside a repository). Auth is via a `SRC_ENDPOINT` environment variable (required — e.g. https://sourcegraph.com) plus an optional `SRC_ACCESS_TOKEN` for private instances. The server runs locally over SSE / Streamable-HTTP (default ports 8000/8080) and is installed from source with UV (`uv sync && uv run python -m src.main`), pip (`pip install -e .`), or a bundled Dockerfile; clients like Cursor connect by pointing `.cursor/mcp.json` at the local `http://localhost:8080/sourcegraph/mcp/` URL. It's ideal for agents that need to find and understand code patterns across many repositories rather than a single local checkout.

The official Semgrep MCP server lets an AI assistant run Semgrep — a fast, deterministic static analysis engine that semantically understands 30+ languages and ships over 5,000 security rules — directly against the code it is writing or reviewing, so you can "secure your vibe coding" without leaving Claude, Cursor, VS Code, or Windsurf. It exposes a focused tool surface: `security_check` scans code for vulnerabilities, `semgrep_scan` runs a scan with a given rule config, `semgrep_scan_with_custom_rule` applies a custom Semgrep rule you supply inline, `get_abstract_syntax_tree` returns the AST of a snippet so an agent can reason about code structure, `supported_languages` lists the languages Semgrep can parse, and `semgrep_rule_schema` fetches the latest rule JSON Schema for writing new rules. With a Semgrep AppSec Platform login and token, `semgrep_findings` pulls findings from your organization's cloud account. The server runs three ways — as a Python package via `uvx semgrep-mcp` (PyPI: semgrep-mcp), as a Docker container `ghcr.io/semgrep/mcp`, or against Semgrep's hosted endpoint at mcp.semgrep.ai — and supports stdio, Streamable HTTP, and SSE transports. Note: the standalone semgrep/mcp repository is now deprecated, with ongoing development folded into the main `semgrep` binary (semgrep/semgrep, under cli/src/semgrep/mcp), so future updates ship through the official Semgrep CLI itself.

The CodeRabbit MCP Server lets Claude and other MCP-capable coding agents pull CodeRabbit's AI code-review output directly into their working context and act on it programmatically, instead of a developer manually reading through GitHub PR comments. Tools cover the full review lifecycle: get_reviews retrieves every CodeRabbit review left on a given pull request, get_review_details returns the configuration and file list behind a specific review, get_comments extracts individual line-level comments together with CodeRabbit's AI-generated prompts and suggested fixes, get_comment_details digs into one comment's full context and example fix, and resolve_comment marks a comment addressed, won't-fix, or not-applicable so the PR thread stays in sync with what the agent actually did. A bundled /coderabbit-review slash command chains these into an automated "fetch, triage, and implement fixes" workflow, which is the main use case: point an agent at a PR that CodeRabbit has already reviewed and have it work through the suggestions autonomously. Installation is npx coderabbitai-mcp@latest with no local build step; the only required credential is a GitHub Personal Access Token (repo scope for private repos, public_repo for public ones) passed as GITHUB_PAT, since the server reads PR review data through GitHub's API rather than CodeRabbit's own API. This is a community integration, not published by CodeRabbit itself, and depends on a repository already having CodeRabbit reviews enabled.

Interact with Codacy API to query code quality issues, vulnerabilities, and coverage insights.

Static code analysis by JetBrains.

DeepL MCP Server is DeepL's official MCP server (DeepL/deepl-mcp-server, npm deepl-mcp-server) that exposes DeepL's high-quality neural translation, document translation, rephrasing, and glossary/style-rule lookups as MCP tools for Claude, Cursor, and other clients. Its core tool, translate-text, translates a single string or an array of strings into a target language with optional source-language auto-detection, formality control (less/more/prefer_less/prefer_more), glossary and style-rule application, tone/context hints, and formatting preservation. translate-document translates whole files — PDF, DOCX, PPTX, XLSX, HTML, TXT and more — reading and writing them on the machine running the server, deriving an output path like report_de.pdf when none is given. rephrase-text rewrites text (optionally into another language) with style and tone options, powering DeepL Write-style polishing. Additional tools list accepted source and target language codes, enumerate account glossaries and their dictionary term entries per language pair, and list style rules. Language codes are ISO 639-1 with optional region (en-US), and target codes that require a region get sensible defaults (en→en-US, pt→pt-BR, zh→zh-Hans). Authentication uses a DeepL API key supplied via the DEEPL_API_KEY environment variable; the server exits immediately if it is unset.

Interact with the Intelligent Content Management platform through Box AI.

Ingest anything from Slack to Gmail to podcast feeds, web crawling, into a searchable project.

Production-ready RAG out of the box to search and retrieve data from your own documents.

RAG Search over your content powered by Inkeep.

Composio exposes its toolkit platform — 1,000+ toolkits with managed authentication, tool search, context management and a sandboxed workbench — over MCP, which makes it a hosted multi-tool endpoint rather than a single-purpose server you run locally. A correction worth stating plainly, because this catalog carried the wrong link: the project is `ComposioHQ/composio` (29,000+ stars, actively pushed), not `ComposioHQ/composio-mcp-plugin`, which is a small three-star side repo for MCP registry plugins. The working model is create-then-generate. You define a server config against one or more toolkits — in Python, `composio.mcp.create(name="my-gmail-server", toolkits=[{"toolkit": "gmail", "auth_config": "ac_xyz123"}], allowed_tools=["GMAIL_FETCH_EMAILS", "GMAIL_SEND_EMAIL"])` — and then mint a per-user URL from it with `composio.mcp.generate(user_id="user-123", mcp_config_id=server.id)`. The URL that comes back has the shape `https://backend.composio.dev/v3/mcp/<SERVER_ID>?user_id=<USER_ID>`, and connections must send an `x-api-key` header carrying your Composio API key — that is required whenever `require_mcp_api_key` is enabled, which is the default for newly created organisations. Two prerequisites trip people up: an auth config for the toolkit has to exist before `create()` will accept it, and the end user has to have authenticated with that toolkit before their generated URL returns anything useful, because handling that OAuth is the point of the platform. Server management is symmetrical and scriptable — `composio.mcp.list()` (filterable by toolkit, with a `limit`), `.get()`, `.update()` to rename or narrow `allowed_tools`, and `.delete()` — and the same configs are editable from the Composio dashboard. SDKs install with `uv add composio` for Python or `@composio/core` for TypeScript, and `@composio/mcp` (v1.0.9 on npm) is a separate small MCP CLI that exposes an `mcp` binary for wiring clients like Claude, Cursor and Windsurf from the command line. Because the endpoint is a plain remote MCP URL with headers, it drops straight into provider-native MCP support — the OpenAI Responses API, for example, takes it as a `{"type": "mcp", "server_url": …, "headers": {"x-api-key": …}}` tool. One caveat from Composio's own documentation: single-toolkit MCP servers are the older path, and for most use cases they now steer you to sessions instead, which give dynamic tool access and let Composio handle context management rather than pinning a fixed tool list per server.

Integrate your AI agent with 500+ APIs: Auth, custom tools, and observability. Open-source.

The Membrane MCP Server is the official Model Context Protocol integration for Membrane, the agentic integration platform formerly known as Integration.app — the company rebranded to getmembrane.com in 2026, and its GitHub org moved from `integration-app` to `membranehq`, which is why the old `integration-app/mcp-server` repo URL no longer resolves. Membrane connects AI agents, products, and internal tools to 100,000+ third-party SaaS applications through a single unified integration layer, so instead of writing bespoke API clients for every app your customers use, an agent calls one MCP server and Membrane routes the request to the right connected integration. The server exposes "actions for connected integrations on Membrane" as MCP tools: in static mode it returns every available action across all connected apps, while dynamic mode lets a client selectively enable only the tools it needs via an `enable-tools` call, and requests can be scoped to specific apps with an `apps` query parameter. Authentication is a Membrane access token, supplied either as a `?token=` query parameter or an `Authorization: Bearer` header — there is no anonymous/no-account mode. It ships as a self-hosted Node.js (v18+) server: clone the repo, `npm install && npm run build`, then run it locally (`npm run dev` serves on `http://localhost:3000`) or containerize it with the provided Docker setup for your own cloud hosting. It speaks MCP over streamable HTTP at `/mcp` (recommended) and a deprecated SSE endpoint at `/sse`. Typical use: an agent needs to "create a contact in whichever CRM this customer has connected" or "sync this record to their connected apps" without the developer hand-building integrations for every possible SaaS target — Membrane's pre-built connector catalog and unified data model handle the app-specific translation.

Inspect traces, manage prompts, curate datasets, and run experiments with open-source AI observability.

Query and analyze your Opik logs, traces, prompts and telemetry data from your LLMs.

Provides access to OpenTelemetry traces and metrics through Logfire.

Create segments, inspect user profiles, search for customers, and access workspace data.

Build, update, and send multi-channel notifications across email, sms, push, Slack, and Teams.

Send product and customer messaging across email, in-app, push, SMS, Slack, Teams.

Glean exposes enterprise search, chat, and agents to any MCP-capable client while enforcing the document permissions your organization already has in place. Two repositories carry the Glean name and the distinction matters: gleanwork/mcp-server, the original local stdio server, is now archived, and the maintained successor is gleanwork/remote-mcp-server (MIT, 164 stars), which Glean marks GA. It is a hosted Streamable HTTP server authenticated with OAuth 2.0 through your company SSO, so there is nothing to install locally and no long-lived API key to paste. Each organization gets its own unique server URL, issued by a Glean admin through the Enable MCP Servers flow in the admin console rather than published as one fixed public endpoint, so setup starts in the Glean admin docs rather than with an npx command. A Glean MCP server can expose three kinds of capability. Glean platform tools cover Search, Chat, Read Document, Code Search, and People, resolved against the unified Glean Knowledge Graph instead of a single source system, so one query spans wikis, tickets, docs, code, and org data at once with user-level access control applied. Glean agents can be surfaced to hosts as callable tools. And the Glean MCP Gateway proxies everything outside Glean: custom read and write tools your team packages, third-party MCP servers routed securely through Glean, and read/write tools from connected data sources. Glean documents 19 supported hosts, including Claude Code, Claude for Desktop, Claude for Teams and Enterprise, ChatGPT, Codex, Cursor, VS Code, and Antigravity. Companion repos worth knowing: gleanwork/configure-mcp-server for client setup and gleanwork/mcp-server-tester for validating MCP servers.

Descript is a popular video and audio editing platform built around transcript-driven editing (delete a word in the text, it cuts the clip), AI overdub voice cloning, screen recording, and Studio Sound noise removal. As of this writing, Descript has not published an official MCP server, and no community project has produced one with meaningful adoption either — repeated GitHub searches across multiple review cycles turn up only forked demo repos and unrelated tools with a description that happens to mention "descript," none exceeding a handful of stars. If you need to script Descript-style transcript/video workflows from an AI agent today, the closest MCP-native options are general-purpose media servers already listed in this directory (search "video" or "audio" categories) combined with Descript's own REST API and Zapier integrations, which are not MCP but can be wrapped in a custom server. This entry is kept as a placeholder so the term stays discoverable; it will be updated the moment Descript or a credible community project ships a real MCP server — check back or watch the Descript developer docs and GitHub for updates.

Connect to the Cartesia voice platform to perform text-to-speech, voice cloning.

Search, fetch, upload, and interact with Gyazo images, including metadata and OCR data.

Canva runs a first-party remote MCP server — marketed inside the product as the Canva AI Connector — at https://mcp.canva.com/mcp, so there is nothing to clone or run locally. Claude Code connects with a single line: claude mcp add canva --transport http https://mcp.canva.com/mcp. Clients that only speak stdio can reach the same endpoint through npx mcp-remote. Authentication is OAuth against your Canva account; Canva's recommended path is now Client ID Metadata Documents, where your client_id is itself a URL pointing at a JSON document describing the client, with the older Dynamic Client Registration flow still supported but deprecated. The tool surface is unusually wide for a design product and is what makes this worth connecting rather than screenshotting designs into a chat. Designs: search-designs, get-design, get-design-pages, get-design-content, get-presenter-notes, generate-design, create-design-from-candidate and copy-design. Brand templates and autofill: search-brand-templates, list-brand-kits, create-design-from-brand-template, get-brand-template-dataset and autofill-design — the combination that lets an agent take a row of data and produce an on-brand asset without a human touching the editor. Assets: upload-asset-from-url and get-assets. Export and import: get-export-formats, export-design, import-design-from-url and resize-design. Folders: create-folder, search-folders, list-folder-items and move-item-to-folder. Comments: comment-on-design, reply-to-comment, list-comments and list-replies, which is the piece that lets an assistant participate in review rather than only produce. The detail most listings miss is the editing-transaction group: start-editing-transaction, perform-editing-operations, commit-editing-transaction and cancel-editing-transaction. Edits are staged and then committed or discarded as a unit, so a model that gets halfway through a change and stops does not leave a half-modified design behind — a meaningfully safer model than fire-and-forget mutations. get-design-thumbnail gives the agent a preview to check its own work against.

MCP server for Mobile Development and Automation - iOS, Android, Simulator, Emulator.

BrowserStack's official MCP server connects Claude, Cursor, VS Code, and other MCP clients to the BrowserStack Test Platform so agents can manage, run, debug, and even fix tests using plain-English prompts. It surfaces BrowserStack's real-device and browser cloud directly inside your IDE or LLM: launch manual app and web test sessions on thousands of real iOS/Android devices and desktop browser/OS combinations, reproduce and debug crashes without local device setup, run and triage automated test suites, and perform accessibility testing against WCAG guidelines. Because context stays in one place, agents can read failing-test output, propose a code fix, and re-run the test in the same conversation — cutting the context-switching between IDE, dashboard, and device lab. Distributed as the official npm package `@browserstack/mcp-server` (Node.js >= 18 required) with one-click setup buttons for VS Code and Cursor via mcp.browserstack.com, plus a hosted remote option. Authentication uses your BrowserStack username and access key from the account settings. Ideal for QA and dev teams that want an AI assistant to drive cross-browser/real-device testing, debug flaky automation, and validate accessibility without leaving their editor or writing boilerplate BrowserStack API calls.

Connect AI assistants with your testing workflow for accessibility, SmartUI, automation.

The official Burp Suite MCP Server, published by PortSwigger, is a Burp extension that exposes Burp Suite's web-security testing engine to AI clients over the Model Context Protocol, letting Claude and other assistants drive live penetration-testing workflows against a target instead of just reasoning about them abstractly. It ships as a Java extension you load into Burp (built from source with `./gradlew embedProxyJar` to produce `burp-mcp-all.jar`, then added via the Extensions tab), and it bundles a packaged stdio MCP proxy alongside an SSE server so any MCP client can connect — Claude Desktop even gets an automatic installer that writes the client config for you. Once loaded, an MCP tab in the Burp UI controls the server: an Enabled checkbox toggles it, the host/port default to http://127.0.0.1:9876, and a separate opt-in checkbox is required before the assistant is allowed to expose config-editing tools, keeping destructive changes behind an explicit gate. Through these tools an AI client can interrogate and manipulate Burp's state — inspecting proxy history and HTTP traffic, sending and modifying requests, and coordinating scanning — which suits agentic security-testing, triage, and report-drafting workflows. Requires Java (with the `jar` command) on your PATH and a running Burp Suite instance. This is PortSwigger's own first-party server, so it tracks Burp's capabilities directly rather than screen-scraping the UI.

Boost security via SAST, SCA, Secrets & IaC scanning with Cycode.

Scan projects using GitGuardian's API with 500+ secret detectors to prevent credential leaks.

Find and fix security risks in your code, scan and secure from vulnerabilities and secret leaks.

MCP guardrails coding agents against introducing dependencies with vulnerabilities, malware.

Open Source data labeling platform.

Deploy your project to the cloud seamlessly with the Defang platform.

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.

Official Gremlin MCP server for chaos engineering and reliability management, exposing Gremlin's Reliability Management (RM) APIs as agent-callable tools. On the service side, `list_services` enumerates every RM service with its reliability score and targeting info, while `get_service_dependencies`, `get_service_status_checks`, and `list_service_risks` drill into a single service to show what it depends on, how it is monitored, and which risks Gremlin has flagged. Reporting tools cover `get_reliability_report` (per-service report for a given date) and `get_reliability_experiments`, which returns recent chaos experiments filtered by dependency or test. Test-suite visibility comes from `get_recent_reliability_tests` and `get_current_test_suite`, so an agent can answer questions like whether a weekly test schedule is actually firing across a six-week policy-expiry window. There is also a billing and fleet-health tier — `get_pricing_report` breaks usage down by tracking period (Daily/Weekly/Monthly) with active agents and unique targets by type, and `get_client_summary` and `get_attack_summary` report agent activity and attack outcomes per team over a date range. Requires Node 18 or higher and a `GREMLIN_API_KEY` from your Gremlin account settings; `GREMLIN_SERVICE_URL` optionally repoints the server at a staging or self-hosted API. Install with `npx -y @gremlin/mcp-server`, with documented setup for Claude Desktop, Cursor, and VS Code 1.99+.

Chat with your builds, CI, and more.

Enable AI access to your CloudBees CI cluster, the Enterprise-grade Jenkins-based solution.

MCP server for DeployHQ API integration, enabling AI to manage deployments.

MCP Server for the JFrog Platform API, enabling repository management and build tracking.

Discovery, exploration, reporting and root cause analysis using all observability data.

Bring real-time production context—logs, metrics, and traces—into your local environment.

Query and interact with kubernetes environments monitored by Metoro.

Official MCP Server to get your behavioral analytics data and insights from Clarity.

Access network of thousands of probes to run ping, traceroute, mtr, http and DNS resolve.

The Home Assistant MCP server lets Claude, ChatGPT, and other MCP clients control and query your smart home in plain language — turning devices on or off, adjusting lights, thermostats, and media players, reading live entity states, calling services, and managing automations and scenes. This community server (homeassistant-ai/ha-mcp), the most-adopted and actively maintained Home Assistant MCP server, is built on FastMCP and exposes 87+ tools spanning device control, state queries, service calls, automation management, and configuration inspection. Its recommended deployment is the HA-MCP Custom Component installed through HACS, which runs the full server in-process inside Home Assistant and works across every install type — Home Assistant OS, Supervised, Container, and Core — with full feature parity and no separate access token to manage. It can also run as a Home Assistant app/add-on on HA OS and Supervised installs (exposing a unique MCP URL with no credential setup), or as a standalone server connecting to your instance via a long-lived access token. Potentially destructive file and YAML-editing tools are gated behind opt-in feature flags and off by default, so a default install is read-and-control only. It integrates with Claude Desktop, Claude.ai, ChatGPT, Cursor, and any MCP client on your local network or configured for remote access. Note: this is a community project, explicitly unofficial and not published by Home Assistant / Nabu Casa.

The Philips Hue MCP Server (mcp-light-control by ykhli) is the highest-starred open-source MCP integration for Philips Hue smart lighting, letting Claude, Cursor, and other MCP clients turn lights on/off and query bridge state directly from a conversation. It talks to your Hue Bridge over the official Philips Hue local API, discovered via a bundled `node build/discover-bridge.js` script that walks you through pressing the bridge link button to mint a bridge username/API key — no cloud account required for local control. A second mode supports the Hue Remote (cloud) API via OAuth2 client credentials and access/refresh tokens, letting an agent control your lights from outside your home network; refresh tokens last roughly 100 days and need periodic renewal. The server exposes three tools: `control_lights` (turn all or specific light IDs on/off), `get_lights_info` (list all bridge-registered lights and their current state), and a novelty `send_morse_code_through_light` tool that blinks a message in Morse code at an adjustable speed — the project's original motivating use case was having a coding agent flash a light when a long-running task finished. No published npm package; install by cloning the repo, running `npm install && npm run build`, and pointing your MCP client config at the generated `build/index.js` with `HUE_USERNAME`/`BRIDGE_IP` env vars (or the remote OAuth env vars for cloud mode). Requires Node.js v14+ and an existing Hue Bridge + lights on your network. A useful "physical status indicator" pattern for home-automation and ambient-notification workflows, though the tool surface is intentionally minimal — no scenes, groups, or color/brightness control beyond on/off.

Control Aqara smart home devices, query status, execute scenes.

Official Baidu Maps MCP server — the first map provider in China to ship Model Context Protocol support — giving agents authoritative location intelligence for Chinese geography, where Western mapping APIs are weakest. The tool surface covers the full location-based-services stack: `map_geocode` turns an address into coordinates and `map_reverse_geocode` goes the other way, returning address, administrative region, and nearby POI context. `map_search_places` finds points of interest by keyword, type, region, or radius, and `map_place_details` fetches the full record for a POI by its unique ID. Routing comes in two forms — `map_directions` plans a single trip by driving, walking, cycling, or public transit, while `map_directions_matrix` batches many origin/destination pairs at once for logistics and delivery-optimization work. Rounding it out are `map_weather` for real-time and forecast conditions by region or coordinate, `map_ip_location` for coarse IP-based city lookup, `map_road_traffic` for live congestion on a road or area, and `map_poi_extract`, which pulls structured POIs out of free-form text such as travel notes (this one requires elevated account permissions). Requires a server-side API key (AK) from the Baidu Maps Open Platform console with the MCP (SSE) service enabled. Ships official SDKs for both runtimes: `pip install mcp-server-baidu-maps` run via `python -m mcp_server_baidu_maps` with `BAIDU_MAPS_API_KEY`, or the npm package `@baidumap/mcp-server-baidu-map`. Baidu recommends SSE transport over stdio for lower latency. MIT licensed.

Official Mapbox server that turns any AI agent into a geospatially-aware system by exposing Mapbox's location intelligence platform as MCP tools. Covers global geocoding (addresses/place names to coordinates and back), points-of-interest search across millions of businesses and landmarks, multi-modal routing for driving, walking, and cycling with real-time traffic, travel-time matrices for accessibility and logistics analysis, and route optimization that solves multi-stop traveling-salesman-style visiting order. Also includes map matching to snap noisy GPS traces onto the road network, isochrone generation to visualize areas reachable within a given time or distance, static map image rendering, and offline geospatial calculations (distance, area, bearing, buffers) that don't require an API call. A Mapbox access token is required; the server can be run locally via npm or accessed through Mapbox's own hosted MCP endpoint at mcp.mapbox.com/mcp for zero-install setup. Fits AI travel assistants, delivery-route optimizers, location-based recommenders, and any agent that needs to reason about 'where' — with documented integration guides for Claude Desktop, Cursor, VS Code, and Goose.

Official BuiltWith MCP server, putting the technology-detection dataset behind natural-language questions like "what does example.com run on?", "is this site on Shopify or Magento?", or "which analytics stack does nytimes.com use?". The tool surface goes far past a single lookup. Detection and metadata come from `domain-lookup`, `domain-api`, and `change-api`, the last returning technology additions and removals with business context — useful for spotting a prospect who just migrated off a competitor. Prospecting is handled by `lists-api`, which finds every site using a given technology and filters on numeric attributes like `SPEND`, `REVENUE`, and `EMPLOYEES`, plus `company-to-url` for company-to-domain resolution, `relationships-api` for related properties, `redirects-api`, `keywords-api`, `tags-api`, and `trends-api` for adoption curves over time. Newer additions include `vector-search` for semantic similarity across technologies and categories, `ask-api` for plain-English list queries ("Magento websites in Spain") with pagination, `trust-api` for trust scoring, `product-api` for ecommerce product search, and `vat-api` for company registration numbers. Credit-free utility tools — `whoami-api`, `usage-api`, and the `mcp-registry-api` v1/v2 endpoints that browse BuiltWith's own registry of remote MCP servers — cost nothing against your quota. The recommended setup is the hosted endpoint at `https://api.builtwith.com/mcp` with a bring-your-own `Authorization: Bearer <BUILTWITH_API_KEY>` header, so there is no local process to run; self-hosting is supported for custom routing or private networks by cloning the repo and running `bw-mcp-v1.js` over stdio or, since February 2026, HTTP transport.

Interact with the Hunter API to get B2B data using natural language.

Mercado Libre's official MCP server.

Marketing insights and audience analysis covering demographic, cultural, influencer analysis.

Interact with Atlan services for data cataloging.

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.

Hand-picked GraphQL operations exposed to AI agents as individual, typed MCP tools rather than raw schema access. That one design decision separates the Apollo MCP server from every "point an agent at your API" wrapper: you do not hand a model your whole schema and hope it composes a sane query; you author the `.graphql` operation documents you are willing to expose, and each one becomes a tool with a name, a description and a typed argument list derived from the operation's variables. That keeps the blast radius of an agent-issued query inside operations your team already reviews, and it means the tool surface stays small enough to fit a client tool-count limit. Written in Rust and maintained by Apollo, it runs in front of any GraphQL API — a federated supergraph on GraphOS, or a plain single-service graph. Schema can come from a local SDL file, from GraphOS Uplink for federated graphs, or (new in v1.17.0, released 2026-07-30) from `schema.source: graphos`, which polls the GraphOS Platform API for non-federated monographs and hot-republishes on a schema-hash change without a restart. Two transports are supported: `stdio` for local desktop clients and `streamable_http` for hosted deployments, the latter with a real `auth` block doing OIDC discovery, per-issuer JWKS caching and RFC 8414 issuer validation. One operational gotcha worth knowing before you deploy: until v1.17.0 an `auth` block misplaced under `stdio` parsed fine and was then silently dropped, so a server could look authenticated and not be — current versions reject that config at parse time. Install the prebuilt binary with `curl -sSL https://mcp.apollo.dev/download/nix/latest | sh`, run the container image `ghcr.io/apollographql/apollo-mcp-server:latest`, or build from source with `cargo build` if you have Rust. Release binaries ship for macOS, Linux (gnu and musl) and Windows on both x86_64 and aarch64, and a `config.schema.json` is published with each release so your editor can validate the config file.

Turn your GraphQL API into an efficient MCP server with schema intelligence.

Get instant AI-powered access to 300,000+ help topics on DevExpress UI Component APIs.

The official Microsoft Learn MCP Server gives Claude, Cursor, VS Code, GitHub Copilot, and any other MCP-compatible client direct, real-time access to Microsoft's official technical documentation, so an assistant answers Azure, .NET, Microsoft 365, and Windows-development questions from current first-party docs instead of hallucinating deprecated SDK methods or invented package names from stale training data. It exposes three tools: microsoft_docs_search runs semantic search against Microsoft's official documentation corpus, microsoft_docs_fetch pulls a specific Learn page and converts it to clean markdown for the model to read in full, and microsoft_code_sample_search retrieves official Microsoft/Azure code snippets with an optional language filter — useful for verifying an AI-generated Azure CLI command or confirming the current signature of an Azure SDK method actually compiles. This is a hosted remote server, not a package to install locally: it runs at the Streamable-HTTP endpoint `https://learn.microsoft.com/api/mcp`, requires no API key, login, or signup, and is free with a high search capacity tuned for heavy coding sessions. An experimental OpenAI-compatible endpoint (`/openai-compatible`) supports OpenAI Deep Research-style clients, and a `maxTokenBudget` query parameter can cap response size. Because it only surfaces official first-party Microsoft documentation rather than scraping arbitrary web search results, it also reduces the supply-chain risk of an agent picking up code from an unverified blog post. A companion `@microsoft/learn-cli` npm package and a set of Claude Code / Copilot CLI Agent Skills (microsoft-docs, microsoft-code-reference) ship in the same repo for terminal-based or skill-driven use.

Allows Homebrew users to run Homebrew commands locally.

CLI for interacting with GitKraken APIs, includes MCP server for Jira, GitHub, GitLab.

Work on your code with JetBrains IDEs: IntelliJ IDEA, PhpStorm, etc.

Google's own MCP server for driving and inspecting a live Chrome instance — the one case where "browser automation" undersells what a server does, because automation is only one of eleven tool categories. It is built on Puppeteer for the clicking and typing (with automatic waiting for action results), and on the Chrome DevTools frontend for the part nothing else offers: `performance_start_trace` / `performance_stop_trace` record a real trace and `performance_analyze_insight` returns the same actionable insights the Performance panel shows, optionally alongside CrUX field data for the same URL. There is also `lighthouse_audit`. Roughly 56 tools ship across Input automation (10), Navigation (6), Emulation (2), Performance (3), Network (2), Debugging (8, including `take_snapshot` of the accessibility tree and source-mapped console messages), Memory heap-snapshot analysis (12), Extensions (5), third-party developer tools, WebMCP and Progressive Web Apps — but several of those categories are off by default and gated behind flags: `--categoryExtensions`, `--categoryPwa`, `--memoryDebugging`, `--experimentalScreencast` (needs ffmpeg), `--experimentalVision` for coordinate-based `click_at`. Run `--slim` for a smaller set if you only want basic browsing. By default the server launches its own Chrome against a dedicated profile at `$HOME/.cache/chrome-devtools-mcp/chrome-profile`, so it starts logged in to nothing; `--autoConnect` (Chrome 144+, with remote debugging enabled at `chrome://inspect/#remote-debugging`) or `--browserUrl=http://127.0.0.1:9222` instead attach it to a browser you are already using, which is how you test signed-in flows and also how an agent inherits your real session. Network access can be fenced with `--blockedUrlPattern` / `--allowedUrlPattern` (URLPattern syntax; the allow form needs Chrome 149+). Only Google Chrome and Chrome for Testing are officially supported. Note that usage statistics are collected by default and CrUX lookups are on by default — opt out with `--no-usage-statistics` and `--no-performance-crux`.

Free open-source platform for building production-ready AI systems with RAG, evaluations, and fine-tuning.

Integrates the LINE Messaging API to connect an AI Agent to LINE Official Account.

Infobip's official set of remote MCP servers, turning the company's global CPaaS platform into agent-callable omnichannel messaging. Rather than one monolithic server, Infobip exposes a per-channel fleet under the base URL `https://mcp.infobip.com`, each a streamable-HTTP endpoint you connect to independently: `/sms` (send/preview, scheduling and rescheduling, bulk sends, transliteration and multilingual character sets, delivery reports, message logs, URL tracking), `/whatsapp` (template messages, text and media — image/audio/video/document/sticker — location and contact messages, full template CRUD, delivery reports, SMS failover), `/whatsapp-flow` (build and manage static and dynamic interactive flows with forms, buttons, and checkboxes), `/viber`, `/rcs` (rich cards, suggested replies, carousels, barcodes with SMS/MMS failover), `/email` (single and bulk sends, scheduling, address validation), `/voice` (single and multi-recipient calls, text-to-speech, pre-recorded audio, conference calls, call logs), and `/mobile-app-messaging` for push notifications and in-app inbox management. Beyond raw sending, additional servers cover sender registration and number purchasing, 2FA flow setup, Telco network authentication to harden online transactions, customer-data storage and activation, Infobip user-account management, multi-tenant orchestration via CPaaS X, and a documentation-search server that lets deep-research models retrieve Infobip docs as a live data source. Authentication is production-grade — OAuth 2.1 or an API key — with agent-level permission and access control so an agent only exercises the channels and scopes it is granted. A free trial account is available. MIT licensed; connect via any MCP client with `claude mcp add --transport http infobip-sms https://mcp.infobip.com/sms`.

Official ClickSend MCP Server for SMS and communication.

Mailgun MCP Server is Mailgun's official, OpenAPI-driven MCP server (mailgun/mailgun-mcp-server, published to npm as @mailgun/mcp-server) that gives Claude, Cursor, and other MCP clients a workflow-oriented interface to send transactional email, diagnose deliverability, and run account operations. It runs locally over stdio — Mailgun does not offer a hosted version — and at startup parses a bundled Mailgun OpenAPI spec, registering a curated allowlist of endpoints as MCP tools with Zod-generated input schemas. Capabilities span Messaging (send emails, retrieve stored messages, resend), Domains (view details, verify DNS, manage click/open/unsubscribe tracking), inbound Routes, versioned email Templates, Analytics and Stats (sending/usage metrics and logs broken down by domain, tag, provider, device, and country), address Validation before sending, and Inspect email-rendering previews across clients. Every tool is annotated with a product tag (send, validate, optimize, inspect) so tag filtering can scope which tools load for a given workflow. Notably, only read and update operations are exposed — no delete tools — keeping the blast radius of an unintended AI action small. Authentication uses a Mailgun API key from the API security settings, supplied via MAILGUN_API_KEY, with MAILGUN_API_REGION=eu for EU-hosted accounts. Requires Node.js v20.12+.

Official MCP server for Sinch Mailjet contact, campaign, segmentation, statistics APIs.

Elastic Email MCP Server delivers full-scale email capabilities to AI agents.

Trade stocks and options, analyze market data, and build strategies through Alpaca API.

Interface with CoinEx cryptocurrency exchange for market data, orders, balance queries.

MCP Server for CoinStats API - crypto market data, portfolio tracking and news.

Cashfree Payments official MCP server for payment integration.

Interact with Flutterwave payment solutions API to manage transactions and payments.

MCP Server that connects AI agents to Chargebee platform for subscription billing.

Search, request, and manage e-signature contracts effortlessly.

Contract and template management for drafting, reviewing, and sending binding contracts.

Create, Edit, Sign, Extract Documents using Natural Language.

MCP server for creating Datawrapper charts using AI assistants.

Ready-made features for AI & human collaboration—use to develop your Liveblocks app quicker.

AI assistants interact with Anytype - a local and collaborative wiki - through natural language.

Official MCP Server to integrate with GROWI APIs.

The DevRev MCP Server lets MCP-capable clients like Claude Desktop, Cursor, and Windsurf search and manage DevRev's unified customer-and-dev platform directly from chat, without switching to the DevRev web app. Its search tool queries across multiple DevRev namespaces at once — issues, tickets, articles, and more — using DevRev's own query syntax (e.g. `product:payments api` scopes a search to a specific product part), so an agent can locate relevant work items in one call instead of paging through separate endpoints. Work-item tools cover listing works filtered by type/owner/related-part, fetching full object detail by ID, and creating new issues or tickets tied to a specific feature or part — useful for turning a bug report surfaced in a support ticket into a linked engineering issue without leaving the assistant. Parts-management tools expose the product hierarchy (products, capabilities, features, epics) so an agent can navigate DevRev's org structure, and a built-in devrev_context() tool returns comprehensive documentation on every available tool, namespace, and parameter — handy for self-onboarding an agent into an unfamiliar DevRev workspace. Authentication uses a DevRev Personal Access Token set as the DEVREV_API_KEY environment variable; the server runs as a local Python process (SSE transport on 127.0.0.1:8888 by default) that Cursor or another client connects to over HTTP. This is an unofficial, community-maintained implementation — DevRev itself has not published a first-party MCP server as of this writing — so treat it as the best available option for AI-assisted DevRev workflows rather than a vendor-supported integration.

Modern product teams connect their AI assistant to Atono to create and update stories, bugs.

Interact with task, doc, and project data in Dart, an AI-native project management tool.

Official MCP server for Cortex.

Experimental MCP server for real-time compliance intelligence into your AI workflows.

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

Access OpenAI models, manage assistants, threads, and files through MCP. Use GPT-4o and o1 models as tools from other AI clients in a unified workflow.

Get Tailwind CSS class suggestions, documentation lookups, and component generation assistance. Accelerates front-end development with AI-powered Tailwind knowledge.

Access shadcn/ui component documentation, generate component code, and get installation instructions for Radix UI-based component library integration.

Send SMS, WhatsApp messages, and make voice calls through Twilio's official MCP server. Automate communication workflows from AI coding and automation tools.

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 time-series data stored in TimescaleDB. Analyze IoT metrics, financial data, and application telemetry with SQL and time-series functions.

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

Run TypeScript and JavaScript scripts with Deno from AI assistants. Execute code, manage packages with JSR, and interact with Deno Deploy.

JavaScript runtime and toolkit MCP server. Run scripts, manage packages, execute tests, and work with Bun's built-in bundler and APIs.

High-performance build system for JavaScript monorepos. Query task graphs, run builds, manage caching, and optimize pipelines with AI.

Smart build system for monorepos. Run tasks, understand project graph, generate code, and optimize CI pipelines across frameworks with AI assistance.

Next-generation frontend build tool MCP. Inspect bundle contents, analyze dependencies, troubleshoot HMR issues, and optimize build configurations.

Rust language server MCP integration. Provides code completion, type inference, refactoring, and diagnostics for Rust projects.

Official Go language server (gopls) MCP integration. Navigate codebases, find usages, refactor Go code, and run tests intelligently.

Python LSP MCP server. Intelligent Python code analysis, autocompletion, linting with pylint/flake8, and formatting with black/autopep8.

Build automation MCP for Java/Kotlin/Android projects. Run tasks, manage dependencies, analyze build scripts, and inspect Gradle project structure.

FlyMCP is an official Model Context Protocol server developed by Fly.io that wraps the `flyctl` CLI, giving AI assistants like Claude Desktop, Cursor, and Windsurf direct control over your global Fly.io deployments. By bridging agents to the Fly.io environment, it enables LLMs to perform platform capabilities directly from your chat—managing applications, scaling machines, inspecting logs, and orchestrating deployments without requiring developers to manually run terminal commands. Written in Go, it requires Go 1.21+ and a locally installed `flyctl` CLI authenticated via `flyctl auth login`. Because it acts as a wrapper over the CLI, it inherits your existing authentication state and permissions seamlessly. Currently, it is distributed as a source repository rather than a precompiled binary, requiring a quick `go build -o flymcp` setup before configuring your MCP client to point at the generated executable.

Railway's official MCP server puts your Railway projects — services, databases, environment variables, deployments, networking, volumes, and templates — inside natural-language reach of Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Factory Droid, and OpenCode. As of the current release, the standalone `@railway/mcp-server` npm package is deprecated in favor of shipping MCP support directly inside the Railway CLI: running `railway mcp` starts a local stdio server, while `railway mcp install` auto-detects installed AI tools and writes the correct client config for you (add `--agent <tool>` to target one of claude-code, cursor, factory-droid, copilot, codex or opencode; add `--remote` to route through `railway mcp proxy` to Railway's hosted server at mcp.railway.com using your CLI login, or `--remote --oauth` to write the HTTPS endpoint directly and let the client run OAuth). `railway setup agent` does the same thing and also installs Railway's `use-railway` agent skill. The installer merges Railway's entry into existing MCP configs without clobbering other servers you've already set up. Local and Remote are not the same tool set: Local exposes roughly fifty tools including domains, volumes, TCP proxies, buckets, logs and metrics, while Remote exposes eleven — and only Remote has `railway-agent`, which hands multi-step debugging to Railway's own agent. Remote also refuses project tokens; it requires a user identity for billing and audit. Once connected, you can ask your AI agent to spin up a new environment from a GitHub repo, roll environment variables across services, inspect deploy logs when a build fails, provision a Postgres or Redis instance, or manage networking and volume mounts — all without leaving your editor or touching the Railway dashboard. Because the CLI is the source of truth, keeping `railway` up to date is enough to pick up new MCP tools; there's no separate npm package to track anymore. The legacy `@railway/mcp-server` package is a deprecated compatibility shim, last published as 0.1.12 on 2026-05-23, and the repository it came from (railwayapp/railway-mcp-server, 192★) was archived the same day — both still install cleanly, which is why people are still running the old path.

Interact with Amazon S3 buckets and objects. Upload, download, list, and manage files, configure bucket policies, and analyze storage costs. Repository corrected 3 August 2026: this listing pointed at aws/mcp-proxy-for-aws, which is AWS's SigV4 authentication proxy and not an S3 server at all, and carried that repo's star count. The closest real S3 server is aws-samples/sample-mcp-server-s3 (78 stars, MIT-0, Python), which exposes ListBuckets, ListObjectsV2 and GetObject as tools and additionally surfaces PDF documents as MCP resources, capped at 1,000 objects. It is sample code rather than a supported product and is not published to PyPI, so it has to be cloned and run with uv rather than installed with a one-liner; the command below is the documented local path. For production AWS access, AWS's maintained servers live in the awslabs/mcp monorepo.

Manage Azure Blob Storage containers and blobs. Upload and download files, configure access tiers, manage lifecycle policies, and inspect metadata.

Manage GitHub Actions workflows, runs, and secrets. Trigger workflows, inspect run logs, manage environment variables, and debug CI failures via AI.

The Prometheus MCP Server lets an AI assistant drive a live Prometheus instance through the HTTP API instead of you hand-writing PromQL in the expression browser — ask it why queries got slow, what is currently firing, or which recording rules would make an SLO cheap to evaluate, and it composes and runs the queries itself. One point of provenance worth knowing before you install: this began life as tjhop/prometheus-mcp-server and was adopted into the Prometheus organisation, so that path now 301-redirects to prometheus/prometheus-mcp, while release binaries and container images are still published under the tjhop namespace. The tool surface goes far past a single query endpoint. Instant and range queries (query, range_query, exemplar_query) sit alongside discovery tools — label_names, label_values, metric_metadata, list_targets, alertmanagers — and operational ones: list_alerts, list_rules, config, flags, build_info, healthy, ready, plus TSDB admin endpoints such as clean_tombstones, delete_series, snapshot, reload, wal_replay_status and quit. It also embeds the official prometheus/docs corpus as both tools (docs_list, docs_read, docs_search) and MCP resources under prometheus://docs, so the model can cite metric-naming best practice rather than invent it. Two features exist specifically to keep long investigations inside a context window: optional TOON (Token-Oriented Object Notation) encoding of API responses in place of JSON, and a configurable response-truncation limit that capable models can override per tool call. Prometheus-compatible backends are handled explicitly rather than assumed — a --prometheus.backend flag selects an implementation, and the Thanos profile removes the tools Thanos returns 404 for (config, alertmanagers, quit, reload, the TSDB admin set) while adding list_stores. Install as a Go binary from the releases page, as a Debian/RPM system package with a bundled systemd unit, via the OCI Helm chart at oci://ghcr.io/tjhop/charts/prometheus-mcp-server, or as a container: `docker run --rm -i ghcr.io/tjhop/prometheus-mcp-server:latest --prometheus.url "https://your-prometheus:9090"` for stdio, or add `--mcp.transport http --web.listen-address ":8080"` for streamable HTTP. Every flag has a PROMETHEUS_MCP_SERVER_* environment-variable equivalent. Secured Prometheus instances are reached with a standard Prometheus http_config file via --http.config, and the MCP endpoint itself can be put behind TLS and basic auth with a Prometheus web-configuration file via --web.config.file. Read the credential-forwarding note before exposing it: over HTTP transport the server forwards each request's Authorization header to Prometheus verbatim without validating it, requests without one fall back to the default client's credentials, and basic_auth_users in the web config conflicts with that forwarding — so anyone who can reach the endpoint can query Prometheus as at least the default client.

Run 200+ open-source AI models via Together AI's inference API. Access Llama, Mistral, Qwen, and other top models with high throughput and low latency.

Ultra-fast LLM inference using Groq's LPU hardware. Access Llama 4, Mixtral, and other models at speeds up to 500 tokens/second via MCP.

Run large language models locally with Ollama. Pull models like Llama 3, Phi-3, and Gemma, execute prompts, and manage model library from AI assistants.

LiteLLM is not a single MCP server so much as an MCP Gateway: the MCP layer inside the LiteLLM AI Gateway (proxy), which puts one fixed `/mcp` endpoint in front of every MCP server your organisation uses and controls access to them by key, team and organisation. Start with the install trap, because it is the reason most people land here. There is no separate `litellm-mcp-server` package — that name is not published on PyPI, so any guide telling you to `pip install litellm-mcp-server` is wrong and the command will fail. The gateway ships inside LiteLLM itself, so the correct install is `pip install 'litellm[proxy]'` (litellm 1.95.0 on PyPI), from the BerriAI/litellm repository. Backing servers are registered either in `config.yaml` under `mcp_servers:` or from the LiteLLM UI under MCP Servers → Add New MCP Server; persisting them to the database needs `STORE_MODEL_IN_DB=True` (or `general_settings.store_model_in_db: true`, optionally narrowed with `supported_db_objects: ["mcp"]` so only MCP objects are stored). All three transports are supported for the servers behind it — streamable HTTP, SSE and stdio — so a stdio entry with `command`, `args` and `env` (say `npx -y @circleci/mcp-server-circleci`) sits behind the same gateway endpoint as a hosted URL. Auth per backing server is declarative: `auth_type` accepts `none`, `api_key` (sends `X-API-Key`), `bearer_token`, `basic`, `authorization` (verbatim, no prefix), `token` (GitHub style), `oauth2` — which must declare an `oauth2_flow` of `authorization_code` for interactive PKCE sign-in or `client_credentials` for machine-to-machine — `oauth2_token_exchange` for RFC 8693 on-behalf-of, and `aws_sigv4` for MCP servers hosted on Bedrock AgentCore. `static_headers` covers servers that just want fixed headers on every request, `extra_headers` names headers to forward from the client, and `${VAR_NAME}` server variables can be scoped Instance (shared) or Per-user. On the client side you connect to `http://<your-proxy>:4000/mcp/` with an `x-litellm-api-key` header, choose a server group with `x-mcp-servers`, and pass per-server credentials as `x-mcp-{server_alias}-{header_name}` — `x-mcp-github-authorization: Bearer gho_…` alongside `x-mcp-zapier-x-api-key: sk-…` — so a single connection carries different auth for each backing server instead of sharing one token across all of them. Tool names are namespaced by server, and `litellm_settings.mcp_aliases` maps a short alias onto a server name so tools read `github_create_issue` rather than `github_mcp_server_create_issue`. A direct REST path, `/mcp-rest/tools/list` and `/mcp-rest/tools/call`, lets you list and call tools with curl and no LLM in the loop. One version note: from LiteLLM v1.80.18 the gateway speaks MCP protocol 2025-11-25 and rejects new server names that do not comply with SEP-986; existing non-compliant names only warn for now.

Data framework for LLM applications. Index documents, build RAG pipelines, query knowledge bases, and create multi-step agents over structured and unstructured data.

Multi-agent AI orchestration framework. Define crews of AI agents with specialized roles, tools, and tasks. Automate complex multi-step workflows.

Access DeepSeek's reasoning and code models via MCP. Use DeepSeek-R1 for complex mathematical and coding problems with extended chain-of-thought reasoning.

Run Python functions in the cloud with Modal. Deploy serverless GPU workloads, schedule jobs, build ML pipelines, and access data lakes without infrastructure setup.

Send messages, manage channels, schedule meetings, and read notifications in Microsoft Teams. Automate team collaboration from AI coding and productivity tools.

Google does not publish a Gmail MCP server. The two repositories in the googleworkspace GitHub organisation — developer-mcp and dev-assist — are for building on Google Workspace APIs, not for reading your mail, so every Gmail MCP setup in circulation is community-built. The leading one by a wide margin is taylorwilsdon/google_workspace_mcp, a Python server published to PyPI as workspace-mcp that covers Gmail alongside eleven other Workspace services behind a single connection: Drive, Calendar, Docs, Sheets, Slides, Forms, Tasks, Contacts, Chat, Custom Search and Apps Script, 120+ tools in total. Gmail contributes fifteen of them across three loadable tiers — core is search_gmail_messages, get_gmail_message_content, get_gmail_messages_content_batch and send_gmail_message; extended adds threads, attachments, drafts, labels and filters; complete adds the batch label operations. Run it with `uvx workspace-mcp --tools gmail` to load Gmail only, or `--tool-tier core` to keep the tool schemas small. Auth is your own Google Cloud OAuth client — the server ships no credentials and sends nothing anywhere except Google's APIs — and `--read-only` is a real, documented switch. The server most third-party guides still name, GongRzhe/Gmail-MCP-Server (npm @gongrzhe/server-gmail-autoauth-mcp), was archived on 2025-08-06 and its npm package has not been published since; it still installs, which is why it keeps getting recommended.

Access and manage secrets stored in 1Password vaults. Retrieve credentials, SSH keys, API tokens, and secure notes directly in AI coding environments.

Comprehensive vulnerability scanner MCP. Scan container images, filesystems, and git repos for CVEs, misconfigurations, and secrets with Aqua's Trivy.

Query Google Analytics 4 data via MCP. Analyze traffic, user behavior, conversions, and audience segments using GA4's reporting API.

Search and download high-quality free stock photos from Unsplash. Find images by keyword, collection, or photographer. Get proper attribution and download links.

Long-term memory layer for AI applications. Store and retrieve user preferences, conversation history, and entity facts with temporal reasoning and semantic search.

Personalized memory layer for AI. Automatically extract and store key information from conversations, enabling truly personalized AI assistant experiences.

Fully managed RAG-as-a-service MCP. Index documents, PDFs, and data sources. Query knowledge bases with semantic search and structured extraction.

API development platform MCP for Postman. Run collections, manage environments, inspect API definitions, generate code snippets, and test API endpoints.

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.

Query OpenStreetMap geographic data via Overpass API. Find points of interest, analyze geographic features, and build location-aware applications.

Collect and query distributed traces, metrics, and logs using OpenTelemetry standards. Analyze application performance and correlate signals across services.

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

End-to-end testing MCP for Cypress. Run test suites, inspect test results, generate test code, and debug failing tests with AI-powered analysis.

JavaScript testing framework MCP for Jest. Run tests, analyze coverage, inspect failures, and generate test code. Works with React, Node, and TypeScript projects.

Next-generation unit testing framework MCP. Run Vitest tests, inspect coverage reports, snapshot testing, and debug failures in Vite-powered projects.

Python testing framework MCP for pytest. Run test suites, analyze failures, measure coverage with pytest-cov, and generate fixture-based test code.

Stagehand is the natural-language layer of the same server documented at /servers/browserbase — one endpoint, two search terms; read that page for session, proxy and stealth behaviour, and this one for how the instruction-following tools actually work. It is cloud browser automation driven by natural-language instructions rather than CSS selectors, running on Browserbase's hosted browsers via the Stagehand framework. The package name has changed and the old one is gone: `@browserbasehq/mcp-stagehand` is not on the npm registry, and the server that replaced it is published as @browserbasehq/mcp-server-browserbase (v2.4.3). Browserbase's own recommendation is to skip the local install entirely and use the hosted server at https://mcp.browserbase.com/mcp over streamable HTTP — they run it and cover the Gemini inference costs that Stagehand's instruction-following needs. Clients without HTTP transport can reach the same endpoint through `npx mcp-remote https://mcp.browserbase.com/mcp`. Six tools are exposed, and they map onto Stagehand's model rather than a raw browser API: start and end open and close a Browserbase session, navigate takes a URL, act performs an action described in plain language, observe returns the actionable elements on the current page so an agent can plan before it clicks, and extract pulls structured data out according to an instruction. The observe-then-act split is the reason this holds up better than selector-based automation on pages that change layout between runs. Worth knowing before you self-host: the browserbase/mcp-server-browserbase repository was archived on 2026-07-20 and its README now states it is retained for historical purposes and should not be treated as representative of Browserbase's current production service. The npm package still installs, but the hosted endpoint is the maintained path.

Headless CMS MCP for Sanity. Query and mutate content using GROQ, manage datasets, import/export content, and work with Sanity's schema-driven data.

Log aggregation MCP for Grafana Loki. Query log streams with LogQL, inspect labels, analyze error patterns, and correlate logs with metrics and traces.

Parse and monitor RSS and Atom feeds from any URL. Aggregate news, blog posts, and podcast feeds. Filter by keyword and track content changes over time.

Extract text, tables, and metadata from PDF documents via MCP. Parse multi-page documents, handle encrypted PDFs, and extract structured data for AI processing.

Excel MCP Server (by haris-musa, nearly 4,000 GitHub stars) lets AI agents create, read, and edit Excel workbooks without Microsoft Excel installed anywhere in the pipeline. It's a Python-based server exposing tools across the full spreadsheet lifecycle: creating and modifying workbooks and worksheets, writing formulas, building and styling Excel Tables, generating charts (line, bar, pie, scatter, and more), constructing dynamic pivot tables for analysis, and applying rich formatting — fonts, colors, borders, alignment, and conditional formatting rules. Built-in data validation keeps ranges, formulas, and cell contents consistent as an agent edits a file. The server supports three transports: stdio for local single-user setups (the default for Claude Desktop and Claude Code), plus SSE and streamable HTTP for remote deployments — when running remotely, set the EXCEL_FILES_PATH environment variable so the server knows where to read and write files, and FASTMCP_PORT to control the listening port. This makes it equally useful for a solo analyst automating a weekly report locally and for a team running a shared Excel-manipulation service that multiple agents call into. Because it operates on the raw XLSX format directly, there's no licensing dependency on Excel itself, and workflows like "pull this CSV into a formatted table with a pivot summary and a bar chart" become a single natural-language request instead of a manual multi-step process.

Google Sheets MCP Server (mcp-google-sheets by xing5, 900+ GitHub stars) is a Python-based bridge between MCP clients like Claude Desktop and the Google Sheets and Drive APIs, offering 19 tools covering the full spreadsheet workflow — creating and listing spreadsheets, reading and writing cell ranges, batch-updating multiple ranges at once, managing individual sheets within a workbook, applying cell formatting, and sharing files via Drive permissions. Authentication supports both Service Accounts (the recommended path for automated or headless agent workflows, configured with SERVICE_ACCOUNT_PATH and DRIVE_FOLDER_ID) and standard OAuth 2.0 for interactive per-user setups. The server runs via uvx with zero manual installation — uvx mcp-google-sheets@latest downloads and launches the latest version on demand, and using the @latest tag is recommended so bug fixes and new tools arrive automatically rather than running a stale cached build. Tool filtering via --include-tools or the ENABLED_TOOLS environment variable lets you expose only the operations a given agent needs, trimming context usage from the full ~13K-token toolset. This is the go-to integration for turning "pull last week's numbers into a new tab and format it as a table" or "update row 42 in the budget sheet" into a single conversational request instead of manual spreadsheet editing, and pairs naturally with Google Drive MCP for agents that need to locate a spreadsheet before editing it.

Create and edit Google Docs documents via MCP. Read document content, insert text, apply formatting, manage comments, and export to various formats.

Universal document converter MCP using Pandoc. Convert between Markdown, HTML, PDF, DOCX, LaTeX, and 40+ other formats with full pandoc options.

Search and retrieve Wikipedia articles via MCP. Fetch article summaries, full content, infoboxes, and categories. Access multilingual Wikipedia content.

Manage Google Calendar events and schedules via MCP. Create, update, and delete events, check availability, manage calendars, and set reminders via AI.

Access NASA's open APIs via MCP. Retrieve Astronomy Picture of the Day, Mars Rover photos, near-Earth object data, exoplanet archive, and earth observation imagery.

Make HTTP requests via MCP. GET, POST, PUT, DELETE with custom headers, authentication, cookies, and response parsing. Debug APIs and web services.

Build, test, and debug regular expressions via MCP. Match patterns, extract groups, validate formats, and explain regex syntax across multiple languages.

Encode, decode, and verify JSON Web Tokens via MCP. Inspect JWT claims, validate signatures, generate test tokens, and debug authentication issues.

Parse, transform, and render Markdown documents via MCP. Convert to HTML/PDF, lint formatting, extract headings and links, and validate CommonMark syntax.

Parse, validate, transform, and query YAML and JSON documents via MCP. Convert between formats, run JSONPath/JMESPath queries, and validate against schemas.

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

Parse and interact with OpenAPI/Swagger specifications via MCP. Explore API endpoints, generate client code, validate request/response schemas, and test APIs.

Execute GraphQL queries and mutations against any GraphQL API via MCP. Introspect schemas, explore types, run operations, and debug resolver performance.

Work with Protocol Buffer definitions via MCP. Parse .proto files, encode/decode messages, generate language bindings, and inspect gRPC service definitions.

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.

Direct integration with OpenAI API for accessing GPT-4o, o1, DALL-E, Whisper, and Embeddings. Useful for multi-model workflows, image generation, and text embedding pipelines.

Tableau MCP server for Tableau Cloud, Tableau Server and Tableau Desktop, published first-party by Tableau under Apache-2.0 and carrying the vendor's own "Tableau Supported" badge — one of the few analytics MCP servers that is not a community reimplementation. It ships three ways and the choice matters more than the install: a hosted server at mcp.tableau.com that uses OAuth 2.1 so every user signs in with their own Tableau Cloud identity and existing per-user permissions are enforced automatically; a self-hosted npm package, @tableau/mcp-server, run over stdio or HTTP for Tableau Server and for Cloud customers who need their own infrastructure; and a Docker/Heroku deployment for shared use. The web server exposes 43 tools across sixteen groups: datasource discovery and VizQL querying (list-datasources, get-datasource-metadata, query-datasource), workbook and view retrieval including rendered images (get-view-image, get-custom-view-image), Tableau Pulse metric definitions and generated insight briefs, Prep flow runs, extract-refresh tasks and jobs, user administration, Admin Insights queries, and MCP-Apps tools that render an interactive viz inside the client. A separate desktop build adds six authoring tools that read and apply workbook XML against a running Tableau Desktop instance. Self-hosted authentication is a Personal Access Token by default (PAT_NAME plus PAT_VALUE), with Connected App direct-trust JWT, user-attribute tokens and full OAuth 2.1 also supported. Requires Node.js 22.7.5 or later. Actively maintained — v4.6.0, last pushed August 2026.

Token-efficient MCP server for the entire Cloudflare API — 2,500+ endpoints in ~1K tokens via dynamic OpenAPI-driven tool generation. Covers DNS, Workers, R2, Zero Trust, Firewall, Images, Stream, Vectorize, Access, and every other Cloudflare product through two unified tools: search() and execute().

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.

Microsoft's official Playwright MCP server (35,900+ GitHub stars, npm `@playwright/mcp`) drives a real browser through Playwright's accessibility tree rather than screenshots, so it needs no vision model and its responses are structured text an LLM can act on deterministically. Requires Node.js 18+; `claude mcp add playwright npx @playwright/mcp@latest` is the whole install for Claude Code, and the same stdio block works in Cursor, Claude Desktop, Windsurf, Codex, Goose, VS Code, Copilot, Kiro and LM Studio. Roughly 70 tools ship across eight groups: core automation (browser_snapshot, browser_find, browser_click, browser_fill_form, browser_evaluate, browser_console_messages, browser_network_requests), tab management, and six opt-in capability groups behind --caps — network request mocking and offline simulation, cookie/localStorage/sessionStorage management, devtools tracing and video, coordinate-based mouse input via vision, PDF export, and testing assertions with browser_generate_locator and the verify_* tools. By default it runs headed with a persistent profile, so logins survive between sessions; that profile is keyed to the client workspace and can only be used by one browser instance at a time, so a second concurrent client needs --isolated or its own --user-data-dir. File-system access is restricted to workspace roots and file:// navigation is blocked unless --allow-unrestricted-file-access is passed, while --allowed-origins and --blocked-origins are explicitly documented as not a security boundary. Every CLI flag has a matching PLAYWRIGHT_MCP_* environment variable. Microsoft now points coding agents at the Playwright CLI with skills instead, on token-efficiency grounds, and recommends MCP for agentic loops that need persistent browser state.

Generate and deploy full-stack web apps via Bolt.new — StackBlitz's AI-powered WebContainer dev environment for instant in-browser project creation.

Repomix packs an entire repository — or a remote GitHub repo — into a single, AI-friendly file (XML, Markdown, or plain text) so an LLM can reason over a whole codebase inside one context window. Beyond the CLI it ships a built-in Model Context Protocol server: run `npx repomix --mcp` (or add that command to your MCP client config) and the assistant gets structured tools instead of raw shell output. The MCP tools include pack_codebase (package a local directory), pack_remote_repository (clone and pack any public GitHub URL on demand), read_repomix_output, file_system_read_file and file_system_read_directory — so a model can pull a dependency's source, grep a monorepo, or grab just the files it needs without you copy-pasting. Output is token-counted and can be compressed (Tree-sitter based code compression), secret-scanned (Secretlint), and filtered with include/ignore globs. Note: the npm package literally named `repomix-mcp` is an unrelated third-party wrapper (lotarcc); the maintained server is Repomix itself via its `--mcp` flag.

AI-powered codebase search and Q&A. Ask questions about any GitHub/GitLab repo in natural language.

Inngest serverless event-driven functions and background jobs — trigger, monitor, and manage workflows via MCP.

Val Town serverless JavaScript platform — create, run, schedule, and manage vals (functions) from your AI assistant.

DocuSign eSignature API — send envelopes, track signing status, retrieve signed documents, and manage templates from AI assistants.

Cloudinary media asset management — upload images/videos, apply transformations, manage CDN delivery, and search digital assets via the Cloudinary API.

a Python MCP server for Jenkins (lanbaoshen/mcp-jenkins, published to PyPI as mcp-jenkins) and the alternative to the official Jenkins MCP plugin: where the plugin has to be installed into the controller from the update centre, this one runs beside Jenkins and talks to it over the ordinary REST API, so you can point it at a Jenkins you do not administer. Install it with uvx mcp-jenkins, pip install mcp-jenkins, or the ghcr.io/lanbaoshen/mcp-jenkins container. Credentials go in as --jenkins-url, --jenkins-username and --jenkins-password (an API token works in place of the password), and on the HTTP transport the same three can be supplied per-connection as the x-jenkins-url, x-jenkins-username and x-jenkins-password headers, which is what lets one running instance serve several Jenkins controllers. Three transports are available via --transport: stdio (the default), sse, and streamable-http, which listens on 0.0.0.0:9887 unless --host and --port say otherwise. The tool set is wider than most Jenkins integrations. Jobs and pipelines: get_item, get_item_config, get_item_parameters, get_all_items, query_items for pattern search, and build_item to trigger. Builds: get_build, get_build_console_output, get_build_parameters, get_build_test_report, get_build_scripts, get_running_builds and stop_build, plus get_all_build_artifacts, get_build_artifact and get_build_artifact_url for pulling artifacts out of a finished run. Queue: get_all_queue_items, get_queue_item, cancel_queue_item. Agents: get_all_nodes, get_node, get_node_config. The plugin tools are the part with no equivalent elsewhere — get_all_plugins, get_plugin, get_plugins_with_updates, get_plugins_with_backup, get_plugin_dependency_graph (Graphviz output), and get_plugins_with_problems, which reports missing dependencies and version mismatches and turns a plugin upgrade audit into one question. Two flags matter for safety. run_groovy_script executes arbitrary Groovy on the controller, which is full remote code execution against your CI; --read-only disables it along with every other mutating tool and is the right default for an agent that only needs to read build state. --jenkins-timeout defaults to 5 seconds, which is often too short for a large get_all_items on a busy controller.

Manage secrets and environment configurations via the Doppler API — fetch secrets for any project, config, and environment; inject environment variables into local dev and CI/CD pipelines; sync secrets across staging, production, and review environments; manage access controls and service tokens; audit secret access logs; rotate API keys; and build automated secret management workflows.

Access Infisical open-source secrets management via their API — read and write secrets across projects and environments; manage secret folders, tags, and overrides; pull secrets for dynamic injection into apps and CI/CD; configure service tokens and machine identities; audit secret change history; sync with AWS Secrets Manager, Azure Key Vault, and GCP Secret Manager; and manage team permissions.

Kibo Commerce ships an official MCP server hosted directly on your own Kibo tenant, so AI assistants can query and mutate live commerce data — catalog, orders, carts, customers, inventory, pricing, shipping, and site settings — without a custom middleware layer. The endpoint follows the pattern https://{host}/mcp/admin/{toolCategories} on your tenant host (for example https://t1000000-s12345.sb.usc1.gcp.kibocommerce.com/mcp/admin/), with the tenant identifier and optional site identifier baked into the hostname; tenant-only URLs work for tenant-level operations, while site-scoped calls need the tenant-plus-site form. Because it is a hosted HTTP server there is no package to install: you add a url entry with an Authorization header to claude_desktop_config.json, .cursor/mcp.json, the Windsurf mcp_config.json, or VS Code Copilot settings. Authentication reuses your existing Kibo API credentials two ways: HTTP Basic with a Base64-encoded applicationKey:clientSecret pair from the Kibo Dev Center, or a short-lived JWT obtained from the Kibo OAuth endpoint at home.kibocommerce.com and sent as a Bearer token (roughly one hour, so your client needs refresh handling). The scale is the notable part — the default /mcp/admin/ path exposes over 500 operations, so Kibo lets you filter by appending comma-separated categories named {resource}.{operation}, such as products.read or categories.read,categories.update, which cuts both tool-discovery latency and the token cost of the tool list. Categories span Commerce Runtime (cart, checkout, order, quote, return, wishlist), Customer and B2B accounts, Product Admin (products, variations, price lists, discounts, search merchandizing and synonyms), Location and inventory, Shipping Admin, Pricing Runtime, and Import/Export. A separate documentation MCP server exists for querying Kibo docs. Debug tool calls with npx @modelcontextprotocol/inspector against the same URL.

Context7 is Upstash's documentation-retrieval MCP server, and it exists to solve one specific failure mode: a coding model answering from year-old training data, inventing APIs that were never shipped, or writing config for a package version you are not running. Instead of guessing, the agent calls Context7 and gets version-specific documentation and code examples pulled from the library's own source, injected straight into the prompt. In practice you append "use context7" to a request — "Create a Next.js middleware that checks for a valid JWT in cookies and redirects unauthenticated users to /login. use context7" — and the docs arrive before the code is written. The MCP surface is deliberately two tools. `resolve-library-id` turns a plain library name into a Context7-compatible ID, taking both a `libraryName` and the user's actual `query` so results can be ranked by relevance rather than string match. `query-docs` then fetches documentation for an exact ID such as `/vercel/next.js` or `/mongodb/docs`. You can skip the resolve step entirely by naming the ID in your prompt ("use library /supabase/supabase for API and docs"), and you can pin a version just by mentioning it ("How do I set up Next.js 14 middleware?"). Setup is a single command, `npx ctx7 setup`, which authenticates over OAuth, generates an API key and installs the integration; `--cursor`, `--claude` and `--opencode` target a specific agent, and `npx ctx7 remove` reverses it. Notably it ships in two modes: classic MCP, or a CLI-plus-Skills mode where the agent shells out to `ctx7 library` and `ctx7 docs` commands with no MCP server at all. To wire it manually, point your client at the hosted endpoint `https://mcp.context7.com/mcp` and pass your key as an `Authorization: Bearer` header — a free key from context7.com/dashboard mainly buys higher rate limits. Two honest caveats from Upstash's own README: the indexed library docs are community-contributed, so accuracy is not guaranteed and pages carry a Report button; and the public repo holds only the MCP server, while the API backend, parsing engine and crawling engine are private. Companion packages include the `ctx7` CLI, `@upstash/context7-sdk`, and Vercel AI SDK tool bindings.

MCP Inspector is the official developer tool for inspecting Model Context Protocol servers, published by the Model Context Protocol project itself, and it is what you reach for when a server will not connect, a tool schema comes back wrong, or an OAuth handshake fails somewhere you cannot see. It ships as a single npm package, `@modelcontextprotocol/inspector`, that exposes three clients behind one `mcp-inspector` binary: a web UI (Vite + React + Mantine over a Node backend, and the default), a scriptable CLI (`--cli`) meant for automation, CI and fast agent feedback loops, and an interactive terminal UI (`--tui`) built on Ink. So `npx @modelcontextprotocol/inspector` opens the web app, and adding `--cli` or `--tui` switches client without changing anything else about the invocation. The current published line is v2 (npm `latest` is 2.0.0, with the older line still reachable on the `v1-latest` tag); worth knowing before you read the source, the repository's `main` branch is the legacy v1 implementation on bug-fixes-only, while v2 development lives on `v2/main`. Node >= 22.19.0 is required. The CLI is the part most people underuse. `--method tools/list`, `resources/list` and `prompts/list` dump a server's whole surface without opening a browser, and `--method tools/call --tool-name mytool --tool-arg key=value` invokes one directly, with `--tool-arg 'options={"format": "json"}'` for JSON-valued arguments. It connects to a local server by command (`npx @modelcontextprotocol/inspector --cli node build/index.js`) and to a remote one by URL, where `--transport http` selects streamable HTTP (a bare URL defaults to SSE) and `--header "X-API-Key: your-key"` supplies auth. Servers can also come from a file: `--catalog` points at a writable catalog (default `~/.mcp-inspector/mcp.json`, or `MCP_CATALOG_PATH`) and `--config` at a read-only session, with `--server` selecting one entry — the two flags are mutually exclusive and neither combines with an ad-hoc target. A file-configured server also carries its own headers, connection and request timeouts, OAuth settings and `roots`, and the file is the only durable way to give a run its roots, which matters for servers like `@modelcontextprotocol/server-filesystem` that call `roots/list` to learn which directories they are allowed to touch. Remote connections honour the conventional `HTTPS_PROXY` / `HTTP_PROXY` / `NO_PROXY` variables through undici's EnvHttpProxyAgent, with no Inspector-specific flag needed.

Zerodha's official Kite MCP server puts India's largest retail brokerage behind an MCP endpoint, so an AI assistant can read market data, inspect a live portfolio and — with your own API keys — place orders through the Kite Connect API. The fastest path involves no installation at all: add `https://mcp.kite.trade/mcp` to your client config and authenticate through the `login` tool, which returns a browser authorization link. Zerodha runs the hosted server in hybrid mode, so both the Streamable HTTP `/mcp` endpoint and the legacy `/sse` endpoint are live; HTTP is the recommended one, and mcp-remote works for clients that only speak stdio. The tool surface covers most of Kite Connect. Market data: `get_quotes`, `get_ltp`, `get_ohlc`, `get_historical_data`, and `search_instruments` for resolving tradingsymbols. Portfolio and account: `get_profile`, `get_margins`, `get_holdings`, `get_positions`, and `get_mf_holdings` for mutual funds. Orders: `place_order`, `modify_order`, `cancel_order`, `get_orders`, `get_trades`, `get_order_history`, and `get_order_trades`. GTT (Good Till Triggered) orders get their own set — `get_gtts`, `place_gtt_order`, `modify_gtt_order`, `delete_gtt_order` — which is what makes conditional exits scriptable from a chat window. Large result sets like holdings, orders and trades paginate automatically. One limitation is important and easy to miss: the hosted server at mcp.kite.trade deliberately excludes the destructive trading tools. If you want an assistant that can actually place, modify or cancel orders, you must self-host. That means Go 1.21+, your own Kite Connect API key and secret in a `.env` file, and `go build -o kite-mcp-server`; `APP_MODE` selects stdio, http, sse or hybrid, `APP_PORT` and `APP_HOST` control the bind, and `PUBLIC_BASE_URL` sets the host used in browser-facing auth links. The same mechanism cuts the other way — `EXCLUDED_TOOLS` takes a comma-separated tool list, so setting `EXCLUDED_TOOLS=place_order,modify_order,cancel_order` gives you a genuinely read-only instance for analysis work. A self-hosted server also serves a status page and runtime docs on its root path.

This Bitbucket MCP server wraps the Bitbucket Cloud and Bitbucket Server REST APIs so an AI assistant can work a pull request end to end instead of just reading repository metadata. Its depth is in the PR lifecycle. Beyond `listRepositories` and `getRepository`, it exposes `getPullRequests`, `createPullRequest`, `getPullRequest` and `updatePullRequest`, then the review actions that usually force a browser tab: `approvePullRequest`, `unapprovePullRequest`, `requestChanges`, `removeChangeRequest`, `declinePullRequest` and `mergePullRequest`. Draft workflow is covered too — `createDraftPullRequest`, `publishDraftPullRequest`, `convertTodraft`. Comment handling is full CRUD plus thread state: `getPullRequestComments`, `addPullRequestComment`, `getPullRequestComment`, `updatePullRequestComment`, `deletePullRequestComment`, `resolveComment` and `reopenComment`, which is what lets an agent leave inline review notes and then mark threads resolved. For reading changes there are three distinct shapes — `getPullRequestDiff`, `getPullRequestDiffStat` and `getPullRequestPatch` — alongside `getPullRequestCommits`, `getPullRequestStatuses` and `getPullRequestActivity`. PR tasks/checklists get their own five tools, and Bitbucket Pipelines are wired in with `listPipelineRuns`, `getPipelineRun`, `runPipeline`, `stopPipeline`, `getPipelineSteps`, `getPipelineStep` and `getPipelineStepLogs`, so an agent can trigger a build and read back the failing step log. Install with `npx -y bitbucket-mcp@latest`. Configuration is environment-variable driven: `BITBUCKET_URL` (defaults to `https://api.bitbucket.org/2.0`), `BITBUCKET_WORKSPACE`, and either `BITBUCKET_TOKEN` or the `BITBUCKET_USERNAME` + `BITBUCKET_PASSWORD` pair. Two auth gotchas the maintainer calls out explicitly, because both produce 401s: the username is usually your email, and an Atlassian API token goes in `BITBUCKET_PASSWORD`, not `BITBUCKET_TOKEN`. App passwords need at least Repositories: Read, Pull requests: Read+Write, and Pipelines: Read. Destructive operations are gated behind `BITBUCKET_ENABLE_DANGEROUS=true` and off by default. This is a community project, not an Atlassian one. Atlassian does ship an official alternative — the Atlassian Rovo MCP Server added Bitbucket Cloud support — but its Bitbucket tools are available only via API-token authentication, not OAuth 2.1, and it is organization-admin-enabled through Admin Hub. Choose this server when you want local control and deep pipeline/PR-task coverage, the Rovo server when you need centrally governed enterprise access across Jira, Confluence and Bitbucket together.

The Memory Bank MCP server turns the Cline Memory Bank pattern into a centralized remote service accessible from any MCP client. Instead of storing project context in local files that get lost between sessions, this server exposes a structured multi-project memory system over the MCP protocol — read, write, update, and list memory bank files across isolated project directories. It enforces consistent file structure (projectBrief, activeContext, progress, systemPatterns, techContext, codebaseContext), prevents path traversal with strict validation, and keeps each project's context cleanly separated. Works seamlessly with Cline, Roo Code, Cursor, Windsurf, and Claude Desktop. Configure via the MEMORY_BANK_ROOT environment variable pointing to your central storage directory. Install with a single npx command; no backend infrastructure required beyond a shared filesystem. With 900+ GitHub stars and active community adoption, Memory Bank MCP is the standard for persistent AI coding context across sessions and IDE switches.

Task Master AI is the most widely-used AI-driven task management framework for software development, with 12,000+ GitHub stars and a purpose-built MCP server that plugs directly into Claude Desktop, Cursor, Windsurf, and any MCP-compatible coding agent. Created by eyaltoledano, it converts high-level project requirements into structured, dependency-tracked development tasks that an AI agent can plan, execute, and update autonomously across coding sessions. The MCP server exposes tools to initialize a project from a PRD or specification document, parse and break down complex tasks into subtasks, list all tasks with their status and dependencies, get next recommended task based on dependency resolution, mark tasks as in-progress or done, update task details and acceptance criteria, expand single tasks into subtasks with AI-generated breakdowns, and view the full task dependency graph. Task Master AI integrates tightly with Claude's extended thinking for complex planning and supports Perplexity for research-backed task breakdowns. Install globally via npm, then run `task-master init` to scaffold your project. Configure the MCP server in your client's JSON config pointing at the globally installed binary. Task Master AI dramatically improves autonomous coding agent quality by keeping Claude focused on the correct next task, preventing scope drift, and maintaining context across long multi-session projects.

MCP Shrimp Task Manager is an intelligent task management server built specifically for AI coding agents — emphasizing chain-of-thought planning, reflection, and style consistency across development sessions. It converts natural language project descriptions into structured, dependency-tracked development tasks with iterative refinement built in. Rather than treating tasks as a flat to-do list, Shrimp models tasks with explicit dependencies, execution state, and reasoning traces so the AI agent can pick up exactly where it left off across sessions. Supports Cursor, Roo Code, Windsurf, Claude Code, and any MCP-compatible client. Features include an optional GUI for visualizing task graphs, multi-language template support (English, Chinese, and more), configurable data directory, and a demo video showing end-to-end agent-driven development. With 2,100+ GitHub stars and a dedicated documentation site, Shrimp Task Manager is one of the most-starred agentic task management MCP servers available. Install by cloning the repo, running npm install + npm run build, and pointing your MCP client at the built index.js.

semantic, symbol-level code retrieval, editing, refactoring and debugging for coding agents — the tools an IDE has, exposed over MCP by Oraios. That distinction is the whole point of Serena: Most agents edit code by matching text and counting lines, which breaks the moment a file shifts; Serena operates on symbols and the relational structure between them, so a cross-file rename or a find-all-references is one atomic call instead of eight to twelve careful, error-prone steps. It connects over the Model Context Protocol to essentially any client — terminal agents like Claude Code, Codex, OpenCode and Gemini CLI, IDE assistants in VS Code, Cursor and JetBrains (Copilot, Junie, JetBrains AI Assistant), and desktop or web clients like Claude Desktop and OpenWebUI. Two interchangeable backends power the semantic layer. The default is free and open-source: an abstraction over Language Server Protocol servers, covering more than 40 languages including C/C++, C#, Go, Java, JavaScript, TypeScript, Python, Ruby, Rust, Swift, Kotlin, Scala, PHP, Elixir, Erlang, Haskell, Clojure, Dart, Lua, Terraform, Solidity, Zig and Lean 4. The alternative is the paid Serena JetBrains Plugin (free trial available), which drives your JetBrains IDE's own analysis engine and unlocks capabilities LSP cannot reach: move symbol/file/directory, inline, type hierarchy, dependency search inside external packages, propagating deletions to strip unused code, and an interactive debugging tool where the agent sets breakpoints, inspects variables and evaluates expressions through a persistent REPL-style interface. Note that CLion and Rider are not supported by the plugin. Retrieval tools cover find symbol, file outline, find referencing symbols, find declaration, find implementations and diagnostics; symbolic editing covers replace symbol body, insert before/after symbol and safe delete. A memory system carries project knowledge across sessions and can be disabled if you already use AGENTS.md. Install is uv-only and deliberately simple: `uv tool install -p 3.13 serena-agent`, then `serena init` to set up the backend (add `-b JetBrains` for the plugin), then configure a launch command in your client or run Serena in HTTP mode and hand the client a URL. One warning worth repeating from the maintainers: do not install Serena from an MCP or plugin marketplace, because those listings carry outdated and suboptimal install commands — follow the official quick start instead. Configuration is layered (global, CLI, per-project with local overrides, client-specific contexts, composable modes) so tool sets and prompts can be tuned per repo. Basic file, search and shell tools ship too but are usually disabled inside harnesses like Claude Code that already provide them.

IBM ContextForge is the reference open-source MCP gateway: a registry, proxy and control plane that sits in front of any number of MCP servers, A2A agents and plain REST/gRPC APIs and exposes them to your AI client as one endpoint. The distinction that matters when you are choosing a gateway is that ContextForge is not only a router — it also virtualizes non-MCP services, wrapping an existing REST or gRPC API as a "virtual" MCP server with registered tools, prompts and resources, and it can discover gRPC methods automatically through the server reflection protocol. That means you can put a gateway in front of internal services that will never ship an MCP server of their own. Federation is the second half of the story: multiple MCP and REST backends are combined behind a single unified interface, with Redis-backed caching and multi-cluster federation for Kubernetes deployments. Transports covered are HTTP, JSON-RPC, WebSocket, SSE with configurable keepalive, stdio and streamable HTTP, and you can pin the MCP protocol version (for example 2025-11-25) rather than inheriting whatever a client negotiates. Governance is the reason most teams reach for a gateway at all, and ContextForge ships the usual controls in-band: authentication with user-scoped OAuth tokens and X-Upstream-Authorization passthrough, retries, rate limiting, and an admin UI for real-time management, configuration and log monitoring — including an airgapped deployment mode. Observability is OpenTelemetry-native, exporting to Phoenix, Jaeger, Zipkin or any OTLP backend, so tool calls are traceable the same way the rest of your services are. A plugin system (40+ plugins at time of writing) covers additional transports, protocols and integrations, and there is TOON compression plus OpenAI-compatible and Anthropic agent routing for the A2A side. It is itself a fully compliant MCP server, so anything that speaks MCP can talk to it. Install from PyPI as mcp-contextforge-gateway (1.0.6 current) or run the ghcr.io/ibm/mcp-context-forge container; Apache-2.0, Python/FastAPI/asyncio.

Agentgateway is a Rust proxy for agentic traffic that covers three planes most MCP gateways treat separately: agent-to-tool (MCP), agent-to-agent (A2A) and agent-to-LLM. If you are comparing gateways, that LLM-gateway half is the differentiator — it routes to OpenAI, Anthropic, Gemini, Bedrock and other providers behind one OpenAI-compatible API with budget and spend controls, prompt enrichment, load balancing and failover, so the same proxy that governs your MCP tool calls also governs model spend. On the MCP side it does tool federation across many servers, speaks stdio, HTTP, SSE and streamable HTTP, integrates OpenAPI services, and handles OAuth against upstream servers. The A2A side adds capability discovery, modality negotiation and task collaboration between agents. Security and policy are where a proxy earns its place in the path: JWT, API-key and OAuth authentication, fine-grained RBAC driven by a CEL policy engine, rate limiting, TLS, and OpenTelemetry metrics, logs and traces. Guardrails are multi-layered and pluggable — regex filters, OpenAI moderation, AWS Bedrock Guardrails, Google Model Armor, or your own webhook — which is the control most teams discover they need only after an agent has already been handed production tools. There is also inference routing for self-hosted models via the Kubernetes Inference Gateway extensions, making decisions on GPU utilization, KV cache state, LoRA adapters and queue depth. Two deployment shapes are documented and they are genuinely different products in practice: a standalone mode driven by flat YAML config with no Kubernetes controller, and a Kubernetes mode using the built-in controller and Gateway API — pick before you start, because the docs split at that fork. A built-in web UI lets you inspect agent-to-agent and agent-to-tool connections live. Apache-2.0, written in Rust, and under active development, so check the release notes against the feature you are relying on.

The Docker MCP Gateway is the engine underneath Docker Desktop's MCP Toolkit, shipped as the docker-mcp CLI plugin. Its premise is containment: every MCP server from the Docker MCP Catalog runs inside its own Docker container rather than as a bare npx or uvx process on your machine, and the npx/uvx servers that do run get minimal host privileges. Your AI clients then all connect to one gateway endpoint instead of each maintaining its own server list, which is what keeps VS Code, Cursor and Claude Desktop on an identical tool configuration. Servers are grouped into profiles, and a profile can pull from four different source types in the same config — catalog references (catalog://mcp/docker-mcp-catalog/github), OCI image references (docker://my-server:latest), MCP Registry URLs (registry.modelcontextprotocol.io/v0/servers/<id>) and local files (file://./server.yaml). Profiles are first-class objects: docker mcp profile create --name dev-tools --server ... --connect cursor creates one and wires it to a client in a single command, and profiles can be exported to YAML or pushed and pulled from OCI registries, so a team can version its tool set the way it versions images. Per-server configuration is set with docker mcp profile config <id> --set github.timeout=30. Secrets are the other reason to run this rather than raw stdio servers: API keys live in Docker Desktop's secrets management instead of environment variables in a JSON config file, and built-in OAuth flows handle servers that need token-based service connections. Dynamic discovery picks up tools, prompts and resources from running servers, and there is built-in logging and call tracing. Prerequisites are Docker Desktop 4.59+ with the MCP Toolkit feature enabled; the plugin can also run independently of Desktop — set DOCKER_MCP_IN_CONTAINER=1 to bypass the Desktop backend checks under WSL2, Docker CE or containerized environments, and enable profiles explicitly with docker mcp feature enable profiles, since that only auto-enables inside Desktop. MIT-licensed Go.

MetaMCP aggregates any number of MCP servers into one unified MCP server, and because the aggregate is itself a compliant MCP server it plugs into any client without special support. The organising concept is the namespace: you group server configurations into a namespace, host that namespace as a single meta-server, and expose it at a public endpoint over SSE or streamable HTTP with auth in front. Switching which namespace an endpoint serves is one click, so a client config written once can be repointed at a different tool set without touching the client. Within a namespace you choose which tools to surface rather than inheriting everything upstream offers, and tool overrides and annotations let you rename or re-describe a tool so a model picks it correctly — useful when two upstream servers both ship a search. A middleware layer wraps the aggregated traffic for observability and security concerns. Server configs are ordinary Claude-Desktop-shaped JSON with STDIO, SSE and streamable-HTTP types, and secrets for stdio servers are managed as environment variables in MetaMCP rather than in client config files. A built-in inspector — effectively MCP Inspector with saved server configs — lets you test both individual upstream servers and your own MetaMCP endpoints from inside the app. Operationally it ships as a single Docker Compose stack: clone the repo, cp example.env .env, docker compose up -d. Watch two things there. It enforces a CORS policy against APP_URL, so if you change that variable the app is only reachable from that exact URL; and the Postgres volume name is global, so rename metamcp_postgres_data in docker-compose.yml if you already run another Postgres container. Authentication covers API keys and OpenID Connect against standard providers, with registration controls for enterprise deployments, plus per-endpoint MCP rate limiting. There is a cold-start cost when stdio servers are launched on demand — the docs cover baking them into a custom Dockerfile to avoid it. MIT-licensed TypeScript. The maintainer has publicly flagged review delays and now merges AI-assisted changes on the ai-dev branch, so test an image built from that branch before relying on it; a community fork exists.

This is the smallest useful thing in the gateway category: a single Go binary that aggregates several MCP servers behind one HTTP entrypoint, with no database, no web UI and no control plane to operate. Tools, prompts and resources from every configured downstream server are merged and served over SSE or streamable HTTP, and downstream clients can be stdio, sse or streamable-http, so it is also the standard way to put a stdio-only server on the network for clients that cannot spawn processes. The feature worth choosing it for is OAuth client support: you authorize once against a downstream server that requires an interactive OAuth flow — Notion is the example the project gives — and the proxy then holds and refreshes that token on behalf of every caller, which removes the per-user browser dance that otherwise blocks headless and shared deployments. Configuration is a single JSON file; an online converter at tbxark.github.io/mcp-proxy turns an existing Claude Desktop config into the proxy's format, so migrating an existing client setup takes a paste rather than a rewrite. Three install paths are documented: build from source with make build, go install github.com/tbxark/mcp-proxy@latest, or the container at ghcr.io/tbxark/mcp-proxy:latest, which is the one most people want because the image bundles npx and uvx and can therefore launch Node and Python MCP servers itself. The container accepts either a mounted config file or a remote config URL passed with --config, which makes a fleet of proxies configurable from one hosted file. Docker Compose examples are in the deployment docs, and command-line flags, endpoint paths and auth examples in the usage docs. MIT-licensed, inspired by adamwattis/mcp-proxy-server. Deliberately not what MetaMCP, ContextForge or Obot are — there is no RBAC, no audit store and no namespace model here, so if you need governance rather than plumbing, start with one of those instead.

mcp-remote is the piece of glue that appears in more MCP install instructions than almost any other package, and it exists because of one gap: most MCP clients still only speak stdio, while a growing number of vendors now ship remote servers behind OAuth. Point a client at a remote URL through mcp-remote and it runs the full authorization flow for you — opening a browser once, storing the tokens under ~/.mcp-auth, refreshing them silently afterwards — then presents the remote server to the client as an ordinary local stdio process. That is why the config snippets published by Linear, Cloudflare, Intercom, PostHog, Render, Webflow, Browserbase and Tavily all fall back to npx mcp-remote <url> for clients without native HTTP transport. Beyond auth it handles the practical details of that bridge: --header for static bearer tokens or custom headers when you want to skip OAuth entirely, --resource to keep separate OAuth sessions for two tenants of the same vendor (the documented Atlassian case), a positional port argument and --host to control where the OAuth callback lands, --allow-http for plaintext services inside a trusted network, --enable-proxy to honour HTTP_PROXY/HTTPS_PROXY/NO_PROXY, and --debug to write a verbose auth trace per server hash. Two known client bugs are worth reading the README for before you file an issue: Cursor and Claude Desktop on Windows mangle spaces inside args, so headers should be written without a space after the colon and the value moved into an env var. The author frames the project as an explicitly temporary proof of concept — the intent is that you delete it once your client supports remote authorized servers natively — and the npm package has sat at 0.1.38 since February 2026, so treat it as stable and widely relied upon rather than actively developed.

sparfenyuk/mcp-proxy is the most-starred transport bridge in the ecosystem and the one to reach for when the bridging job runs in both directions. Mode one is stdio-to-SSE/Streamable-HTTP: the client launches mcp-proxy as an ordinary local command, passes a remote endpoint URL as the first argument, and the proxy relays the session onwards — the classic way to attach Claude Desktop to a server it cannot reach natively. Add --transport=streamablehttp when the upstream uses the newer transport, --headers Authorization "Bearer ..." (or the API_ACCESS_TOKEN environment variable) for static auth, and --client-id / --client-secret / --token-url when the upstream expects an OAuth2 client-credentials exchange rather than a static token — that last one is the feature most of the alternatives do not have. Mode two runs the other way: give it --sse-port and a command after the -- separator, and it spawns a local stdio server and exposes it over the network, which is how you put an npx- or uvx-only server behind a URL that other machines, containers or hosted agents can reach. Named servers let one process front several stdio commands on distinct paths, so a single container can publish a whole toolset. It installs from PyPI as mcp-proxy (0.12.0, Python 3.10+), runs equally well via uvx, and ships a container image documented for extension — the README shows layering your own uvx/npx dependencies into it and a Docker Compose setup, which is the shape most self-hosted deployments end up using. Actively maintained, MIT licensed, last pushed July 2026.

Supergateway converts an MCP server between every transport pair anyone actually asks for, in one command and with no config file. Running npx -y supergateway --stdio "uvx mcp-server-git" exposes a stdio server over SSE on port 8000; swapping --outputTransport streamableHttp publishes it at /mcp instead, --outputTransport ws publishes a WebSocket endpoint, and pointing --sse or --streamableHttp at a remote URL runs the bridge backwards, presenting a hosted server to a stdio-only client. Stateful mode with --sessionTimeout is available for streamable HTTP when you need session continuity, and stateless is the default. The operational flags are the reason it shows up in so many container deployments: --cors accepts a bare flag for any origin, explicit origins, or a regex; --healthEndpoint /healthz registers liveness paths for an orchestrator; --header can be repeated for arbitrary headers and --oauth2Bearer sets an Authorization header in one argument; --logLevel none keeps a noisy bridge out of your logs. WebSocket output is the genuinely distinguishing capability here — the other proxies in this category cover stdio, SSE and streamable HTTP but not WS. One caveat to weigh before you standardise on it: the repository was last pushed in October 2025 and npm has sat at 3.4.3 since, so it predates parts of the current transport guidance and will not pick up spec changes. It is stable and still widely used, but for a new deployment that needs ongoing maintenance the Python and TypeScript mcp-proxy projects are the actively developed alternatives.