Best MCP Servers for Claude Code, by Job

The Short Answer

The best MCP server is the one that does the job in front of you, so shortlist by job, not by stars. If the agent keeps grepping the same code, you want a search server. If it needs to test a flow, you want a browser or QA server. If it forgets your project every session, you want a memory server. The table below maps each job to the servers covered here; the sections after it give the detail.

How to add any MCP server. Claude Code registers servers from the command line. The pattern is the same every time, and the scope flag decides who gets it.

# Every MCP server install has the same shape:
claude mcp add <name> -- <command and args>

# Pick a scope:
#   --scope user      available in every project you open (personal)
#   --scope project   written to .mcp.json and committed, so your team gets it too

# Real example — Microsoft's Playwright browser server:
claude mcp add playwright npx @playwright/mcp@latest

# Check what you have wired up:
claude mcp list

New to MCP? Our MCP setup walkthrough covers the wiring step by step. One note before the list: “best by job” here is not a ranking. These are servers worth knowing, grouped so you can pick the one that fits.

Code Understanding & Search

Coding agents waste turns rediscovering the same code: grep, read a file, grep again. Two servers attack that from different angles. One searches by meaning; the other maps how code connects.

Claude Context

What it does. Zilliz's open-source MCP server indexes your repository into a Milvus or Zilliz Cloud vector database, then exposes hybrid search that combines dense embeddings (meaning) with BM25 (exact identifiers).

The job it solves. Asking “find the functions that verify webhook signatures” and getting the right chunks back, instead of the agent loading whole directories. On a large repo that is real token savings; the project reports roughly 40% token reduction on its own benchmark.

Caveat. It needs a vector database. Managed Zilliz Cloud is the easy path; self-hosting Milvus works but adds operational load. The local index snapshot can drift out of sync, and exact symbol lookup is not guaranteed — a real language server still wins for jump-to-definition. Overkill for a small repo where grep is already fine.

Read more: the Claude Context guide (architecture, real bugs, and when grep still wins).

CodeGraph

What it does. CodeGraph parses your repo into a local SQLite knowledge graph of files, symbols, calls, imports, and routes using tree-sitter, then exposes graph tools to the agent: context, trace, callers, callees, and impact.

The job it solves. Structural questions. “What calls this function?” “How does an auth request reach the database?” “What breaks if I rename this?” The agent queries the graph once instead of rebuilding the same mental map every session. This is the “code knowledge graph” angle, distinct from Claude Context's semantic search.

Caveat. Local-first, so nothing leaves your machine, but setup is two steps: wire the MCP server and index the repo, or it looks broken. Resolver quality decides correctness — a false “0 callers” can be worse than no answer — so treat graph results as strong context, not proof. Watch-mode can leak resources on very large trees.

Read more: the CodeGraph guide.

Browser & Web Automation / QA

These give the agent hands and eyes inside a running app, so it can click, type, and check what actually happened. One is the web standard; one stretches to mobile.

Playwright MCP (Microsoft)

What it does. Microsoft's browser server drives Chromium through Playwright. It works from the page's accessibility tree rather than pixels, so the agent can navigate, click, fill forms, watch or mock network requests, manage cookies, and take screenshots.

The job it solves. Web automation and web QA. It is the most widely documented browser MCP for Claude Code, which makes it the default choice when the target is a website. Install it with claude mcp add playwright npx @playwright/mcp@latest.

Caveat. Web only — there is no native mobile here. It needs a current Node.js (18 or newer as of 2026). And it is a capability, not a test plan: the agent can drive the browser, but you still decide what “passing” means.

Read more: the official Playwright MCP docs, and our QA workflow with Claude Code.

Watchr

What it does. Watchr (the watchr-mcp package) turns Claude Code into a plain-English QA agent across iOS, Android, and web. No scripts, no selectors. It auto-detects the target — iOS Simulator, a physical device, an Android emulator, or headless Chromium via Playwright — and runs audits for accessibility, performance, visual regression, and crashes.

The job it solves. Cross-platform QA without an Appium or XCUITest suite. You say “test the checkout flow I just changed on iOS and tell me what broke,” and it taps through, watches the network, and reports back with screenshots. The mobile-plus-web coverage is its least-crowded edge.

Caveat. Pre-1.0 software as of 2026, so expect rough edges and change. The “30 to 60% QA time saved” figure is the vendor's own, not an independent benchmark, and the commercial model is still unclear. Do not confuse it with the unrelated watchr.ai product.

Read more: the Watchr deep dive and the QA workflow guide.

Memory & Persistence

Agents are stateless: each session starts cold. A memory server records what happened, compresses it, and feeds the relevant parts back next time, so you stop re-explaining the project. Two strong options, both local-first.

Claude-Mem

What it does. Claude-Mem captures tool usage through lifecycle hooks, compresses each session into semantic summaries, and injects relevant context at the start of the next one. It stores everything locally in SQLite plus a vector index and exposes search tools with progressive disclosure, so the agent pulls only the detail it needs.

