Skip to content
Capital & Compute
· ai· coding-agents· tools

The Only MCP Servers Worth Installing in 2026

Most MCP server lists are directory dumps. The tested consensus is five servers, a strict tool budget, and three catalogs worth bookmarking.

By Capital & Compute

PulseMCP, one of the ecosystem’s larger directories, indexes 20,115 MCP servers as of July 2026. The best MCP servers question has a much shorter answer than that number suggests: independent testers keep converging on the same five, and the interesting problem is not which servers to add but how many tools your agent can carry before it gets worse at its job.

That second problem has hard numbers attached. Cursor silently stops offering tools to its agent past a documented ceiling of about 40, and every tool definition you load is context the model reads on every request. An MCP server is not a free upgrade. It is a purchase, paid in the scarcest resource an agent has.

What are the best MCP servers?

The best MCP servers for developers in 2026, where every independent tested ranking converges, are:

  • GitHub MCP (official): issues, pull requests, and code search
  • Context7 (Upstash): live, version-specific library documentation
  • Playwright MCP (Microsoft): browser automation and UI self-verification
  • Postgres MCP Pro (Crystal DBA): schema-aware SQL with a read-only mode
  • Sentry MCP (official, hosted): production errors and stack traces

Independent testing also converges on running three to six servers total, because every extra tool definition consumes agent context. The table adds the number that matters for that budget: what each server costs in tools at default settings.

Server Best for Maintainer Default tool load
GitHub MCP Issues, PRs, code search GitHub (official) 42 tools across 5 default toolsets
Context7 Version-correct library docs Upstash 2 tools
Playwright MCP Browser automation, UI verification Microsoft (official) 23 tools default, 68 with all flags
Postgres MCP Pro Schema-aware SQL, index tuning Crystal DBA Read-only mode available
Sentry MCP Production errors in the fix loop Sentry (official, hosted) Remote, OAuth

That table is the destination. The route matters more, because the reason these five win is the same reason most of the other 20,000 lose.

The tool budget: why more servers make the agent worse

Here is the mechanism the listicles skip. When an MCP server connects, its tool definitions enter the model’s context. Names, descriptions, parameter schemas. The agent reads them on every request whether it uses them or not, and past a point, the catalog itself becomes the problem: the model picks between lexically similar tools less reliably as the count grows.

The vendors say this themselves now. GitHub’s own server README recommends trimming its toolsets because “enabling only the toolsets that you need can help the LLM with tool choice and reduce the context size” (the github-mcp-server documentation, 2026). When the company shipping the most popular official MCP server tells you to load less of it, believe them.

Cursor made the constraint concrete. Community threads on the Cursor forum documented a hard limit of 40 tools across all connected servers: go past it and the excess tools remain visible in settings while silently disappearing from what the agent can call. Claude Code took a different route, deferring full tool schemas until a tool is actually needed, a loading model covered in detail in the Claude Code harness guide on this site. Different mitigations, same underlying economics.

Now price the consensus picks against that 40-tool budget, using tool counts taken directly from each project’s README on July 2, 2026. The github-mcp-server documentation lists 42 tools across its five default toolsets. Microsoft’s Playwright MCP documentation lists 23 tools in its default profile and 68 with every optional capability flag enabled. Context7 adds 2. Just the trio, at defaults, comes to 67.

Spending a 40-tool budget on three default installsWaterfall: GitHub MCP default toolsets add 42 tools, Playwright MCP defaults add 23, Context7 adds 2, for 67 tools loaded in total. A gold marker shows the 40-tool ceiling Cursor documents, which the three defaults exceed by 27 tools.0 tools20 tools40 tools60 tools80 toolsGitHub MCP5 default toolsets+42 toolsPlaywright MCPdefault profile+23 toolsContext7+2 toolsTotal loaded67 toolsCursor ceiling: ~40 tools
Spending a 40-tool budget on three default installs
StepChangeRunning total
GitHub MCP (5 default toolsets)+42 tools42 tools
Playwright MCP (default profile)+23 tools65 tools
Context7+2 tools67 tools
Total loaded67 tools67 tools
Cursor ceiling: ~40 tools40 tools67 tools
The consensus trio at default settings loads 67 tool definitions. Cursor documents a ceiling of about 40 active tools; everything past it silently drops out of the agent.Source: Tool counts from the GitHub, Playwright, and Context7 READMEs, July 2, 2026

Two of the most recommended servers on the internet, installed at defaults, already bust the budget before your third pick. That is not an argument against them. It is an argument for configuring them: GitHub down to the toolsets you use, Playwright without the optional flags, and nothing installed that cannot name the recurring task it serves.

An MCP server is not a free upgrade. It is a purchase, paid in the scarcest resource an agent has.

This is why the practical guidance from people who actually run these things sounds so conservative. The tested roundups at Nimbalyst and Codersera (both 2026) land on three to six servers for most developers, added one at a time when a real need appears, removed when the agent stops calling them. Not because more servers cost money. Because they cost accuracy.

The consensus five

Every credible tested list this year, and this site read the major ones side by side, converges on the same core. The evaluation frame below is consistent: what the server does, why it earns a slot in a 40-tool budget, and the caveat that usually goes unmentioned.

1. GitHub MCP: the agent joins the PR workflow

The official GitHub MCP server (31.1k stars, July 2026) turns an agent from a code generator into a participant: it reads issues, reviews pull requests, searches across repositories, and inspects CI runs without leaving the editor. GitHub hosts a remote endpoint at api.githubcopilot.com/mcp/, so the zero-install path is real.

Why it earns the slot: issue and PR context is the highest-value external state most coding agents lack, and this is the vendor-maintained way to get it. The archived Anthropic reference server it replaced is exactly that, archived.

The caveat: if you live in Claude Code with the gh CLI already authorized, you have most of this through shell access, and the marginal value shrinks. And as charted above, its five default toolsets (context, repos, issues, pull requests, users) already carry 42 tools; trim to the groups you use and leave the other toolsets off until a task demands them.

2. Context7: documentation that matches your installed version

Context7, maintained by Upstash and sitting at 58.5k stars as of July 2026, attacks the single most common failure of AI-written code: APIs hallucinated from stale training data. It resolves a library name and pulls current, version-specific documentation into the prompt at answer time. Free to use, with an optional API key for higher rate limits.

Why it earns the slot: two tools. That is the entire context price for eliminating the “trained on React 17, you run React 19” class of bug, which makes it the best cost-benefit ratio on this list. Frontend or backend, it does not matter; every stack has fast-moving dependencies.

The caveat: coverage tracks the popularity of the library. Obscure internal frameworks get nothing, and you are trusting a third party to inject text into your prompts. Keep that in mind in security-sensitive environments.

3. Playwright MCP: the agent checks its own UI work

Microsoft’s Playwright MCP (34.6k stars) gives the agent a real browser: navigate, click, type, read the accessibility tree, screenshot. The practical effect is an agent that can verify its own frontend changes instead of declaring victory after the code compiles.

Why it earns the slot: for frontend work, self-verification is the difference between an agent that ships working UI and one that ships plausible UI. Nothing else on this list closes that loop.

The caveat is the price tag charted above: 23 tools in the default profile, 68 once the optional capability flags for vision, PDF, devtools, network, storage, and testing are all on. This is the server to enable per project and configure deliberately, not to leave running globally. Keep the flags off until a task needs them.

4. Postgres MCP Pro: schema-aware answers, read-only by default

The original reference Postgres server is archived, and Postgres MCP Pro from Crystal DBA (3k stars) is the maintained successor worth installing. It goes past raw SQL access: database health checks, EXPLAIN plan analysis with hypothetical index simulation, and index tuning that uses classical search algorithms rather than letting the model guess.

Why it earns the slot: backend agents without schema access write queries by vibes. With it, the agent joins the debugging loop, and the restricted read-only mode makes that sane in production-adjacent environments.

The caveat: point it at a read replica anyway. An agent with database credentials is an incident report waiting on a permissions mistake, and read-only mode is a config flag, not a law of physics.

5. Sentry MCP: production errors close the loop

Sentry runs an official hosted MCP server at mcp.sentry.dev with OAuth, so the agent can pull real production issues, stack traces, and error context into the conversation where the fix is being written.

Why it earns the slot: it connects the two halves of the job that usually live in different tabs. The alert says where it broke; the agent is already sitting in the code that broke. Remote and OAuth-based also means no local process and no API key pasted into a config file.

The caveat: it matters exactly as much as your Sentry usage does. No Sentry, no slot; this one is conditional on your stack, which is why some rankings swap it for a database or search server.

The situational tier

A second group is genuinely useful when a specific condition holds, and dead weight otherwise.

  • Linear, Slack, and Notion: team context servers. Worth a slot when your tickets, threads, and specs hold information the agent needs mid-task. Solo developers can skip all of them.
  • Figma: the official server translates design context into code. High value for design-system work, irrelevant if no one hands you Figma files.
  • A search server (Exa or Brave): useful if your harness lacks built-in web search. Claude Code has search built in, so adding one there mostly creates tool-choice confusion. If you add one, add exactly one; duplicate search tools make the agent flip between near-identical names.
  • SQLite: local database inspection with near-zero setup. Cheap enough that the usual caution barely applies.
  • Supabase and Neon: official servers for their hosted Postgres platforms. If your database lives there, prefer the vendor server over a generic one.

The pattern across the tier: each server is justified by a recurring task, not by capability in the abstract. The scaffolding guide to agent harnesses makes the general version of this argument; MCP is just the layer where over-provisioning is easiest.

Three servers appear on nearly every list and deserve skepticism, not because they are broken but because 2026 harnesses made them redundant.

Filesystem sits at or near the top of nearly every recommendation list, and if your client is Claude Code, Cursor, or any modern coding agent, you already have file tools. Adding an MCP layer duplicates built-in capability and spends tool budget on it. It exists for MCP clients without native file access, which yours is probably not.

Memory, the knowledge-graph reference server, overlaps with the persistent memory that clients now ship natively. It also only learns what you actively tell it, which in practice means it mostly stays empty.

Sequential Thinking structures multi-step reasoning for models that need external scaffolding. Frontier models in 2026 plan natively, and testers now describe the server as latency without payoff, situational at best.

All three live on in the official reference repository, which is worth reading for a different reason: its archive section. The project moved a long row of once-standard servers (PostgreSQL, GitHub, Slack, Puppeteer, Brave Search among them) to an archived repository, with maintained successors named where they exist. Half the MCP tutorials on the internet still point at those archived servers. Check the maintenance status before you install anything, including anything on this page.

Where the full catalogs live

Sometimes you genuinely need the long tail: an embedded-systems server, a Bloomberg-shaped finance tool, something for a niche SaaS. Three resources cover it.

  1. punkpeye/awesome-mcp-servers: the canonical community list, roughly 800+ servers across 50+ categories as of July 2026. Breadth-first; curation is inclusion, not ranking.
  2. best-of-mcp-servers: 400 servers in 34 categories, ranked by an automated project-quality score and updated weekly. The closest thing to a maintained answer to “is this server alive?”
  3. mcpservers.org: a searchable directory with per-client install commands, useful once you know what you want.

Treat the catalogs as a warehouse, not a shopping list. The failure mode is browsing one and installing six interesting things; every one of them bills your tool budget from that day on.

Operating rules that outlast any ranking

Server rankings rot. These rules have held all year:

  1. Run three to six servers. Past roughly ten, tool selection measurably degrades and you are tuning noise.
  2. Count tools, not servers. One maximal Playwright outweighs five lean single-purpose servers.
  3. Enable heavy servers per project. Browser automation belongs in frontend repos, not in your global config.
  4. One search server, maximum. And zero if your client has native search.
  5. Prefer official remote endpoints (GitHub, Sentry) over community processes. OAuth beats API keys pasted into JSON.
  6. Keys go in environment variables, never committed in .mcp.json.
  7. Audit monthly: remove any server the agent has stopped calling. Silence is the signal.

For how MCP fits alongside skills, hooks, and subagents inside a full agent setup, the Claude Code harness guide covers the loading mechanics, the broader economics live in the 2026 coding-agent landscape, and the agents these servers plug into are mapped on the AI coding agents hub.

Frequently asked questions

What is an MCP server?
An MCP (Model Context Protocol) server is a program that gives an AI agent structured access to an external system, such as GitHub, a database, or a browser, through a standard set of tools the agent can call. MCP is an open protocol, so one server works across clients like Claude Code, Cursor, and other MCP-compatible agents.
How many MCP servers should I run?
Three to six for most developers. Every connected server adds tool definitions to the agent context, and tool selection degrades as the count grows; Cursor documents a ceiling of about 40 active tools in total. Add one server when a recurring need appears and remove any server the agent stops calling.
Do MCP servers slow down Claude Code or Cursor?
They can. Tool definitions consume context on every request, and in Cursor, tools past the roughly 40-tool limit silently become unavailable to the agent. Claude Code defers full tool schemas until a tool is needed, which softens the cost but does not remove the value of keeping the server count low.
Are MCP servers free?
The servers themselves are almost all free and open source, including everything recommended here. Costs come from the services behind them (a Sentry plan, a hosted database) and from optional rate-limit tiers, such as the Context7 API key for heavier use.
Do I need the Filesystem MCP server with Claude Code?
No. Claude Code ships native file reading, writing, and editing tools, so the Filesystem server duplicates built-in capability and spends tool budget doing it. It exists for MCP clients that lack native file access.

Bottom line

Install GitHub and Context7. Add Playwright when you touch frontend, Postgres MCP Pro when the agent needs your schema, Sentry if you run Sentry. Budget tools like the scarce resource they are, check maintenance status before trusting any list (this one included), and let the two big catalogs stay bookmarks instead of shopping lists. The best MCP setup is the smallest one that covers your recurring tasks.

Sources

Subscribe to Capital & Compute

Source-backed analysis of what AI compute really costs, sent when a new post goes live.

No spam. Unsubscribe anytime.

← Back to all posts