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:

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

Claude Code:

claude mcp add context7 -s user -- npx -y @upstash/context7-mcp@latest

Get a free API key at context7.com/dashboard for higher rate limits (unauthenticated access is available but rate-limited on large projects).

---

2. GitHub MCP

What it does: Gives the agent direct access to repositories, issues, pull requests, branches, commits, and Actions results — without you copying content into chat.

Why it matters: The context-switching overhead of “paste this issue body into Cursor, then paste the relevant code, then describe the relationship” is the biggest productivity leak in modern AI coding workflows. With GitHub MCP, you say “fix issue #847” and the agent fetches the issue body, the referenced code, and recent related commits on its own.

GitHub’s official server (at ghcr.io/github/github-mcp-server) replaced the now-deprecated npm package @modelcontextprotocol/server-github in April 2025. Use the official version. For Cursor, use the hosted remote endpoint which exposes a focused subset of tools and stays within the 40-tool budget:

Cursor (remote, stays within tool budget):

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

This requires Cursor 0.48.0+ and authenticates through your existing GitHub Copilot session or a Personal Access Token.

Claude Code (Docker, full tool set):

claude mcp add-json github --scope user \
  '{"command":"docker","args":["run","--rm","-i","--env","GITHUB_PERSONAL_ACCESS_TOKEN=ghp_yourtoken","ghcr.io/github/github-mcp-server"]}'

---

3. Playwright MCP

What it does: Drives a real Chromium browser — navigate URLs, click elements, fill forms, capture screenshots, run accessibility checks — from inside your coding agent.

Why it matters: Writing browser automation without running the browser is guesswork. Playwright MCP closes the loop: your agent can scaffold a test, run it against your staging URL, see what breaks, fix the selector, and re-run — all in one session. It also helps with tasks like “check that the checkout flow still works after the API change.”

The server uses structured accessibility snapshots rather than screenshots, which means it works accurately with standard text-based models — no vision-tuned model required. The microsoft/playwright-mcp repository has 30,873 GitHub stars. Microsoft now recommends using the CLI backend over MCP for pure coding-agent workflows (4× fewer tokens per session), but the MCP version remains the right choice for interactive workflows where you want to see what the agent is doing and intervene.

Cursor / Windsurf / Claude Code:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

First run downloads the package and a Chromium binary automatically.

---

4. Supabase MCP

What it does: Connects the agent directly to your Supabase project — read and write data, inspect table schemas, run migrations, and generate SQL.

Why it matters: Database-adjacent tasks (adding a column, fixing a query, writing a migration) are high-friction in AI coding tools today. Without database access, the agent writes migrations against schema it inferred from your application code — which lags behind the actual DB state. With Supabase MCP, it reads the live schema.

Supabase ships an official hosted remote server and an npm package (@supabase/mcp-server). The hosted version uses OAuth — no long-lived tokens on disk. Scope to a single project to prevent the agent from touching other projects in your org.

Cursor / Windsurf (hosted, read-write):

{
  "mcpServers": {
    "supabase": {
      "type": "http",
      "url": "https://mcp.supabase.com/mcp"
    }
  }
}

Cursor / Claude Code (npm, single project, read-only):

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server@latest",
               "--project-ref", "abcdefghijklmn",
               "--read-only"]
    }
  }
}

Add --read-only until you are confident your prompts won’t accidentally trigger writes. Upgrade to read-write only when you specifically need migration generation.

---

5. Sequential Thinking

What it does: Adds a structured multi-step reasoning tool to the agent — the agent can break a problem into a chain of dependency-ordered thoughts before generating code.

Why it matters: For complex tasks (architecture decisions, debugging subtle state bugs, redesigning an API across multiple services), a single-shot prompt to a coding agent often produces shallow results. Sequential Thinking forces a deliberate reasoning pass that meaningfully improves output quality on problems with more than 3-4 interacting constraints. Anthropic maintains this server in the official reference repository.

This is the most “infrastructure” pick on this list — you do not invoke it explicitly. The agent chooses it automatically when it detects a complex problem. It exposes 1 tool, so it costs almost nothing against Cursor’s 40-tool budget.

Cursor / Windsurf / Claude Code:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

---

6. Linear MCP

What it does: Connects the agent to your Linear workspace — read issues, projects, and cycle state; create issues; update status; add comments.

Why it matters: For teams using Linear, the workflow gap today is that AI coding tools have no awareness of sprint state. You describe a task to the agent that is already tracked as an issue — and you re-describe it from scratch. Linear’s official MCP server closes this: “implement the requirements in LIN-2847” works without you pasting the issue body.

Linear ships an authenticated remote server hosted at mcp.linear.app. The connection uses OAuth, which means no static API tokens to manage. The server supports finding, creating, and updating issues, projects, and comments.

Cursor / Windsurf / Claude Code:

