Best MCP Servers for Claude Code (2026)

The best MCP servers for Claude Code are the few that pay for the tool-list slots they consume: GitHub's official server, a docs source to cut hallucinations, a code-research tool, and a package-lookup server. Claude Code speaks MCP natively over stdio, so most of the good options run locally as a subprocess with no proxy. The catch nobody tells you: each server dumps its whole tool list into the model's context, and past roughly 40 tools the model gets vague about which one to call. So the real skill isn't finding servers — it's picking the handful worth the budget.

This is an opinionated shortlist, grounded in what each server actually exposes. I note official vs community, transport, and auth for every pick, because in a young, local-first ecosystem those boring fields matter more than feature lists. Add them with the claude mcp add command or a project .mcp.json; the config generator will spit out a correct snippet if you'd rather not hand-write JSON.

First: the tool-budget rule that decides everything

Before any list, internalize the constraint. Roughly 40 tools is where most MCP clients — Claude Code included — start losing the plot on tool selection. Around 90% of MCP servers run locally over stdio, so adding one is cheap to run but not cheap to think about: every tool it exposes competes for the model's attention on every turn.

Do the arithmetic before you install. Graphlit alone ships 26 tools; add Octocode's 14 and you're already at 40 from two servers. That's the whole reason "install everything" fails — it's a portfolio problem, not a per-server one. The cursor tool-limit math works the same way in Claude Code. My rule: three or four servers, and if a server exposes 20+ tools it has to be earning its keep as your primary workflow, not a maybe.

GitHub MCP Server — the one non-negotiable

If Claude Code touches your repos, install GitHub's official server and stop shopping. It's genuinely first-party (built by GitHub, not a community wrapper), which is what you want for something holding a token with write access to your code. It covers repos, issues, PRs, and Actions.

It's a stdio server that runs in Docker and authenticates with a personal access token. Two things to get right:

• Mint a fine-grained PAT scoped to only the repos you actually work in. A default token grants broad read/write across everything you can see — a bad trade for an agent with tool access. This is the single most important security move in your whole setup; more in MCP security: what actually matters.
• The hosted remote variant uses OAuth and never stores your PAT locally. If your org prefers that, take it — the trade-off is the usual local vs remote one.

Minimal local config:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<your-fine-grained-pat>" }
    }
  }
}

GitMCP — free, zero-auth, kills library hallucinations

When Claude Code invents an API that a library never had, GitMCP is the fix. It turns any public GitHub repo into a live documentation source the model can fetch on demand, so it grounds answers in the actual README, llms.txt, and docs instead of its training-cutoff memory.

This is the rare remote pick I keep. It's a hosted SSE service at https://gitmcp.io/docs with no auth — no credentials leave your machine, so it's safe by construction, but it only ever sees public content. It's community-maintained, not official. Point it at a repo whose docs you trust and it earns its slot the first time it stops the model from confidently making up a function signature. This is grounding, not a general API bridge — for why that distinction matters, see MCP vs API. Grounding beats guessing, full stop.

Octocode — code research, not just code search

Reach for Octocode when you need Claude Code to understand an unfamiliar codebase, not just grep it. It wires GitHub search, local filesystem, and package-registry lookups (npm, PyPI) into one research loop, so the model can trace how a pattern is actually used across repos before it writes anything.

It's a stdio server (npx octocode-mcp@latest) authenticating via a GitHub OAuth device flow — run octocode login once, and it supports GitHub Enterprise via --hostname. It's community-built and exposes 14 tools, which is a real chunk of your budget. Justify it: keep it when your work is reading and comprehending large or foreign codebases; skip it if GitHub's server already covers your day-to-day.

Package Registry MCP — the cheap, obvious win

Add Package Registry MCP so Claude Code stops guessing at version numbers and dependency names. It searches npm, crates.io, NuGet, PyPI, and Go registries — plus GitHub Security Advisories — for current package info the model otherwise hallucinates from stale training data.

It's stdio, community-maintained, and needs no auth (npx package-registry-mcp). At 16 tools it's not free budget-wise, but the payoff is concrete: correct versions in your package.json, and a real vulnerability check before you pin a dependency. This is the one I'd add second, right after GitHub.

Two situational picks: Anyquery and Graphlit

Add these only when the job actually calls for them — both are heavier than they look. Anyquery lets Claude Code run SQL over files, databases, and 40+ apps (GitHub, Notion, Chrome, Todoist). It's a stdio, no-auth Go binary (brew install anyquery). The sharp edge: its executeQuery tool can run INSERT/UPDATE/DELETE on sources that support writes, so the model can mutate connected data. Point it at read-only sources unless you mean it.

Graphlit is a RAG/ingestion server — pull in and search content from Slack, Discord, Google Drive, GitHub, Jira, and Linear. It's stdio but needs Graphlit API credentials (org ID, environment ID, JWT secret) and ships 26 tools, which by itself is most of your budget. Only add it if cross-source retrieval is the task; otherwise it drowns out everything else.

Quick comparison

Server	Official?	Transport	Auth	Tools	Add it when
GitHub	Official	stdio (Docker)	PAT / OAuth (remote)	~toolsets	Claude Code touches your repos
GitMCP	Community	remote SSE	None	7	Library docs / stopping hallucinations
Octocode	Community	stdio	GitHub OAuth	14	Researching unfamiliar codebases
Package Registry	Community	stdio	None	16	Correct versions + advisories
Anyquery	Community	stdio	None	few	SQL across files/apps (writes possible)
Graphlit	Community	stdio	API keys	26	Cross-source RAG is the job

What to skip (and how to add these)

Skip anything that duplicates a tool you already have, and skip the 20-plus-tool servers unless they're your main workflow — two of them and you've blown the budget with nothing left for GitHub. Skip "kitchen-sink" servers that bundle a dozen unrelated integrations; you pay attention-tax on every tool whether you use it or not.

To install, use claude mcp add for a quick global add, or commit a project-level .mcp.json so your team shares the same setup — see how to add an MCP server for both. Browse the full best MCP servers list or the servers for coding agents cut if your stack differs, and check the Claude client hub for config paths across the Claude family. My default starter set for Claude Code: GitHub + Package Registry + GitMCP — three servers, well under budget, and it fixes the failures you hit most.