The job it solves. The blank-slate problem. Past decisions, bug fixes, and rejected approaches carry over, so the agent does not suggest the fix you already tried. It is one of the most adopted memory plugins in the Claude Code ecosystem.

Caveat. It is a full system: a background worker, plus Bun and a Python tool for vector search. Install with npx claude-mem install, not a bare global npm install, which only fetches the library. It targets Claude Code and Gemini CLI, not Cursor or Windsurf, and it is AGPL-3.0 licensed.

Read more: the Claude-Mem guide.

Agentmemory

What it does. Agentmemory is a local memory runtime that captures sessions through hooks, MCP, or REST, then indexes them with BM25, vector, and graph search fused together. It serves bounded context blocks back to the agent and ships a web viewer for browsing what it recorded.

The job it solves. Persistent memory that is not tied to one agent. It works across Claude Code, Codex, Cursor, Gemini CLI, and other MCP clients — useful if you move between tools and want one memory layer underneath.

Caveat. Pre-1.0 as of 2026. Basic capture runs without an API key, but richer LLM-backed compression needs a provider configured, which is a common source of setup confusion. Its benchmarks are first-party retrieval numbers, not independent full-task results.

Read more: the Agentmemory deep dive.

Files & Version Control

These are the two official reference servers from the MCP project itself. Claude Code already reads files and runs git in the shell, so these matter most when you want access that is scoped, structured, or available to clients without those native tools.

Filesystem (official)

What it does. The official Filesystem server provides file operations with configurable access controls. You pass it the directories it is allowed to touch: npx -y @modelcontextprotocol/server-filesystem /path/to/allowed.

The job it solves. Giving an agent (or an MCP client without built-in file tools) read and write access to a specific, sandboxed set of folders rather than the whole disk.

Caveat. Inside Claude Code it overlaps with native file tools, so its real value is the access boundary. Scope the allowed paths deliberately; an over-broad allow-list is a foot-gun.

Git (official)

What it does. The official Git server exposes tools to read, search, and manipulate Git repositories. It is a Python server, run with uvx mcp-server-git.

The job it solves. Letting the agent inspect history, diffs, and branches as a defined tool surface instead of free-form shell commands — handy in clients without shell access, or when you want git actions to be explicit and reviewable.

Caveat. If you already let the agent run git in a terminal, this adds little. Reach for it when a structured, permissioned git interface is the point. Both servers are listed on the official MCP reference servers page.

Payments & Spending

A newer category: servers that let an agent pay for something — a metered API, a per-call service — using rails built for machines. The two names to know are x402 (Coinbase's revival of the HTTP 402 status code for stablecoin micropayments) and MPP, the Machine Payments Protocol from Stripe and Tempo. An MCP server using one of these rails can charge for a tool call the agent makes.

The job it solves. Autonomous spend: the agent buys what it needs to finish the task without you in the loop for every charge.

Caveat. This is the one place to be slow. An agent should never hold a raw key or card, because a single hostile instruction can drain it. Put every payment behind a policy gate that enforces caps, an allow-list of payees, and human approval above a threshold. The how is in giving an AI coding agent a budget, and the why — the protocols and players — is in agentic payments, explained.

How to Choose

Resist the urge to install everything. Stacking context servers can make your agent harder to debug before it makes it faster. A short method that holds up:

• Start from the bottleneck. Name the thing the agent keeps doing badly — losing context, re-grepping, failing to test — and add the one server that targets it.
• Measure one real task. Run the same task with and without the server. Watch tool calls, time to a useful answer, and how often you correct it.
• Prefer local-first for private code. If source cannot leave your machine, weight CodeGraph, Claude-Mem, and Agentmemory over anything that ships code to a hosted index.
• Match the tool to the job, not the hype. Semantic search and a code graph solve different problems; a web driver and a cross-platform QA agent are not interchangeable.

A Security Caveat

An MCP server is code that runs as a tool your agent can invoke with your permissions. Depending on what it exposes, that can mean reading your files, making network calls, or running commands on your machine. A sloppy or malicious server is both a supply-chain risk and a prompt-injection surface: hostile text the agent reads could try to steer it into calling a tool you did not intend.

So vet a server before adding it. Prefer official or well-known sources, read what tools and permissions it asks for, and scope it to a project rather than all of your machine when you can. For anything that touches money or secrets, do not trust the agent's judgment — put a gate in front of the action, as in the budget guide.

FAQ

Sources

Protocol and official-server facts come from the MCP and Playwright docs; each tool's details come from its own site and our deep dives, linked below.

• Model Context Protocol — official site and reference servers
• Playwright MCP — getting started (Microsoft)
• Watchr — official site (Affinity Labs)

Further reading on this site

• Claude Context: semantic code search
• CodeGraph: local code knowledge graph
• Watchr: QA agent for iOS, Android, and web
• How to QA an app with Claude Code
• Claude-Mem: persistent memory
• Agentmemory: memory across agents
• Give your AI coding agent a budget
• How to set up MCP servers