{
  "mcpServers": {
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/mcp"
    }
  }
}

MCP clients that do not yet support remote servers natively can use mcp-remote as a proxy. Linear documents this in their MCP setup page.

---

7. Sentry MCP

What it does: Connects the agent to Sentry error tracking — pull issue details, search events by query, run Sentry’s Seer AI for root cause analysis, and resolve issues.

Why it matters: Production bugs come with a Sentry issue ID and a stack trace. Without the Sentry MCP, fixing a production error requires: open Sentry, copy the error message, copy the stack trace, paste into your coding agent, describe the file layout, ask for a fix. With it: “fix the bug in SENTRY-8821” — the agent pulls the full event, the stack trace, the breadcrumbs, and Seer’s root cause analysis in one step.

Sentry provides a hosted remote server at mcp.sentry.dev with OAuth 2.0 — nothing to install and no API token to manage or rotate.

Cursor / Windsurf / Claude Code:

{
  "mcpServers": {
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    }
  }
}

---

The right stack by workflow type

Workflow	Servers to install	Skip
Solo web dev (React/Next.js/Vite)	Context7, GitHub MCP, Playwright	Sentry, Linear
Backend API / Python	Context7, GitHub MCP, Supabase	Playwright, Linear
Full-stack team	Context7, GitHub MCP, Supabase, Linear, Sentry	—
Open source contributor	Context7, GitHub MCP, Sequential Thinking	Supabase, Sentry, Linear
Data engineering (SQL/dbt)	Context7, Supabase, Sequential Thinking	Playwright
QA / automation engineer	Playwright, GitHub MCP, Sentry	Linear

If you are on Cursor, verify your total tool count after adding servers. Run the agent on a simple task and check the Cursor MCP status panel to confirm all tools are visible. If any show as unavailable, you have exceeded the 40-tool ceiling — disable the server with the most tools and switch to a hosted/remote variant.

---

What to skip

The Filesystem MCP server is an Anthropic reference implementation and frequently recommended, but Cursor, Claude Code, and Windsurf already have full native filesystem access. Filesystem MCP duplicates built-in capability with worse ergonomics — skip it unless you have a specific security reason to sandbox file access through a separate process.

General-purpose tool hubs (Zapier MCP, Composio, etc.) expose hundreds of integrations as individual tools. This sounds useful until you hit the 40-tool ceiling on your first try. If you need Notion or Slack access, install the official native Notion or Slack MCP server rather than routing through a hub that multiplies your tool count.

Community-built clones of servers that now have official versions. The @modelcontextprotocol/server-github npm package is deprecated — use ghcr.io/github/github-mcp-server. Multiple unofficial Supabase servers exist on npm and GitHub — use @supabase/mcp-server from Supabase’s official account. Official versions get security patches; forks often do not.

---

Honest take

Three servers cover 80% of the productivity gains: Context7 (eliminates documentation hallucinations), GitHub MCP (eliminates issue/PR context-switching), and Playwright (closes the browser-testing loop). Add the remaining four based on what your team actually uses.

The recurring mistake is installing 10 servers “just in case.” Cursor’s 40-tool limit means more servers often means a worse coding agent — the agent picks the wrong tool more often when it has 60 choices versus 20. Audit quarterly: if you have not invoked a server’s tools in two weeks, remove it.

One friction point that the ecosystem has not solved yet: MCP configuration is per-workstation, not per-project. If you onboard a new team member, they manually replicate your mcp.json or .claude/settings.json. Some teams ship an .mcp.json template to their repository root and document the setup in their README; that is the current best practice for team coordination.

For teams running Claude Code on CI (headless mode, claude -p), Linear and Sentry MCP servers are the highest-value additions — they let automated agents close the loop between a failing build, an open issue, and an error trace without human context injection at each step.

The MCP ecosystem will look different in 12 months. Right now the seven servers above are the ones that are stable, actively maintained, and worth the context overhead in daily coding work.

---

Sources

• Context7 MCP — GitHub (upstash/context7)
• GitHub MCP Server — Official repository (github/github-mcp-server)
• Playwright MCP — Official repository (microsoft/playwright-mcp)
• Supabase MCP Server — Official documentation (supabase.com)
• Sequential Thinking MCP — modelcontextprotocol/servers
• Linear MCP server — Linear Docs
• Sentry MCP Server — ChatForest review
• Connect Claude Code to tools via MCP — Official Claude Code docs
• Cascade MCP Integration — Official Windsurf docs (100-tool limit)
• MCP Statistics — PulseMCP
• Cursor MCP 40-tool limit — Cursor Community Forum
• modelcontextprotocol/servers — GitHub
• Playwright MCP — Official Playwright documentation
• GitHub MCP Server installation guides — github/github-mcp-server

Last updated May 25, 2026. MCP server APIs and tool counts change frequently; verify against official documentation before installing.