This article was originally published on aicoderscope.com

The verdict up front: Context7 and GitHub MCP belong in every setup. Add Playwright if you write tests, Supabase or Postgres if your agent touches a database, and Linear or Sentry if your team uses them. That is a 3-to-5-server stack covering 90% of real coding workflows. Beyond 7 total MCP servers, Cursor's 40-tool ceiling degrades agent accuracy faster than the extra integrations help.

The MCP ecosystem grew from roughly 6,800 public servers at year-end 2025 to more than 9,400 by mid-April 2026 — the official modelcontextprotocol/servers reference repository alone has crossed 86,000 GitHub stars. The problem is not access; it's selection. Most MCP servers listed in directories look useful until you actually try to use them with an AI coding agent. Context window costs are real, tool selection accuracy drops with every additional server you add, and many community servers expose duplicate functionality from different angles. This article skips the directory padding and covers only servers that have been verified to work, are actively maintained, and solve a concrete problem in a daily coding workflow.

What MCP actually does for a coding agent

Model Context Protocol is an open standard, developed by Anthropic and now governed as an independent specification, that defines how AI tools call external services. Without it, every IDE integration is a custom API wrapper — GitHub in Cursor uses different plumbing than GitHub in VS Code Copilot. With MCP, you configure a server once and it works across every MCP-compatible client: Cursor, Claude Code, Windsurf, VS Code with Copilot, Continue.dev, Cline, and others.

For coding work, MCP matters on two dimensions. The first is grounding: your agent can read fresh API documentation, query your live database schema, or pull the current state of a GitHub issue rather than hallucinating from stale training data. The second is action: the agent can create GitHub branches, run browser-based tests against your staging URL, update Linear issues, or invoke Sentry's root cause analysis — all within a single task, without you copying context between tools.

Without MCP, you manually feed context. With it, the agent fetches what it needs. The difference on a task like "fix the bug in issue #847 and write a regression test" is the difference between 4 context switches and 0.

How to wire MCP into Cursor, Claude Code, and Windsurf

The configuration files and commands differ by tool. Get these paths right before copying any config.

Cursor

Cursor reads from two locations. Global configuration (applies to all projects) goes in ~/.cursor/mcp.json. Project-scoped configuration goes in .cursor/mcp.json at the repository root and overrides global. Cursor requires version 0.48.0 or later for Streamable HTTP servers; all stdio-based servers work on any recent version.

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/name@latest"],
      "env": { "API_KEY": "your-key-here" }
    }
  }
}

Restart Cursor after editing. Cursor applies changes only on restart — there is no hot-reload for MCP config.

Claude Code

Claude Code manages MCP through the CLI and stores config in ~/.claude/settings.json (user scope) or .claude/settings.json in the project root (project scope). Three scope levels exist: user, project, and local. Local scope is gitignored by default — use it for personal API tokens. (For a broader Claude Code setup reference, see the Claude Code power user guide.)

# Add a stdio server at user scope
claude mcp add context7 -s user -- npx -y @upstash/context7-mcp@latest

# Add an HTTP server
claude mcp add-json github --scope user \
  '{"type":"http","url":"https://api.githubcopilot.com/mcp/","headers":{"Authorization":"Bearer YOUR_PAT"}}'

# List configured servers
claude mcp list

# Test a specific server
claude mcp test context7

Windsurf

Windsurf stores MCP configuration in ~/.codeium/windsurf/mcp_config.json. The Cascade panel also includes a built-in MCP Marketplace (Settings → Cascade → MCP Servers) with one-click installs for common servers. Windsurf's tool ceiling is 100 — the most permissive of the three tools — but agent accuracy still degrades past 50 active tools. Enable MCP under Settings → Cascade → Model Context Protocol before the config file takes effect.

The 40-tool ceiling problem

Cursor has a hard limit of 40 active tools across all connected MCP servers. Hit it and Cursor logs a warning; the agent silently loses access to tools past the cutoff, and the behavior is nondeterministic — you do not know which tools got cut.

Claude Code's practical ceiling is lower than Windsurf's 100-tool limit but higher than Cursor's 40 — community reports suggest reliable performance up to about 50 tools before selection accuracy drops noticeably. The GitHub issues tracker has an open request for per-tool enable/disable filtering, which would help, but it is not yet shipped.

One server exposing 20 tools plus four others at 10 tools each = 60 tools. You have already blown Cursor's budget with 5 servers. The implication: pick servers that expose compact, focused tool sets over servers that expose every API endpoint the integration supports. Context7 exposes 2 tools. The GitHub MCP server exposes 46. If you are on Cursor, the self-hosted Docker GitHub server exposes more than 40 tools on its own — meaning it blows the entire budget before you add anything else. You must use the hosted remote version (https://api.githubcopilot.com/mcp/) which exposes a focused subset, not the Docker version.

Tool count per server (approximate — counts shift across versions):
| Server | Tool count | Notes |
|---|---|---|
| Context7 | 2 | Compact by design |
| GitHub MCP (remote hosted) | ~20 | Remote endpoint exposes a focused subset |
| GitHub MCP (Docker self-hosted) | 46+ | Full API surface, exceeds Cursor's limit alone |
| Playwright MCP | ~20 | Navigation + click + input + screenshot |
| Supabase MCP (hosted) | ~15 | Read + write + schema tools |
| Sequential Thinking | 1 | Single reasoning tool |
| Linear MCP | ~15 | Issues + projects + comments |
| Sentry MCP | ~10 | Issues + events + Seer AI |

The Docker-hosted GitHub MCP server exposes more than 40 tools on its own — blowing Cursor's entire budget before adding a single other server. The practical move: use the hosted/remote variants where available (GitHub, Supabase, Linear, Sentry all offer them), which expose trimmed tool sets, and reserve the full Docker-hosted versions for Claude Code and Windsurf.

The 7 MCP servers worth installing

1. Context7

What it does: Fetches current, version-specific documentation for any library or framework and injects it directly into the agent's context. When your agent writes code using React 19, Pydantic v2, or FastAPI 0.115, it reads the actual current docs — not training data from 18 months ago.

Why it matters: The single most common source of hallucinated code in AI coding agents is outdated API knowledge. A library changes its import path, deprecates a function signature, or ships a breaking change in a major version bump, and the agent silently writes code against the old API. Context7 eliminates this by fetching live docs at query time.

The project has 55,700 GitHub stars and works with Cursor, Claude Code, Claude Desktop, VS Code Copilot, Windsurf, Cline, and 30+ other MCP-compatible clients. Use it by appending use context7 to any prompt: "rewrite this fetch handler with the SvelteKit 2.x routing API, use context7."

Cursor / Windsurf config:

json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest