9 MCP Servers for Claude Code Worth Installing in 2026

Updated 2026-08-22. Every entry below was re-checked on that date against the official MCP reference-server registry and each vendor's own documentation. Package names and hosted endpoints in this ecosystem change often: several reference servers this post originally listed have since been archived upstream and are replaced here by their maintained successors. Treat the snippets as a dated snapshot and confirm the package or URL before you paste a credential into it. If you are installing Claude Code itself for the first time, start with the Claude Code setup guide.

MCP — the Model Context Protocol — turns Claude Code from "an agent that reads and writes files" into "an agent that talks to your databases, your monitoring stack, your tickets, your library docs, and the rest of your stack." Nearly two years into the protocol's life, the ecosystem has settled around a few servers that are genuinely worth installing on day one and a long tail of niche ones for specific workflows.

This post is the day-one shortlist: nine MCP servers that meaningfully change what Claude Code can do, with a one-paragraph rationale, the install snippet, and a real example query for each. None of these are "hello world" — every one is something we and the developers we talk to actually use in 2026.

Quick Refresher: What MCP Is

MCP is a small JSON-RPC protocol — originally shipped by Anthropic, now an open standard — that standardizes how agents access external tools. An MCP server exposes tools (callable functions), resources (readable URIs), and prompts (templates) over stdio or HTTP. Claude Code reads the servers you registered — project-scoped ones from .mcp.json in the repository root, user- and local-scoped ones from ~/.claude.json — starts or connects to them, and the tools they expose appear in the agent's tool list automatically.

Two install shapes cover everything below. A local (stdio) server is a process Claude Code launches: claude mcp add <name> -- npx -y <package>. A remote (HTTP) server is a URL you connect to, usually with OAuth handled from inside Claude Code: claude mcp add --transport http <name> <url>. Add --scope user to either form to make the server available in every project instead of only the current one. The JSON snippets below are the equivalent mcpServers entries if you prefer to edit the file by hand.

For China-specific notes (running MCP servers behind a network that blocks PyPI / npm registries) see How to use Claude Code in China.

The nine servers below are ordered loosely by how often we reach for them.

1. Filesystem (@modelcontextprotocol/server-filesystem)

The first MCP server most people install, and still one of the officially maintained reference servers. It exposes scoped file read/write/search outside Claude Code's working directory. Useful when the agent needs to read ~/Documents for a writeup, look at a config in /etc/, or ferry files between projects.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/me/Documents",
        "/Users/me/projects"
      ]
    }
  }
}

Real use: "Find every docker-compose.yml under my projects directory and tell me which ones are using deprecated v2 syntax." The agent walks the filesystem, opens each, and reports back.

2. Git (mcp-server-git)

Claude Code already reads files; the Git MCP adds first-class operations on commit history, blame, diffs, and bisect. It replaces a lot of git shell calls with structured tool calls that Claude composes more reliably. This one is a Python package from the reference-server repo, so it is installed with uvx rather than npx.

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git"]
    }
  }
}

Real use: "Find the commit where the rate-limit middleware switched from in-memory to Redis. Summarize the diff and list every file it touched." The agent runs through git log and git show in one chain instead of pasting hashes back and forth.

3. GitHub (github/github-mcp-server)

The original reference-server package for GitHub is archived; GitHub now maintains the official server itself, and it pulls in issues, pull requests, branches, workflow runs, and code search. The easiest route is the hosted endpoint, which authenticates with OAuth from inside Claude Code — no token on disk:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

If you would rather run it locally with a personal access token, the same server ships as a Docker image:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    }
  }
}

Real use: "Look at the last 10 closed PRs in this repo. Which ones touched the auth module? For those, summarize the review comments — were any concerns raised that we did not address?"

4. Postgres (postgres-mcp)

The archived reference Postgres server has a maintained successor in Postgres MCP Pro. It adds schema introspection, index and query-plan analysis, and — the part that matters for safety — an explicit --access-mode=restricted flag that keeps the session read-only. Pair it with a read-replica connection string and the agent can answer data questions without ever being able to change a row.

