Best MCP Servers for Claude Code in 2026: 8 You Should Actually Install

Claude Code is a CLI agent. Without MCP servers it can read files and run shell commands; with them it can do real engineering work. The MCP catalog has grown past 75,000 entries on Skiln alone, which is great for choice and terrible for decision-making.

This guide is the opinionated answer to "which MCPs do I actually install in Claude Code?" Eight servers, ranked by how much weight they pull in a real coding workflow.

Why Claude Code Needs Its Own MCP Shortlist

The Claude Code shortlist looks different from the Claude Desktop shortlist for a specific reason: Claude Code is task-oriented. The agent works in a repo, runs commands, opens PRs, and iterates against tests. The MCPs that matter are the ones that touch source code, the filesystem, version control, browsers (for QA), and the data the code reads and writes.

Claude Desktop optimizes for conversation. Claude Code optimizes for shipping. That shift in what "good" looks like changes which MCPs deserve a slot in ~/.claude.json.

Eight MCPs is also a deliberate cap. Above ten the model spends measurable token budget every turn just listing tools it will not call. Below five and you are leaving capability on the table. Eight is the sweet spot for a well-equipped Claude Code session that still feels responsive.

How We Ranked the Top Servers

Four criteria, applied to the full Skiln catalog of MCPs that report Claude Code compatibility:

1. Frequency of use. How often does a real coding workflow call this MCP? We measured across a sample of 200 Claude Code sessions from public agent logs and our own dogfooding.
2. Failure mode without it. What breaks if you do not have this MCP? "Filesystem" is non-negotiable; "documentation MCP" is annoying-to-be-without but not catastrophic.
3. Reliability. Does the server consistently respond, or does it crash, hang, or rate-limit at inconvenient times? Reliability beats feature surface.
4. Maintenance. Last meaningful commit within 60 days. Dead MCPs introduce silent bit-rot.

The 8 Best MCP Servers for Claude Code

1. Filesystem (the one you cannot skip)

The reference filesystem server, indexed on Skiln as Filesystem.

Why it leads. Without filesystem access, Claude Code is a chatbot that talks about your codebase. With it, the agent can read, write, list, search, and watch files in directories you allow. Everything else builds on this.

What to configure. Restrict the allowed directories to the project root and any external configs you genuinely need (e.g., ~/.config/myapp). Do not give it access to ~ blanket. The single most common Claude Code mistake is over-broad filesystem access.

Common gotcha. On Windows, paths need forward slashes inside the JSON config or properly escaped backslashes. The installation errors guide covers this with examples.

2. Sequential Thinking

The reasoning scaffold, indexed on Skiln as Sequential Thinking.

Why it pulls weight in Claude Code. Long-running coding tasks (migrate this module, refactor these 8 files, implement this feature end to end) tend to lose coherence around step 7 to 10 without explicit thinking structure. Sequential Thinking forces the agent to externalize the plan and revise it as the work progresses.

What to configure. The canonical Anthropic build is the right pick. The Tools fork (Sequential Thinking Tools) is worth considering if you have 10+ MCPs installed; the tool-aware reasoning measurably improves tool-selection accuracy. The full ranking is in the best Sequential Thinking MCP servers guide.

3. GitHub MCP (official)

The official GitHub MCP server. The community has multiple forks (githubmcp, GitHubMcpServer) but the GitHub-published one is the default.

What it does. Opens PRs, reads issues, comments on threads, lists workflow runs, downloads action logs, manages branches, and queries the GraphQL API. Effectively, it puts the entire GitHub UI inside Claude Code's reach.

What to configure. Set a fine-grained PAT scoped to the repos you actually work in. Avoid classic tokens; their blast radius is too wide. The official server respects the GitHub rate limit gracefully (5,000 calls/hour for PATs), so heavy use is fine.

Why this MCP matters most. Once the agent can read issues and open PRs, the "code in a vacuum" failure mode disappears. Every coding session can ground itself in the actual ticket and ship its work as a reviewable PR. This is the single MCP that takes Claude Code from "AI pair programmer" to "autonomous contributor."

4. Playwright MCP

The browser automation workhorse. Multiple maintained forks; the executeautomation/mcp-playwright build is the most popular in Claude Code workflows.

What it does. Launches a real Chromium instance, navigates pages, fills forms, clicks, scrapes, screenshots, and runs full E2E tests. Critical for any agent that needs to verify "does the page actually work after my code change?"

When to install. Any project with a frontend. Skip if your stack is backend-only. The headless mode keeps the resource cost low (200 to 400 MB while a session is open).

Alternative. Chrome DevTools MCP, covered in the best Chrome DevTools MCP servers guide, is the right pick if you need DOM inspection or network panel access rather than scripted automation. Most teams want one or the other, not both.

5. Postgres MCP

The canonical Postgres server, indexed on Skiln as Postgres. There are alternatives (Neon Postgres, OpenClaw Postgres) optimized for specific hosts.

What it does. Lets Claude Code introspect schemas, run queries, profile slow ones, and propose migrations grounded in actual table structure. The win is enormous: instead of writing queries from memory, the agent writes queries that compile against your real schema on the first try.

What to configure. Read-only credentials by default. Promote to write only when you trust the workflow (and even then, prefer a separate "migrations" MCP with elevated scope). The default Postgres MCP supports this connection model cleanly.

Why it matters for Claude Code. Any backend project with a database wants this. Without it, every "write a query that does X" prompt risks a schema mismatch. With it, the agent reads the schema and writes correct SQL on attempt one. See the PostgreSQL MCP server guide for setup details.

6. Context7 (documentation)

The documentation MCP, indexed on Skiln as Context7.

Why this one for Claude Code. Of the documentation MCPs, Context7 has the cleanest catalog of popular libraries that show up in coding work. Pair it with Ref (see the best Documentation MCP servers guide) if your stack includes private docs or long-tail OSS.

What it does. Fetches versioned documentation on demand. Claude Code calls it before generating library code so the function signatures and import paths are correct for the version you actually use.

Configuration tip. Add a system-prompt nudge: "Before calling any library function, fetch the docs via Context7." The model will skip the lookup otherwise on simpler prompts.

7. Claude Code MCP (recursive)

Claude Code wrapped as an MCP, indexed on Skiln as Claude Code.

Why this is interesting. It lets one Claude Code session spawn sub-Claude-Code sessions as MCP tool calls. The pattern unlocks parallel work - "run these four independent migrations in four sub-agents and report back" - without you opening four terminals.

Best for. Workflows with independent parallel work. Avoid for serial tasks where the orchestration overhead does not pay off. Most users do not need it; the ones who do find it indispensable.

Watch out for. Recursive Claude Code can rack up token budget fast. Set explicit per-sub-agent token limits in the orchestrator system prompt.

8. Shell Utility MCPs (the small but mighty)

A category, not a single server. The ones worth installing:

• Time / date MCPs for any workflow that needs the current timestamp without relying on the model's stale notion of "today."
• HTTP-fetch MCPs for ad hoc API calls where building a full integration is overkill.
• Search MCPs for web lookups when documentation MCPs do not cover the topic.

Why these matter. The first seven MCPs cover the big workflows. The eighth slot is for the small utilities that fill the gaps in your specific stack. Treat it as a rotating slot - install what your last three Claude Code sessions wished they had, evaluate after a week, swap if it did not earn its keep.

Quick Comparison Table

Installation: ~/.claude.json Walkthrough

Claude Code reads ~/.claude.json (your home directory). Add the recommended stack:

