---
title: "Best MCP servers for developers: official servers by category"
description: "The best MCP servers for developers: 15 official servers from GitHub, Microsoft, Sentry, Stripe, AWS, and more, with transport, auth, and Claude Code setup."
summary: "This list covers 15 official MCP servers from GitHub, Microsoft, Supabase, Sentry, Linear, AWS, Stripe, and other developer services, grouped by category. Each entry gives the tools, maintainer, transport, auth, and scope controls, followed by setup steps for Claude Code, Cursor, and VS Code."
type: "comparison"
canonical_url: "https://theaiengineering.com/articles/best-mcp-servers"
markdown_url: "https://theaiengineering.com/articles/best-mcp-servers.md"
topic: "Model Context Protocol"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-11-19"
updated: "2026-11-19"
keywords: ["best mcp servers","mcp server list","claude code mcp","mcp servers"]
citation: "The AI Engineering Editors. \"Best MCP servers for developers: official servers by category.\" The AI Engineering, updated Nov 19, 2026. https://theaiengineering.com/articles/best-mcp-servers"
---

# Best MCP servers for developers: official servers by category

## TL;DR

- The most useful MCP servers for software engineers are official ones maintained by the vendor of the underlying service, such as GitHub's MCP server, Microsoft's Playwright MCP, Sentry's remote server, and Stripe's server at mcp.stripe.com.
- Most vendor MCP servers now run remotely over Streamable HTTP with OAuth sign-in, while browser servers and self-managed database servers run locally as stdio subprocesses.
- Most servers that can write data offer a way to narrow access, such as GitHub's /readonly URL, Supabase's read_only and project_ref parameters, Linear's /mcp/readonly endpoint, and MongoDB's --readOnly flag.
- In Claude Code, claude mcp add --transport http <name> <url> adds a remote server, a -- separator passes a local server's own command, and --scope project writes a shared .mcp.json file.
- The official MCP Registry at registry.modelcontextprotocol.io lists server metadata under verified namespaces such as com.stripe and io.github.github, and it was still in preview in November 2026.