{
  "mcpServers": {
    "postgres": {
      "command": "uvx",
      "args": ["postgres-mcp", "--access-mode=restricted"],
      "env": {
        "DATABASE_URI": "postgresql://reader@localhost:5432/mydb"
      }
    }
  }
}

Real use: "We added a new subscription_tier column three weeks ago. Are any rows still NULL? If so, can you tell from joins which user cohort?" The agent inspects the schema, runs the query, and joins context together.

5. Context7 (hosted https://mcp.context7.com/mcp)

The single most common way an agent writes wrong code is stale library knowledge — an API that changed after the model's training cut. Context7 pulls current, version-specific documentation for the library you name straight into the context, so "use the Next.js 16 proxy convention" resolves against today's docs rather than last year's. It is a hosted server authenticated with an API key passed as a bearer header:

claude mcp add --transport http context7 https://mcp.context7.com/mcp \
  --header "Authorization: Bearer <your-context7-key>"

Real use: "Before you write the middleware, pull the current Next.js docs on proxy.ts and confirm the matcher syntax. Then implement it." Cuts the retry loop where the agent guesses an outdated signature.

6. Linear (hosted https://mcp.linear.app/mcp)

Issue tracking is where the work lives, and pulling Linear into Claude Code closes a big context gap. The community linear-mcp package is superseded by Linear's own hosted server, which authenticates with OAuth:

claude mcp add --transport http linear https://mcp.linear.app/mcp

A read-only variant lives at https://mcp.linear.app/mcp/readonly — use it when the agent should read tickets but never update them.

Real use: "I'm picking up issue ENG-1432. Pull the full ticket, the linked design doc, the related issues, and the recent comments. Summarize what's actually being asked."

7. Playwright (@playwright/mcp)

The reference Puppeteer server is archived; Microsoft's Playwright MCP is the maintained browser-driving server. It works from the accessibility tree rather than screenshots, which makes it cheaper in tokens and more reliable at clicking the right element. Navigate URLs, click, fill forms, screenshot, scrape content that needs JS execution.

claude mcp add playwright npx @playwright/mcp@latest

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Real use: "Open our staging site, sign in as the test user, navigate to billing, take a screenshot. Now do the same on production. Diff the screenshots." Gives Claude Code true e2e test execution capability.

8. Web Search (@brave/brave-search-mcp-server or Tavily)

The web is part of context. A search MCP gives the agent a way to find current information without you copy-pasting into the prompt. The reference Brave server was archived and replaced by Brave's official package; Tavily offers a hosted endpoint if you would rather not run a process.

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
      "env": { "BRAVE_API_KEY": "BSA..." }
    }
  }
}

Tavily, hosted: claude mcp add --transport http tavily "https://mcp.tavily.com/mcp/?tavilyApiKey=<your-tavily-key>".

Real use: "What is the current AWS limit for API Gateway concurrent requests? Find the official docs link." Faster and more honest than Claude relying on its training cut.

If you call Claude from your own code rather than through Claude Code, the model's server-side web_search tool is the alternative to running a search server yourself — Claude web search and code execution through the API covers running it on Router One's /v1/messages, where the MCP connector itself is rejected with a 400.

9. Sentry (hosted https://mcp.sentry.dev/mcp)

Surfaces production errors directly to the agent. Sentry's official server is hosted and OAuth-authenticated, so there is no auth token to manage:

claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

The first time you say "look at the latest Sentry errors and tell me which ones are likely related to PR #1234" you understand why this is on the list.

Real use: "Pull the top 10 unresolved errors from the last 24 hours. Group by likely cause. For each, suggest which file is probably involved based on the stack traces."

Honorable Mentions

A few servers that just missed the shortlist but are worth knowing:

• Notion / Confluence — pull in internal documentation. Notion runs a hosted server at https://mcp.notion.com/mcp. Especially useful for design docs and historical decisions.
• Figma — read frames and component definitions. Pair with a frontend agent that translates designs to code.
• JetBrains IDE — control IntelliJ/PyCharm from Claude Code. Useful for refactor flows that benefit from IDE inspections.
• Memory (@modelcontextprotocol/server-memory) — a reference server that gives the agent a persistent knowledge graph across sessions. Worth it if you have a long-running project.
• Slack — the reference server is archived; community forks carry it on, so check maintenance status before handing one a bot token.
• MongoDB / Redis — analogous to the Postgres server, for the rest of your data layer.

A Note on Trust and Permissions

MCP servers run with whatever credentials you give them. A few rules of thumb:

• Use read-only credentials wherever possible. The Postgres example runs in restricted mode against a reader user; Linear has a read-only endpoint; a GitHub token can be scoped to read-only on private repos.
• Prefer hosted servers with OAuth over long-lived tokens in a JSON file: the token never touches your disk, and revoking access is one click on the vendor side.
• Audit what each server exposes before installing widely. npx @modelcontextprotocol/inspector opens the MCP Inspector, which connects to a server and lists every tool it registers; inside Claude Code, /mcp shows each connected server's tool count.
• Avoid running production credentials on a developer machine. For prod-data agents, run the MCP server in your prod environment and let Claude Code talk to it over HTTP MCP, not stdio.
• Be especially careful with tools that take destructive actions — DELETE queries, rm -rf, force-pushes. Either use read-only modes or wrap them with confirmation prompts.

Setup Tips

• Where the config lives: .mcp.json in the repository root for project-scoped servers your team shares through version control (Claude Code asks you to approve them on first use); ~/.claude.json for user-scoped servers available in every project and for local-scoped ones private to a single project. claude mcp add … --scope user writes to the right place for you.
• Verifying a server runs: claude mcp list prints a health status per server; inside Claude Code, /mcp lists connected servers, handles OAuth sign-in for remote ones, and surfaces any that failed at startup.
• From China: the npx-based installs may stall on npm registry latency. Either configure npmrc to use a Chinese mirror, or install the server packages globally once and reference the local path. Hosted servers sidestep the registry entirely. See Claude Code in China for more.

FAQ

Do I need all nine? No. Pick three or four that match the actual external systems your work touches. A senior engineer working on a TypeScript backend usually ends up with filesystem, git, GitHub, Postgres, and one of Linear/Context7. A frontend dev might pick Figma and Playwright instead.

Will these slow Claude down? Each stdio server is a process; a dozen running adds startup time and memory. We see noticeable slowdown past ~15 local servers; under 8 is invisible. Hosted HTTP servers cost nothing locally, which is one more reason to prefer them.

How do I write my own? The protocol is small. The official SDKs in TypeScript and Python are well-documented. A useful internal pattern is wrapping your own internal HTTP API as an MCP server — about 80 lines of TypeScript.

Does this work with Codex CLI? Yes. Codex CLI supports MCP servers too: codex mcp add <name> -- <command> for stdio servers, or an [mcp_servers.<name>] table in ~/.codex/config.toml, with streamable HTTP and OAuth supported. Most servers above work in both clients unchanged. If you run both CLIs, see Codex CLI alternative for keeping their spend on one key.

Can MCP servers reach the internet? Yes — they're regular processes or remote services. Search and web-aware servers are explicitly that. For sensitive setups, network-isolate local servers if needed.

What about MCP through Cursor or other clients? Cursor has shipped MCP support since early 2025: it reads .cursor/mcp.json (project) or ~/.cursor/mcp.json (global) and speaks stdio and HTTP with OAuth, so the servers above work there too. What differs is the client-side plumbing — Claude Code adds project-scope approval for shared .mcp.json files, plugin-bundled servers, and OAuth sign-in from the /mcp panel. Self-hosted chat UIs are in the same boat: LibreChat reads an mcpServers block in its librechat.yaml, so the same servers can sit behind a chat window pointed at Router One.

Conclusion

MCP is the difference between "Claude Code that reads files" and "Claude Code that touches your whole stack." Start with filesystem + git + GitHub + Postgres; layer in the rest as your workflows demand them. The compound effect — every MCP server multiplies what every other can do — is what makes the agent feel materially more useful month over month.

If you are wiring several MCP-equipped agents into one workflow, the pattern-level tradeoffs — sequential, parallel, hierarchical, human-in-the-loop — are covered in multi-agent orchestration patterns.

For configuring Claude Code itself see the setup guide; for understanding how an LLM API gateway fits beneath your orchestration framework, see How to run AI agents in production.