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 design files, and the rest of your stack." A year 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: ten 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 Anthropic shipped to standardize 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 your .mcp.json or ~/.config/claude/mcp.json, starts the configured servers, and the tools they expose appear in the agent's tool list automatically.
If this is your first time, the Claude Code setup guide covers initial install. For China-specific notes (running MCP servers behind a network that blocks PyPI / npm registries) see How to use Claude Code in China.
The ten servers below are ordered loosely by how often we reach for them.
1. Filesystem (@modelcontextprotocol/server-filesystem)
The first MCP server most people install. 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 (@modelcontextprotocol/server-git)
Claude Code already reads files; the Git MCP adds first-class operations on commit history, blame, diffs, and bisect. Replaces a lot of git shell calls with structured tool calls that Claude composes more reliably.
{
"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 the PR description." The agent runs through git log, git show, and the GitHub API in one chain.
3. GitHub (@modelcontextprotocol/server-github)
Pulls in issues, pull requests, branches, runs, and the GraphQL API. Significantly faster than scraping GitHub via curl, and Claude does not have to remember the API shape — the tool descriptions handle it.
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"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 (@modelcontextprotocol/server-postgres)
Read-only by default — Claude can introspect schemas, run SELECT queries, look at constraints. Critical for any agent working against a real database. Pair it with a read-replica connection string for safety.
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://reader@localhost/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. Slack (@modelcontextprotocol/server-slack)
Reads channels you authorize. The killer use is "summarize what happened in #incidents over the last 24 hours" without context-switching out of your editor.
{
"mcpServers": {
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-...",
"SLACK_TEAM_ID": "T..."
}
}
}
}
Real use: "Read #api-questions from the last 7 days. Make a list of recurring confusions our docs do not cover, sorted by frequency." Replaces 30 minutes of scrolling.
6. Linear (linear-mcp)
Issue tracking is where the work lives, and pulling Linear into Claude Code closes a big context gap. The agent can read tickets, find related ones, and (with permission) update them.
{
"mcpServers": {
"linear": {
"command": "npx",
"args": ["-y", "linear-mcp"],
"env": {
"LINEAR_API_KEY": "lin_..."
}
}
}
}
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. Puppeteer / Playwright (@modelcontextprotocol/server-puppeteer)
Lets the agent drive a real browser — navigate URLs, click, screenshot, fill forms, scrape content. Indispensable for QA flows and scraping that needs JS execution.
{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}
}
}
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. Brave Search / 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.
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": { "BRAVE_API_KEY": "BSA..." }
}
}
}
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.
9. Sentry (sentry-mcp)
Surfaces production errors directly to the agent. 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.
{
"mcpServers": {
"sentry": {
"command": "npx",
"args": ["-y", "sentry-mcp"],
"env": {
"SENTRY_AUTH_TOKEN": "...",
"SENTRY_ORG": "my-org"
}
}
}
}
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."
10. Router One (router-one-mcp)
The Router One MCP gives the agent access to your usage and routing dashboard — current spend, recent runs, model breakdown — without you alt-tabbing to the web UI. Useful when an agent is iterating and you want to see live cost in the same loop.
{
"mcpServers": {
"router-one": {
"command": "npx",
"args": ["-y", "@router-one/mcp"],
"env": { "ROUTER_ONE_API_KEY": "sk-..." }
}
}
}
Real use: "How much did this session cost? Which model contributed most to the spend? Show me the last 5 runs and their per-step breakdown." For more on the underlying observability layer see How to run AI agents in production and AI model routing explained.
Honorable Mentions
A few servers that just missed the top 10 but are worth knowing:
- Notion / Confluence — pull in internal documentation. 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 / KV — give the agent a persistent scratchpad across sessions. Worth it if you have a long-running project.
- MongoDB / Redis — analogous to the Postgres server, for the rest of your data layer.
A Note on Trust and Permissions
MCP servers run as separate processes with full credentials you give them. A few rules of thumb:
- Use read-only credentials wherever possible. The Postgres example points to a reader user; the GitHub token can be scoped to read-only on private repos.
- Audit what each server exposes before installing widely.
mcp inspect <server>lists the tools a server registers; read it once. - 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 to put the config:
.mcp.jsonin your project for project-specific servers;~/.config/claude/mcp.jsonfor ones that should be available globally. - Verifying a server runs: in Claude Code,
/mcplists the connected servers and surfaces any that crashed at startup. - From China: the npx-based installs may stall on npm registry latency. Either configure
npmrcto use a Chinese mirror, or install the server packages globally once and reference the local path. See Claude Code in China for more.
FAQ
Do I need all ten? 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 Slack/Linear. A frontend dev might pick Figma and Puppeteer instead.
Will these slow Claude down? Each MCP server is a process; a dozen running adds startup time and memory. We see noticeable slowdown past ~15 servers; under 8 is invisible.
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? Codex CLI is OpenAI's tool and has its own tool-call interface; MCP is Anthropic's protocol. There is partial overlap (some servers expose both) but full MCP support is Claude Code's strong suit. See Codex CLI alternative.
Can MCP servers reach the internet? Yes — they're regular processes. Search and web-aware servers are explicitly that. For sensitive setups, network-isolate them if needed.
What about MCP through Cursor or other clients? Cursor added partial MCP support in early 2026. The shape of the integration is different — fewer tools per server, fewer auto-loaded prompts. Claude Code remains the most complete MCP client today.
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.
For configuring Claude Code itself see the setup guide; for understanding why an agent platform like Router One matters in production, see How to run AI agents in production.