Claude Code · MCP
The Minimum Viable MCP Stack
Five Model Context Protocol servers worth the context tokens — filesystem, github, playwright, postgres, sequential-thinking — and eleven I stopped installing.
The short answer
The right MCP stack is five servers or fewer. Every server ships its tool schemas into Claude's context on every turn — bloat it and you pay in both tokens and wrong-tool picks. The minimum viable stack is filesystem (cross-project reach), github (PR and issue access), playwright (real browser automation), a database server like postgres (query your real data), and sequential-thinking (force step-by-step reasoning on hard problems). Add others only when a specific recurring task justifies the context cost.
Why fewer MCP servers is better
Every MCP server connected to Claude Code injects its full tool schema into the model's context on every single turn. That's the contract — Claude needs to know what tools exist before it can call them. Typical schemas run 500 to 2,000 tokens per server.
A naïve "install everything that looks cool" stack of 15 servers eats 15-30K tokens of context before you type anything. On Sonnet 4.6's 1M context window that's fine in raw terms — but the real cost is cognitive: more tool definitions means more bad tool picks, more "Claude decided to call the time server instead of just computing the date" moments, and a transcript cluttered with tool calls that don't advance the work.
The test for every MCP server: does this server earn its context cost on more than half of my sessions? If no, it stays out of the default stack. You can always add project-specific servers in .mcp.json.
The 5 servers
For each: what it is, the killer use case, when to keep it, when to drop it, and a copy-paste config block.
filesystem
EssentialSchema: ~1,200 tokens@modelcontextprotocol/server-filesystem
Claude Code can already read and edit files in your project root. Filesystem MCP extends that to arbitrary paths on your machine — Downloads, Documents, a sibling project, wherever. If you work across more than one repo or reference docs outside the project, you need this.
Killer use case
Pulling a CSV from ~/Downloads and having Claude merge it into the project without copying files around.
Keep if
You routinely work across multiple project directories or reference data stored outside your codebase.
Drop if
You only ever work inside a single repo. Claude Code's built-in tools already handle that.
.mcp.json snippet
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/you/src",
"/Users/you/Downloads"
]
}
}
}github
EssentialSchema: ~1,800 tokens@modelcontextprotocol/server-github
Reading PR discussions, searching issues, and checking CI status without tab-switching to github.com. Claude pulls context directly from the API — including issue bodies, PR review comments, and Actions logs — which means it can answer "why did this fail?" without you copy-pasting stack traces.
Killer use case
Asking Claude to look at the last three failed Actions runs across five repos and tell you what broke. With the gh CLI you'd write a script; here Claude just queries.
Keep if
You ship to GitHub regularly and want Claude to read PRs, issues, and CI without you being the clipboard.
Drop if
You host on GitLab or Bitbucket exclusively — look for equivalent community servers instead.
.mcp.json snippet
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
}
}
}
}playwright
Task-specificSchema: ~2,500 tokens@playwright/mcp
Full browser automation as MCP tools — navigate, click, fill forms, screenshot, extract text. Claude stops guessing how the page behaves and actually drives it. For web scraping, end-to-end testing, or verifying a deployed change looks right, this replaces hours of manual QA.
Killer use case
Asking Claude to "check all my live sites render the H1 correctly" and watching it open each one, extract the H1, and report back. Five minutes instead of an afternoon.
Keep if
You do web QA, scraping, or automation as part of your workflow. Web developers, SEO operators, anyone running multiple sites.
Drop if
You work on pure-backend or CLI projects with no browser dimension. The context overhead is not worth it.
.mcp.json snippet
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["-y", "@playwright/mcp"]
}
}
}postgres (or sqlite)
Task-specificSchema: ~1,500 tokens@modelcontextprotocol/server-postgres
Read-only SQL access to your actual database. Claude runs queries, reads schemas, and can explain your data instead of guessing from model files. Pair with a read-only user and you can safely let Claude explore production data to diagnose issues or draft migrations.
Killer use case
Asking "how many users signed up last week and what's their churn rate?" and getting the answer in one turn, grounded in real rows rather than hallucinated.
Keep if
Your project has a real database (Postgres, MySQL, SQLite) and you want Claude to reason about data, not just code.
Drop if
Your data is static JSON or flat files — just have Claude read them directly.
.mcp.json snippet
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://readonly:pw@localhost:5432/mydb"
]
}
}
}sequential-thinking
MetaSchema: ~800 tokens@modelcontextprotocol/server-sequential-thinking
Gives Claude an explicit "think" tool that forces step-by-step reasoning into the turn. Useful on hard debugging, architectural decisions, or when Claude is jumping to a solution too fast. You see Claude's reasoning chain as tool calls in the transcript, which makes it easier to spot where the logic went sideways.
Killer use case
A gnarly production bug Claude keeps mis-diagnosing. Turn on sequential-thinking and ask the same question — Claude slows down, walks the logic, and usually lands it.
Keep if
You regularly hit complex reasoning tasks where Claude rushes. Debugging, architecture, trade-off analysis.
Drop if
You mostly do routine edits. For simple tasks this just adds noise to the transcript.
.mcp.json snippet
{
"mcpServers": {
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
}
}What I tried and dropped
Every "top 20 MCP servers" listicle includes these. I installed them, then removed them. Here's why.
Slack / Discord / Linear MCPs
In theory Claude posts status updates. In practice the workflows that matter (filing an incident, closing a ticket) still need human review. You save nothing and add an OAuth flow.
Time / date / calendar servers
Claude can compute dates. You do not need an MCP server to tell it today is Tuesday. Adds context for zero benefit.
puppeteer (superseded)
Playwright MCP is strictly better — same surface, more reliable selectors, better screenshot handling. Pick Playwright.
memory / vector stores
CLAUDE.md is your memory. A project-level MCP "memory" server duplicates what a well-written CLAUDE.md does for 0 tokens of tool schema.
Monorepo "helper" servers
Most wrap git commands Claude Code can already run via Bash. You pay context for tools it already has.
Aggregator "all-in-one" MCPs
Packages that bundle 15 tools into one server are the worst of both worlds — full context cost, no clarity on what is available. Prefer small focused servers.
Combined .mcp.json for the full stack
Drop this into .mcp.json at your repo root. Claude Code picks it up on next session.
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/src"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "$GITHUB_TOKEN" }
},
"playwright": {
"command": "npx",
"args": ["-y", "@playwright/mcp"]
},
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres", "$DATABASE_URL"]
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
}
}Use environment variables for tokens and connection strings. Commit .mcp.json without secrets; each dev supplies their own GITHUB_TOKEN / DATABASE_URL.
How much context does this stack cost?
| Server | Schema tokens (approx) |
|---|---|
| filesystem | ~1,200 |
| github | ~1,800 |
| playwright | ~2,500 |
| postgres (or sqlite) | ~1,500 |
| sequential-thinking | ~800 |
| Total per turn | ~7,800 tokens |
On Sonnet 4.6 (1M context) that's 0.8% of the window. On Haiku 4.5 (200K) it's 3.9%. Either way: trivial compared to a 15-server kitchen-sink stack eating 25K+ tokens before you type anything.
Frequently asked questions
What is MCP in Claude Code?+
MCP (Model Context Protocol) is an open standard Anthropic released for connecting LLMs to external tools and data sources. An MCP server exposes capabilities — file access, API calls, database queries — that Claude can call during a session. Claude Code ships with a client; you add servers by editing .mcp.json or .claude/settings.json. Think of MCP as 'npm for AI tools' — reusable capability packages you bolt onto Claude.
Why not install every MCP server?+
Every server you connect ships its tool definitions into Claude's context on every turn. That means more tokens per call (cost) and less room for your actual work (context window). A bloated MCP stack also increases the chance Claude picks the wrong tool for the job. The right move is the smallest stack that covers 90% of your workflow.
How much context do MCP servers use?+
Typical tool schemas are 500-2000 tokens per server. A 10-server stack can eat 10-15K tokens of context before you send a single message. On Sonnet 4.6's 1M context that is fine; on Haiku's 200K you notice it. The bigger cost is cognitive load on the model — more tools means more wrong-tool picks.
Where do I configure MCP servers?+
Three layers. The user-level file at ~/.claude.json applies to every project. The project-level .mcp.json (checked into git) applies to everyone on the repo. The per-project .claude/settings.json overrides. Claude Code merges all three on startup. For team servers that everyone needs (shared database, company GitHub), use .mcp.json so it's version-controlled.
Are MCP servers safe?+
They run with your user permissions, so a malicious server can read your files and call your APIs. Two habits: (1) only install servers from sources you trust — the official @modelcontextprotocol/* packages, well-known vendors, your own code; (2) review what tools each server exposes before approving it. Claude Code prompts before the first tool call from a new server.
What is the difference between MCP and a slash command?+
A slash command is a named prompt you invoke manually (e.g. /commit). MCP servers expose tools Claude can call autonomously when it decides they help. Slash commands are prompts; MCP gives Claude new capabilities. Use slash commands for reusable workflows you trigger yourself; use MCP for capabilities you want Claude to reach for on its own.
Can I write my own MCP server?+
Yes — it is a small, stable spec. Anthropic publishes reference implementations in TypeScript and Python that you can fork. A 'hello world' MCP server is about 40 lines of code. The real work is designing the tool surface: each tool needs a clear name, description, and JSON schema so Claude picks the right one at the right time.
Where do I find the official MCP server list?+
The canonical directory is github.com/modelcontextprotocol/servers — Anthropic and community maintainers curate reference servers there. The official site at modelcontextprotocol.io has the spec. Avoid random 'awesome-mcp' listicles that have not been updated in three months; the ecosystem moves fast and broken servers pile up in those lists.
References
- • modelcontextprotocol.io — official spec
- • github.com/modelcontextprotocol/servers — reference server implementations
- • Claude Code MCP documentation — setup + authentication
Related reading
Hooks complement MCP — MCP adds capabilities, hooks enforce rules about how Claude uses them. The decision tree explains when each extension type fits.