An [MCP server](https://theaiengineering.com/glossary/mcp-server) is a program that exposes a service's tools and data to AI applications through the [Model Context Protocol](https://theaiengineering.com/glossary/model-context-protocol), and the best MCP servers for developers are the official ones that vendors maintain for their own services. This list covers 15 of them, grouped by the job they do on a software team: code hosting, browsers, documentation, databases, errors, issue tracking, cloud, payments, and web search. A summary table comes first, each entry then gives the same five facts (what it does, who maintains it, transport and auth, best use, and the access to watch), and the last sections cover setup in Claude Code, Cursor, and VS Code, plus security. For background on the protocol itself, start at the [MCP topic hub](https://theaiengineering.com/topics/mcp).

## Selection criteria

Every server here is maintained by the company that runs the underlying service, was actively developed in 2026, documents its transport and authentication, and does a job a software engineer needs during development or operations. We checked each server's repository or documentation in November 2026 and left out community wrappers, archived projects, and servers without a stated auth model.

- **Vendor-maintained.** The repository or docs page belongs to the service's own organization; popular community servers for the same service are excluded.
- **Active in 2026.** Open-source servers had commits in November 2026, and hosted servers have current vendor documentation.
- **Stated transport and auth.** Remote servers run over Streamable HTTP (an [MCP transport](https://theaiengineering.com/glossary/mcp-transport)) and name their sign-in method; local servers run over stdio and name the credentials they read.
- **Narrowable access.** Servers with read-only modes, scoping parameters, or permission selection at sign-in were preferred.

The MCP project's reference servers, such as Filesystem, Git, and Fetch, are left out because the [servers repository](https://github.com/modelcontextprotocol/servers) calls them educational examples rather than production-ready solutions. Former reference servers for GitHub, Brave Search, and Sentry were archived, and those vendors now maintain their own.

## MCP server list: summary table

The table lists all 15 servers with their maintainer, where they run, how they authenticate, and their category, based on each vendor's repository or documentation as of November 2026. "Remote" means a vendor-hosted Streamable HTTP endpoint, and "local" means a process on your machine, usually over stdio. Several servers offer both.

| Server | Maintainer | Remote or local | Auth | Category |
|---|---|---|---|---|
| [GitHub MCP Server](https://github.com/github/github-mcp-server) | GitHub | Both: `api.githubcopilot.com/mcp/` or Docker image | OAuth or personal access token | Code hosting |
| [Playwright MCP](https://github.com/microsoft/playwright-mcp) | Microsoft | Local (stdio; HTTP with `--port`) | None (local browser) | Browsers and testing |
| [Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) | Chrome DevTools (Google) | Local (stdio) | None (local Chrome) | Browsers and testing |
| [Context7](https://github.com/upstash/context7) | Upstash | Both: `mcp.context7.com/mcp` or `@upstash/context7-mcp` | Optional API key | Documentation |
| [Microsoft Learn MCP Server](https://github.com/MicrosoftDocs/mcp) | Microsoft | Remote: `learn.microsoft.com/api/mcp` | None | Documentation |
| [Supabase MCP](https://supabase.com/docs/guides/getting-started/mcp) | Supabase | Remote: `mcp.supabase.com/mcp` (subset in the local CLI) | OAuth 2.1 | Databases and backends |
| [MongoDB MCP Server](https://www.mongodb.com/docs/mcp-server/overview/) | MongoDB | Both: `mongodb-mcp-server` or Atlas-managed `mcp.mongodb.com` | Connection string; OAuth when managed | Databases and backends |
| [Sentry MCP](https://mcp.sentry.dev/) | Sentry | Both: `mcp.sentry.dev/mcp` or `sentry mcp` | OAuth; CLI login locally | Observability and errors |
| [Linear MCP](https://linear.app/docs/mcp) | Linear | Remote: `mcp.linear.app/mcp` | OAuth 2.1 or API key | Issue tracking |
| [Atlassian Rovo MCP Server](https://developer.atlassian.com/cloud/rovo-mcp/) | Atlassian | Remote: `mcp.atlassian.com/v2/mcp` | OAuth 2.1 or API token | Issue tracking and docs |
| [Notion MCP](https://developers.notion.com/guides/mcp/get-started-with-mcp) | Notion | Remote: `mcp.notion.com/mcp` | OAuth or MCP token | Team docs |
| [AWS MCP Server](https://aws.amazon.com/blogs/aws/the-aws-mcp-server-is-now-generally-available) | AWS | Remote, through a local signing proxy | AWS IAM (SigV4) | Cloud |
| [Cloudflare API MCP server](https://github.com/cloudflare/mcp) | Cloudflare | Remote: `mcp.cloudflare.com/mcp` | OAuth or API token | Cloud |
| [Stripe MCP](https://docs.stripe.com/mcp) | Stripe | Remote: `mcp.stripe.com` | OAuth or agent API key | Payments |
| [Exa MCP](https://github.com/exa-labs/exa-mcp-server) | Exa | Both: `mcp.exa.ai/mcp` or `exa-mcp-server` | None, OAuth, or API key | Web search |

## Local vs remote MCP servers

A local MCP server runs as a subprocess on your machine, talks to the host over stdio, and reads credentials from environment variables. A remote server runs on the vendor's infrastructure, takes requests over Streamable HTTP, and usually signs you in with OAuth. Most servers on this list are remote; browser and self-managed database servers are the exceptions.

**Figure 1: Local MCP servers run as subprocesses with credentials from the environment; remote servers run at the vendor and authenticate with OAuth or a key.**

A coding agent host connects to two local servers over stdio on the developer's machine and to two vendor-hosted servers over Streamable HTTP with tokens.

Components:

- **MCP host**: Claude Code, Cursor, or VS Code
- **Playwright MCP**: stdio subprocess local browser
- **MongoDB MCP**: stdio subprocess keys in env vars
- **GitHub MCP**: Streamable HTTP OAuth or PAT
- **Stripe MCP**: Streamable HTTP OAuth or agent key
- **Browser**: on your machine
- **Database**: local or Atlas
- **GitHub API**
- **Stripe API**

Groups:

- Local: Playwright MCP, MongoDB MCP, Browser
- Remote: GitHub MCP, Stripe MCP, GitHub API, Stripe API

Connections:

- MCP host → Playwright MCP: stdio
- MCP host → MongoDB MCP: stdio
- MCP host → GitHub MCP: HTTPS
- MCP host → Stripe MCP: HTTPS
- Playwright MCP → Browser
- MongoDB MCP → Database
- GitHub MCP → GitHub API
- Stripe MCP → Stripe API

The split decides where credentials live. A remote server's OAuth token is issued for that server and can be revoked from the vendor's settings or your client. A local server inherits whatever its environment holds, so one broad token in an environment variable gives every tool call the same reach. Either way, the model still emits ordinary [tool calls](https://theaiengineering.com/glossary/tool-calling), as the [MCP explainer](https://theaiengineering.com/articles/what-is-model-context-protocol) describes.

## Code hosting: GitHub MCP Server

GitHub's official MCP server gives an agent access to repositories, issues, pull requests, and Actions, either through a GitHub-hosted remote endpoint or a local Docker container. The MCP project archived its own GitHub reference server, and GitHub's server groups tools into toolsets that you can switch on individually to keep the agent's tool list short.

### GitHub MCP Server

- **What it does:** Reads and writes repositories, issues, pull requests, and users. Default toolsets are `context`, `repos`, `issues`, `pull_requests`, and `users`; `actions`, `code_security`, `dependabot`, and others are opt-in.
- **Maintainer:** [GitHub](https://github.com/github/github-mcp-server), MIT license; v2.1.0 shipped on November 3, 2026.
- **Transport and auth:** Remote at `https://api.githubcopilot.com/mcp/` over Streamable HTTP, with OAuth in hosts that register a GitHub App, such as VS Code, or a personal access token (PAT) in an `Authorization` header elsewhere. Locally it runs over stdio from the `ghcr.io/github/github-mcp-server` Docker image, with a PAT or a browser login.
- **Best for:** Reviewing pull requests, triaging issues, reading code across repositories, and checking CI runs.
- **Caution:** A broad token exposes every repository it can reach, so use a fine-grained one. Append `/readonly` to the remote URL or pass `--read-only` locally, and pick toolsets with `/x/{toolset}` or the `X-MCP-Toolsets` header. The `X-MCP-Lockdown` header hides public issue content from users without push access, which GitHub calls a best-effort filter, not a security boundary.

## Browsers and testing: Playwright MCP and Chrome DevTools MCP

Two official browser servers cover front-end work: Microsoft's Playwright MCP automates pages through accessibility snapshots, and Google's Chrome DevTools MCP exposes DevTools data such as performance traces, network requests, and console logs. Both run locally, control a real browser, and need no account, which makes the browser profile the main thing to protect.

### Playwright MCP

- **What it does:** Automates a browser through Playwright and reads pages through the accessibility tree rather than pixels, so no vision model is needed. Tools include `browser_navigate`, `browser_snapshot`, `browser_click`, and `browser_take_screenshot`; `--caps` adds vision, PDF, and DevTools capabilities.
- **Maintainer:** [Microsoft](https://github.com/microsoft/playwright-mcp), Apache 2.0; v0.0.85 shipped on November 9, 2026.
- **Transport and auth:** Local: `npx @playwright/mcp@latest` runs over stdio, and `--port` switches to HTTP. It has no auth of its own. By default it uses a persistent browser profile that keeps logins between sessions; `--isolated` keeps the profile in memory.
- **Best for:** Reproducing UI bugs, checking a page after a change, and drafting Playwright tests from a live page.
- **Caution:** The README says Playwright MCP is not a security boundary, and neither is `--allowed-origins`. Real logins in a persistent profile become the agent's sessions, so prefer `--isolated`. For coding agents, the README notes that Playwright's CLI with skills can be more token-efficient.

### Chrome DevTools MCP

- **What it does:** Records performance traces and extracts insights, analyzes network requests, reads console messages with source-mapped stack traces, navigates pages, and takes screenshots. `--slim` exposes a reduced tool set for basic browsing.
- **Maintainer:** The [ChromeDevTools organization](https://github.com/ChromeDevTools/chrome-devtools-mcp) on GitHub, Apache 2.0; v1.13.0 shipped on November 11, 2026.
- **Transport and auth:** Local over stdio with `npx -y chrome-devtools-mcp@latest`, and no auth; `--isolated` and `--headless` control the browser instance.
- **Best for:** Debugging layout, network, and page-load performance problems with the data a developer would read in DevTools.
- **Caution:** The server exposes the browser's content to the MCP client, so keep personal data out of that browser. Usage statistics go to Google by default (`--no-usage-statistics` turns them off), and performance tools may send trace URLs to the Chrome UX Report API unless you pass `--no-performance-crux`.

## Documentation: Context7 and Microsoft Learn

Documentation servers give a model current API references at query time, so it is less likely to write code against outdated library versions. Context7 covers many open-source libraries through community-contributed entries, while vendor docs servers such as Microsoft Learn return only the vendor's official documentation. Both are read-only, which makes them the lowest-risk servers on this list.

### Context7

- **What it does:** Returns current documentation and code examples for libraries. It has two tools: `resolve-library-id` finds a library, and `query-docs` fetches the relevant snippets.
- **Maintainer:** [Upstash](https://github.com/upstash/context7), MIT license.
- **Transport and auth:** Remote at `https://mcp.context7.com/mcp`, or local through the `@upstash/context7-mcp` package. An API key, sent as a bearer token, is optional and raises rate limits. Upstash also offers a CLI-plus-skills mode (`npx ctx7 setup`) that skips MCP entirely.
- **Best for:** Fast-moving frameworks and SDKs whose APIs changed after the model's training cutoff.
- **Caution:** Context7's README says library entries are community-contributed and that it cannot guarantee their accuracy, completeness, or security. Treat returned snippets as untrusted input, like any web content.

### Microsoft Learn MCP Server

- **What it does:** Searches and fetches official Microsoft documentation and code samples with three tools: `microsoft_docs_search`, `microsoft_docs_fetch` (which returns a page as Markdown), and `microsoft_code_sample_search`.
- **Maintainer:** [Microsoft](https://github.com/MicrosoftDocs/mcp), through the MicrosoftDocs organization on GitHub.
- **Transport and auth:** Remote at `https://learn.microsoft.com/api/mcp` over Streamable HTTP, with no API key, login, or sign-up. The `@microsoft/learn-cli` package gives terminal access to the same three capabilities.
- **Best for:** Azure, .NET, and Microsoft 365 work where a model's knowledge of service names and SDK versions is out of date.
- **Caution:** It is read-only and covers only Microsoft content. Its OpenAI-compatible endpoint and `maxTokenBudget` parameter are marked experimental and subject to change.

## Databases and backends: Supabase and MongoDB

Database servers let an agent inspect schemas, run queries, and apply migrations, so they carry the most risk of any category here. Supabase and MongoDB both maintain official servers with read-only modes and scoping controls. Neon runs a comparable remote server at `mcp.neon.tech/mcp` with a `readonly=true` option, though Neon does not recommend using it in production environments.

### Supabase MCP

- **What it does:** Manages Supabase projects: `list_tables`, `execute_sql`, and `apply_migration` for the database, `deploy_edge_function` for Edge Functions, `query_logs` for debugging, `search_docs`, and `create_branch` for development branches. Tools are grouped into feature groups such as database, debugging, development, docs, branching, and storage.
- **Maintainer:** [Supabase](https://github.com/supabase/mcp), Apache 2.0; v0.17.0 shipped on November 13, 2026.
- **Transport and auth:** Remote at `https://mcp.supabase.com/mcp` with an OAuth 2.1 login. The Supabase CLI serves a subset of tools at `http://localhost:54321/mcp` for local development, without OAuth.
- **Best for:** Schema changes, migrations, Edge Functions, and log-driven debugging on Supabase projects.
- **Caution:** The server runs with your developer permissions, and Supabase warns that data such as a support ticket can carry prompt injection into SQL queries. Scope it with `project_ref`, add `read_only=true` for unattended work, limit `features`, test changes on a branch, and never give the server to end users.

### MongoDB MCP Server

- **What it does:** Queries and manages MongoDB data and Atlas: `find`, `aggregate`, `count`, and `export` for data, `atlas-list-clusters` and `atlas-create-cluster` for infrastructure, and `atlas-get-performance-advisor` for query and index advice.
- **Maintainer:** [MongoDB](https://github.com/mongodb-js/mongodb-mcp-server), Apache 2.0; v3.3.0 shipped on November 9, 2026.
- **Transport and auth:** The local server (`npx -y mongodb-mcp-server@latest`) runs over stdio or HTTP and reads a connection string from `MDB_MCP_CONNECTION_STRING`. The Atlas Managed MCP Server, generally available since August 13, 2026, runs at `https://mcp.mongodb.com` with OAuth through Atlas and works only with Atlas deployments.
- **Best for:** Exploring schemas, writing aggregation pipelines against real data, and checking cluster performance.
- **Caution:** Start the local server with `--readOnly`, which allows only read, connect, and metadata operations, or block tools with `--disabledTools`. Its HTTP mode has no built-in authentication and is meant for localhost. On the managed server, AI client access is off by default for each organization, and the read-only flag is on by default.

## Observability and errors: Sentry MCP

Sentry's MCP server lets an agent read the issues, stack traces, traces, and logs a developer opens when debugging production errors, then propose a fix in the editor. Sentry hosts it as a remote OAuth server and also ships it inside the Sentry CLI for local and self-hosted use, with tools grouped into skills that you can enable or disable.

### Sentry MCP

- **What it does:** Groups tools into skills (`inspect`, `seer`, `triage`, and `project-management`), with natural-language search tools such as `search_issues`, `search_errors`, `search_traces`, and `search_logs` that translate questions into Sentry queries.
- **Maintainer:** [Sentry](https://mcp.sentry.dev/); the code lives in the `getsentry/toolkit` repository alongside the Sentry CLI.
- **Transport and auth:** Remote at `https://mcp.sentry.dev/mcp` with OAuth. Appending slugs (`/mcp/{organizationSlug}/{projectSlug}`) scopes the connection to one organization or project. Locally, `sentry mcp` runs the same server over stdio after `sentry auth login`, and setting `SENTRY_HOST` points it at self-hosted Sentry.
- **Best for:** Fixing production errors from the stack trace and checking whether a deploy introduced new issues.
- **Caution:** Sentry recommends project scoping where possible. Drop skills you don't need with `?disable-skills=` on the remote URL or `--disable-skills` locally, for example `project-management`.

## Issue tracking and team docs: Linear, Atlassian, and Notion

Linear, Atlassian, and Notion each run a hosted, remote MCP server with OAuth sign-in, so there is nothing to install or update locally. They give agents the context that lives outside the repository: tickets, specs, runbooks, and decisions. Each one acts with the signed-in user's permissions, so the agent can see and change whatever that user can.

### Linear MCP

- **What it does:** Finds, creates, and updates Linear issues, projects, and comments.
- **Maintainer:** [Linear](https://linear.app/docs/mcp), as a hosted service.
- **Transport and auth:** Remote at `https://mcp.linear.app/mcp` over Streamable HTTP, with OAuth 2.1 and dynamic client registration, or an OAuth token or API key in an `Authorization: Bearer` header. The `/sse` endpoint remains only as a deprecated fallback.
- **Best for:** Turning an issue into a branch and pull request, and keeping issue status in step with the code.
- **Caution:** The default endpoint is read-write. When the agent only needs context, use `https://mcp.linear.app/mcp/readonly`, request only the `read` OAuth scope, or create an API key with only the Read permission.

### Atlassian Rovo MCP Server

- **What it does:** Connects Jira, Confluence, Jira Service Management, Bitbucket Cloud, Compass, Loom, and other Atlassian apps. The v2 endpoint exposes a `discover` tool that clients use to find the rest of the tool catalog on demand.
- **Maintainer:** [Atlassian](https://developer.atlassian.com/cloud/rovo-mcp/), as a hosted service.
- **Transport and auth:** Remote at `https://mcp.atlassian.com/v2/mcp`, which Atlassian recommends for new setups, with OAuth 2.1 or an API token for headless use; Jira Service Management takes API tokens only, and Compass takes OAuth only. The legacy `/v1/sse` endpoint lost support after June 30, 2026.
- **Best for:** Teams on Jira and Confluence that want agents to read specs, update tickets, and link work to code.
- **Caution:** Access matches what the user can already see in Atlassian Cloud. Admins can restrict which AI tools connect with domain controls and IP allowlisting, and tool usage appears in audit logs. Some tools consume Rovo credits, and Atlassian says most calls cost 1 to 10 credits.

### Notion MCP

- **What it does:** Searches a workspace, fetches pages, creates and edits pages, and manages databases and views.
- **Maintainer:** [Notion](https://developers.notion.com/guides/mcp/get-started-with-mcp), as a hosted service.
- **Transport and auth:** Remote at `https://mcp.notion.com/mcp` over Streamable HTTP with OAuth. On Business and Enterprise plans, a workspace owner can create MCP tokens that clients send as a bearer token, with no browser sign-in. The legacy SSE endpoint retires on February 23, 2027.
- **Best for:** Pulling specs, runbooks, and meeting notes into a coding session, and writing results back.
- **Caution:** The agent can read and edit anything you can access in the selected workspace. Notion's open-source `notion-mcp-server` is no longer actively maintained, and Notion's guide calls it a last resort.

## Cloud platforms: AWS and Cloudflare

AWS and Cloudflare have both moved from many product-specific servers to one managed server that covers their whole API. Instead of a tool per endpoint, each offers a few generic tools that can call any API operation, which keeps tool definitions small but means the credential's permissions, not the tool list, define what the agent can do.

### AWS MCP Server

- **What it does:** Offers a small, fixed tool set: `call_aws` runs any of more than 15,000 AWS API operations, `run_script` runs short Python scripts in a sandbox with no network access, and `search_documentation` and `read_documentation` retrieve current AWS docs. AWS service teams maintain Agent Skills for it.
- **Maintainer:** [AWS](https://aws.amazon.com/blogs/aws/the-aws-mcp-server-is-now-generally-available); generally available since May 6, 2026, with no additional charge for the server itself.
- **Transport and auth:** Remote and managed, with endpoints in N. Virginia (`https://aws-mcp.us-east-1.api.aws/mcp`) and Frankfurt. MCP Proxy for AWS, an open-source proxy run locally with `uvx mcp-proxy-for-aws@latest`, signs requests with your IAM credentials, and CloudTrail records the calls.
- **Best for:** Inspecting and changing AWS resources without installing a server per service.
- **Caution:** `call_aws` and `run_script` can do anything the IAM principal can, so use a dedicated role and IAM or service control policies to keep it read-only where possible. The [awslabs/mcp](https://github.com/awslabs/mcp) repository still publishes local stdio servers per service, and AWS names the Agent Toolkit for AWS as their successor.

### Cloudflare API MCP server

- **What it does:** Covers the Cloudflare API with Code Mode: the model writes JavaScript for a `search` tool that queries the OpenAPI spec and an `execute` tool that calls the endpoints it found, and the code runs in isolated Workers. A `docs` tool searches Cloudflare's developer documentation.
- **Maintainer:** [Cloudflare](https://github.com/cloudflare/mcp), Apache 2.0.
- **Transport and auth:** Remote at `https://mcp.cloudflare.com/mcp`, with OAuth (recommended), where you select permissions during authorization, or user and account API tokens for CI. Cloudflare's README puts the Code Mode tools at about 1,100 tokens, against about 244,000 for one tool per endpoint with minimal schemas.
- **Best for:** Managing Workers, DNS, and other Cloudflare resources, or debugging a deployment, from one server.
- **Caution:** `execute` can call any endpoint the token's permissions allow, so grant only what the task needs. Older product servers such as Workers Bindings, Workers Builds, and Observability are deprecated in favor of this one; the docs server at `docs.mcp.cloudflare.com/mcp` remains.

## Payments: Stripe MCP

Stripe's MCP server gives agents read and write access to the Stripe API, plus search over Stripe's documentation and support articles. Stripe hosts it at mcp.stripe.com, supports OAuth with separate permissions for live and sandbox environments, and can require human confirmation in the Dashboard before sensitive actions, such as refunds, go through.

### Stripe MCP

- **What it does:** Calls the Stripe API through four generic tools (`stripe_api_search`, `stripe_api_details`, `stripe_api_read`, and `stripe_api_write`) and searches Stripe's documentation.
- **Maintainer:** [Stripe](https://docs.stripe.com/mcp), as a hosted service; `stripe agent setup` in the Stripe CLI installs it along with Stripe's skills.
- **Transport and auth:** Remote at `https://mcp.stripe.com`, with OAuth for interactive clients (separate permissions per live account or sandbox) or an agent API key as a bearer token. Stripe's docs say that from December 2026 the server stops accepting full-access secret keys and restricted keys without the Agent tag, so key-based setups must migrate by November 30, 2026.
- **Best for:** Building and debugging payment integrations against a sandbox, and answering support questions about customers, invoices, and subscriptions.
- **Caution:** `stripe_api_write` covers POST, PATCH, PUT, and DELETE. Stripe's Dashboard confirmation applies only to specific actions and is separate from your client's tool approval, so keep both on. Admins can disable MCP access separately for live mode and sandboxes.

## Web search: Exa MCP

Web search servers let an agent look up changelogs, issue threads, and error messages that no documentation server covers. Exa's official server is remote and works without an account, with rate limits. Brave and Tavily also maintain official servers: Brave's runs locally with a Brave Search API key, and Tavily's runs remotely with an API key or OAuth.

### Exa MCP

- **What it does:** Searches the web and fetches pages with `web_search_exa` and `web_fetch_exa` by default; the `?tools=` parameter enables `web_search_advanced_exa` and `agent_run` for multi-step research.
- **Maintainer:** [Exa](https://github.com/exa-labs/exa-mcp-server), MIT license.
- **Transport and auth:** Remote at `https://mcp.exa.ai/mcp`, which works anonymously with rate limits; OAuth or an API key raises them. Exa also publishes the `exa-mcp-server` npm package for local use.
- **Best for:** Research beyond library docs, such as release notes, bug reports, and blog posts about an error.
- **Caution:** Every result is third-party web content and a direct path for prompt injection, so keep tool approval on for any write-capable server in the same session.

The [web search APIs directory](https://theaiengineering.com/platforms/web-search-apis) compares the search APIs behind these servers.

## How to add MCP servers in Claude Code, Cursor, and VS Code

Each client stores MCP servers in a JSON config with the same building blocks: a name, then either a URL for a remote server or a command and arguments for a local one. Claude Code adds entries from the terminal with `claude mcp add`, Cursor reads `mcp.json` files, and VS Code adds servers through its MCP: Add Server command.

### Claude Code MCP setup

Anthropic's [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp) recommends the HTTP transport for remote servers and marks SSE as deprecated. For a local server, `--` ends Claude Code's own options, so everything after it is the server's command and flags:

```bash
# Remote server over Streamable HTTP; run /mcp in a session to sign in
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

# Local stdio server: everything after -- is the server's own command
claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest --isolated

# Environment variables for a stdio server (keep another option between --env and the name)
claude mcp add --env MDB_MCP_CONNECTION_STRING="$MONGODB_URI" --transport stdio mongodb \
  -- npx -y mongodb-mcp-server@latest --readOnly

# Shared with the team through .mcp.json
claude mcp add --scope project --transport http supabase \
  "https://mcp.supabase.com/mcp?project_ref=<project-ref>&read_only=true"
```

For servers that take an API key instead of OAuth, `--header` (`-H`) adds a header such as `"Authorization: Bearer <token>"`. The `--scope` flag decides where the entry is saved and who gets it:

| Scope | Stored in | Loads in |
|---|---|---|
| `local` (default) | `~/.claude.json` | The current project, for you only |
| `project` | `.mcp.json` at the project root | The current project, for everyone who clones it; Claude Code asks for approval before first use |
| `user` | `~/.claude.json` | All of your projects |

A project `.mcp.json` supports `${VAR}` and `${VAR:-default}` expansion, so each developer's token stays in their own environment rather than in git:

```json
{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/readonly",
      "headers": { "Authorization": "Bearer ${GITHUB_PAT}" }
    },
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--isolated"]
    }
  }
}
```

Inside a session, `/mcp` shows server status and runs OAuth sign-in; `claude mcp list`, `get`, and `remove` manage entries from the shell. Removing a server deletes its stored tokens without revoking them, so run `claude mcp logout <name>` first. Tool search is on by default, so only tool names and server instructions take up the [context window](https://theaiengineering.com/glossary/context-window) at session start, and `MAX_MCP_OUTPUT_TOKENS` caps a tool's output at 25,000 tokens by default.

### Cursor

Cursor reads `.cursor/mcp.json` in a project and `~/.cursor/mcp.json` for every project, both with a top-level `mcpServers` object. Local entries take `command`, `args`, and `env`; remote entries take `url` and optional `headers`. According to [Cursor's MCP docs](https://cursor.com/docs/mcp), it signs in to remote servers with OAuth using the authorization code flow with PKCE, resolves `${env:NAME}` and `${workspaceFolder}` variables, and asks for approval before running MCP tools by default.

```json
{
  "mcpServers": {
    "linear": { "url": "https://mcp.linear.app/mcp" },
    "context7": {
      "url": "https://mcp.context7.com/mcp",
      "headers": { "Authorization": "Bearer ${env:CONTEXT7_API_KEY}" }
    },
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest", "--isolated"]
    }
  }
}
```

### VS Code

In VS Code, run **MCP: Add Server** from the Command Palette, choose HTTP or a command (stdio), and pick where to save the entry. VS Code's [MCP configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration) recommends the portable `mcpServers` format for new GitHub Copilot configurations: a workspace-root `.mcp.json` to share with the team, or `~/.copilot/mcp-config.json` for personal servers. The older `.vscode/mcp.json` file uses a `servers` key and belongs to VS Code's local, editor-managed mode, which the reference says is deprecated and will be removed in February 2027. Because Claude Code's project scope reads the same root `.mcp.json`, one file can configure both tools.

**Figure 2: Where each client reads MCP servers from. A root .mcp.json in git serves Claude Code and VS Code; personal entries live in the home directory.**

Claude Code and VS Code both read a shared .mcp.json in the repository, Cursor reads .cursor/mcp.json, and each client also reads a personal config file in the home directory.

Components:

- **.mcp.json**: mcpServers, committed to git
- **.cursor/mcp.json**: mcpServers, per project
- **Claude Code**
- **VS Code**: GitHub Copilot
- **Cursor**
- **~/.claude.json**: local and user scopes
- **~/.copilot/mcp-config.json**: personal servers
- **~/.cursor/mcp.json**: all projects

Groups:

- Repository, shared through git: .mcp.json, .cursor/mcp.json
- Home directory: ~/.claude.json, ~/.copilot/mcp-config.json, ~/.cursor/mcp.json

Connections:

- .mcp.json → Claude Code: project scope
- .mcp.json → VS Code
- .cursor/mcp.json → Cursor
- ~/.claude.json → Claude Code
- ~/.copilot/mcp-config.json → VS Code
- ~/.cursor/mcp.json → Cursor

## Find more servers in the official MCP Registry

The official MCP Registry at registry.modelcontextprotocol.io is a metadata catalog for public MCP servers, backed by contributors including Anthropic, GitHub, PulseMCP, and Microsoft. It records where to find each server and how to install it, not the code itself. As of November 2026 it was still in preview, with its v0.1 API frozen since October 2025.

Server names use reverse-DNS namespaces tied to a verified GitHub account or domain, so the namespace is the quickest provenance check. A query of the registry API on November 16, 2026, returned official entries such as `io.github.github/github-mcp-server`, `com.stripe/mcp`, `com.supabase/mcp`, `app.linear/linear`, and `io.github.getsentry/sentry-mcp`, alongside servers from other publishers with similar names.

The [registry documentation](https://modelcontextprotocol.io/registry/about) says it is meant mainly for downstream aggregators and delegates security scanning to package registries and those aggregators. The [MCP platforms directory](https://theaiengineering.com/platforms/mcp-platforms) compares it with directories such as Glama and PulseMCP.

## Security: scope every MCP server you add

Every MCP server adds tool definitions to the model's context and a new path for actions and untrusted data. Official servers lower the chance of installing a malicious package, but they still return issue comments, web pages, and database rows that can carry instructions. Give each server the least access its job needs.

- **Prefer read-only modes and narrow scopes.** Use the controls covered above, from GitHub's `/readonly` and Supabase's `project_ref` to permission selection during OAuth for Cloudflare and Stripe.
- **Keep tool approval on for writes.** [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop) approval in the client is the last check before an agent merges, deploys, refunds, or drops data.
- **Watch for tool poisoning.** In [tool poisoning](https://theaiengineering.com/glossary/tool-poisoning), a malicious or compromised server hides instructions in a tool's description or schema. Install from vendor namespaces, pin local package versions in shared configs rather than floating on `@latest`, and review tool descriptions after updates.
- **Treat tool results as untrusted.** [Prompt injection](https://theaiengineering.com/glossary/prompt-injection) can arrive in any tool result, which is why Supabase wraps SQL results in warnings and Stripe cautions against combining its server with others.
- **Keep developer servers away from end users.** Supabase says its server runs with developer permissions and should not be given to customers.

When many developers share many servers, an [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway) such as [Bifrost](https://docs.getbifrost.ai/mcp/overview) can put them behind one endpoint and filter which tools each virtual key sees, as the [AI gateway explainer](https://theaiengineering.com/articles/what-is-an-ai-gateway) describes.

## Which MCP servers to install first

Start with the servers that match the services your team already uses, and add them one at a time. For most web teams, that means GitHub's server, one documentation server such as Context7, one browser server such as Playwright MCP, and the error tracker. Add database, cloud, and payment servers per project, in read-only or sandbox mode first.

For how coding agents use these servers day to day, see the [AI coding agents guide](https://theaiengineering.com/articles/ai-coding-agents) and the [AI coding tools directory](https://theaiengineering.com/platforms/ai-coding-tools). To expose an internal API the same way, follow [how to build an MCP server](https://theaiengineering.com/articles/how-to-build-an-mcp-server).

## Frequently asked questions

### What are the best MCP servers for Claude Code?

For most software teams, start with GitHub's MCP server for repositories and pull requests, Context7 or a vendor documentation server for current library docs, Playwright MCP or Chrome DevTools MCP for browser work, and Sentry's remote server for production errors. Add database, cloud, and payment servers only for the projects that need them, and connect each one in read-only or project-scoped mode first. All of them install with claude mcp add.

### How do I add an MCP server to Claude Code?

Run claude mcp add --transport http <name> <url> for a remote server, then type /mcp in a Claude Code session to complete any OAuth sign-in. For a local server, run claude mcp add <name> -- <command> [args], where everything after the -- separator is the server's own command. Add --scope project to save the entry in a .mcp.json file that teammates share, or --scope user to load it in every project.

### Where can I find a list of MCP servers?

The official MCP Registry at registry.modelcontextprotocol.io publishes metadata for public MCP servers under names tied to verified GitHub accounts or domains, such as com.stripe/mcp or io.github.getsentry/sentry-mcp. It was still in preview in November 2026. Directories such as the GitHub MCP Registry, Glama, and PulseMCP add search and curation on top, and each vendor's own documentation remains the source for current URLs, auth methods, and flags.

### Are MCP servers safe to use?

An MCP server is as safe as its maintainer, its permissions, and the content it returns. Official servers reduce supply-chain risk, but any server can return text that carries prompt injection, such as an issue comment, a database row, or a web page. Prefer read-only or narrowly scoped credentials, keep tool-call approval on for write actions, and connect production data only when a task requires it.

### What is the difference between a local and a remote MCP server?

A local MCP server runs on your machine as a subprocess that the host starts and talks to over stdio, and it reads credentials from environment variables. A remote MCP server runs on the vendor's infrastructure and is reached over Streamable HTTP, usually after an OAuth sign-in in the browser. Remote servers need no installation or updates, while local servers can reach your browser, files, and private networks.

### How many MCP servers can I connect at once?

The protocol sets no limit, but every connected server adds tool definitions that compete for the model's context window. Claude Code defers MCP tool definitions through tool search by default, loading only tool names and server instructions at session start, and it sets no fixed per-server tool cap. Other clients may load every definition upfront, so enable only the servers and toolsets a project actually uses.

## Terms in this guide

- [MCP server](https://theaiengineering.com/glossary/mcp-server): An MCP server is a program that exposes tools, resources, and prompts to AI applications through the Model Context Protocol, running locally over stdio or remotely over Streamable HTTP.
- [Model Context Protocol (MCP)](https://theaiengineering.com/glossary/model-context-protocol): Model Context Protocol (MCP) is an open protocol, introduced by Anthropic in November 2024, that standardizes how AI applications connect to external tools, data sources, and prompts through MCP servers.
- [MCP transport](https://theaiengineering.com/glossary/mcp-transport): An MCP transport is the binding that carries Model Context Protocol messages between a client and a server; the specification defines stdio for local subprocesses and Streamable HTTP for remote servers.
- [Tool calling](https://theaiengineering.com/glossary/tool-calling): Tool calling is an LLM capability in which the model, given a list of tool definitions, outputs a structured request naming a tool and its arguments, which the application executes and returns.
- [Context window](https://theaiengineering.com/glossary/context-window): A context window is the maximum number of tokens a language model can take into account in a single request, including the system prompt, conversation history, tool results, and the generated output.
- [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop): Human-in-the-loop (HITL) is an agent design in which the run pauses at defined checkpoints, such as before a sensitive tool call, so a person can approve, edit, or reject the action.
- [Tool poisoning](https://theaiengineering.com/glossary/tool-poisoning): Tool poisoning is an attack in which a malicious or compromised MCP server hides instructions in a tool's description or schema, which the model reads as trusted context and may follow.
- [Prompt injection](https://theaiengineering.com/glossary/prompt-injection): Prompt injection is an attack in which text supplied to a large language model, typed by a user or hidden in content the model reads, alters the application's intended behavior or output.
- [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway): An MCP gateway is a proxy that sits between MCP hosts and many MCP servers, exposing them through one endpoint and centralizing authentication, tool access policy, and audit logging.

## Related guides

- [What is the Model Context Protocol (MCP)? How it works](https://theaiengineering.com/articles/what-is-model-context-protocol): The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. Learn its architecture, transports, tool calls, and security.
- [How to build an MCP server: a Python and TypeScript tutorial](https://theaiengineering.com/articles/how-to-build-an-mcp-server): Learn how to build an MCP server with the official Python and TypeScript SDKs: tools, resources, transports, testing, client config, and production security.
- [AI coding agents: how they work and how the major tools compare](https://theaiengineering.com/articles/ai-coding-agents): AI coding agents compared: how they differ from autocomplete, the four main categories, a comparison table of major tools, and how to evaluate and secure them.
- [What is tool calling? How LLM function calling works](https://theaiengineering.com/articles/tool-calling): Tool calling lets an LLM request actions from your code through structured calls. Learn the request loop, parallel calls, structured outputs, security, and MCP.

Part of the [Model Context Protocol](https://theaiengineering.com/topics/mcp) topic hub.

## Cite this guide

The AI Engineering Editors. "Best MCP servers for developers: official servers by category." The AI Engineering, updated Nov 19, 2026. https://theaiengineering.com/articles/best-mcp-servers

- Title: Best MCP servers for developers: official servers by category
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-11-19
- Updated: 2026-11-19
- URL: https://theaiengineering.com/articles/best-mcp-servers
- Markdown: https://theaiengineering.com/articles/best-mcp-servers.md

To cite one section, link to its anchor:

- [Selection criteria](https://theaiengineering.com/articles/best-mcp-servers#selection-criteria)
- [MCP server list: summary table](https://theaiengineering.com/articles/best-mcp-servers#mcp-server-list-summary-table)
- [Local vs remote MCP servers](https://theaiengineering.com/articles/best-mcp-servers#local-vs-remote-mcp-servers)
- [Code hosting: GitHub MCP Server](https://theaiengineering.com/articles/best-mcp-servers#code-hosting-github-mcp-server)
- [Browsers and testing: Playwright MCP and Chrome DevTools MCP](https://theaiengineering.com/articles/best-mcp-servers#browsers-and-testing-playwright-mcp-and-chrome-devtools-mcp)
- [Documentation: Context7 and Microsoft Learn](https://theaiengineering.com/articles/best-mcp-servers#documentation-context7-and-microsoft-learn)
- [Databases and backends: Supabase and MongoDB](https://theaiengineering.com/articles/best-mcp-servers#databases-and-backends-supabase-and-mongodb)
- [Observability and errors: Sentry MCP](https://theaiengineering.com/articles/best-mcp-servers#observability-and-errors-sentry-mcp)
- [Issue tracking and team docs: Linear, Atlassian, and Notion](https://theaiengineering.com/articles/best-mcp-servers#issue-tracking-and-team-docs-linear-atlassian-and-notion)
- [Cloud platforms: AWS and Cloudflare](https://theaiengineering.com/articles/best-mcp-servers#cloud-platforms-aws-and-cloudflare)
- [Payments: Stripe MCP](https://theaiengineering.com/articles/best-mcp-servers#payments-stripe-mcp)
- [Web search: Exa MCP](https://theaiengineering.com/articles/best-mcp-servers#web-search-exa-mcp)
- [How to add MCP servers in Claude Code, Cursor, and VS Code](https://theaiengineering.com/articles/best-mcp-servers#how-to-add-mcp-servers-in-claude-code-cursor-and-vs-code)
- [Find more servers in the official MCP Registry](https://theaiengineering.com/articles/best-mcp-servers#find-more-servers-in-the-official-mcp-registry)
- [Security: scope every MCP server you add](https://theaiengineering.com/articles/best-mcp-servers#security-scope-every-mcp-server-you-add)
- [Which MCP servers to install first](https://theaiengineering.com/articles/best-mcp-servers#which-mcp-servers-to-install-first)
- [Frequently asked questions](https://theaiengineering.com/articles/best-mcp-servers#faq)