{   "mcpServers": {     "filesystem": {       "command": "npx",       "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/code/your-project"]     },     "sequential-thinking": {       "command": "npx",       "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]     },     "github": {       "command": "npx",       "args": ["-y", "@github/mcp-server-github"],       "env": {         "GITHUB_PERSONAL_ACCESS_TOKEN": ""       }     },     "context7": {       "command": "npx",       "args": ["-y", "@upstash/context7-mcp"]     },     "postgres": {       "command": "npx",       "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://readonly:pw@localhost:5432/yourdb"]     }   } }

Save the file, then run /reload inside Claude Code (or restart the terminal session). Verify with /mcp - all five servers should appear in the list. The desktop installation guide has client-by-client troubleshooting steps; the installation errors guide covers the four issues that catch most first-time installers.

Workflows This Stack Unlocks

The 5-MCP core (Filesystem + Sequential Thinking + GitHub + Context7 + Postgres) handles the workflows that take Claude Code from "AI assistant" to "autonomous contributor":

• Implement an issue end to end. Read the GitHub issue, plan via Sequential Thinking, fetch library docs via Context7, write the code via Filesystem, run tests via shell, open a PR via GitHub. One prompt, no babysitting.
• Migrate a database schema. Introspect the current schema via Postgres MCP, plan the migration, write the migration file via Filesystem, run it against a dev DB, write the rollback. Sequential Thinking keeps the multi-step plan coherent.
• Bug triage. Read the issue, search the codebase via Filesystem, query the DB for the failing record via Postgres, reproduce via Playwright (if it is a UI bug), patch via Filesystem, open a PR via GitHub.
• Code review automation. The agent reviews a PR, fetches the relevant library docs via Context7 to verify API usage, queries the schema via Postgres to verify the query is correct, comments inline via GitHub MCP.
• Dependency upgrade sweeps. Walk through every dependency, read the changelog via Context7, plan the upgrade via Sequential Thinking, apply via Filesystem, open per-package PRs via GitHub.

If you also want to extend this to MCP-powered desktop tooling, see the best desktop MCP servers guide.

What This Stack Will Not Solve

Honest caveats:

• Bad code review. MCPs ground the agent in real data; they do not raise its standards. Pair with linters, tests, and a human gate for anything shipping to production.
• Cost overruns. Each MCP call burns tokens. A 30-tool-call session on Claude 4.7 Sonnet can cost $0.50 to $2.00. Watch your spend; set per-session caps in your wrapper script if you have one.
• Security drift. Filesystem and Postgres MCPs are powerful enough to do damage if scoped too widely. Re-audit your scopes monthly.
• Vendor lock-in feelings. These MCPs work with Cursor, Windsurf, Cline, and the rest. If you migrate off Claude Code, the same stack ports cleanly. The compatibility table in the best MCP clients guide shows which servers work where.

Frequently Asked Questions

What is the minimum MCP stack for Claude Code?

Filesystem, GitHub MCP, and Sequential Thinking. Filesystem so the agent can read and write code, GitHub MCP so it can open PRs and read issues, Sequential Thinking so it plans long tasks instead of improvising. Add Context7 for documentation lookups and you have a credible 4-server stack that handles most agent work.

Are MCP servers different for Claude Code versus Claude Desktop?

The MCP servers themselves are identical, but the right shortlist differs. Claude Desktop is conversation-oriented, so reasoning and retrieval MCPs matter most. Claude Code is task-oriented, so filesystem, git, browser, and database MCPs do more work. The 8 below are the ones that pull weight in Claude Code specifically.

Where do I install MCPs for Claude Code?

Edit ~/.claude.json (the JSON file in your home directory). Add entries under the mcpServers object. Each entry needs a command (usually npx or a path to a binary) and optional args + env. Restart Claude Code with the /reload command or by closing and reopening the terminal session.

Will too many MCP servers slow Claude Code down?

Modestly. Each MCP adds startup time (50 to 500 ms on first call) and a tool definition that takes 50 to 200 tokens in the system prompt. With 8 to 10 servers you will not notice. Above 20, you may see the model getting confused about which tool to call. Most teams settle at 6 to 10 active MCPs.

Can Claude Code use HTTP/SSE MCP servers, or only stdio?

Both. Claude Code supports stdio (default, easiest), HTTP, and SSE transports. The HTTP and SSE options matter when you want a single MCP instance shared across multiple Claude Code sessions or hosted remotely. For solo developer use, stdio is the right choice.

Does Claude Code work with MCP servers that need authentication?

Yes. Most authenticated MCPs (GitHub MCP, Postgres MCP, hosted Ref) read their credentials from environment variables that you set in the mcpServers entry's env field. For OAuth flows, the MCP usually pops a browser window on first use, completes the handshake, and caches the token locally.

Is the official GitHub MCP better than the community forks?

For Claude Code use, yes. The official GitHub MCP (by GitHub) gets feature parity with the GitHub API as it ships, supports fine-grained PAT scopes correctly, and handles rate limiting gracefully. Community forks are useful for niche features but the official one should be the default.

What about MCP servers that wrap Claude Code itself?

They exist (Claude Code MCP) and they are useful for letting one Claude Code session orchestrate sub-tasks via another Claude Code session. The pattern is good for parallel work like 'run these 4 independent migrations in 4 sub-agents.' For everyday solo coding, the recursive setup is overkill.

Last updated: June 06, 2026 · Skiln tracks every MCP server with Claude Code compatibility daily across PulseMCP, Smithery, Glama, LobeHub, OpenClaw, and mcp.directory.