Best MCP Servers for Cursor (2026)

The best MCP servers for Cursor are the ones that earn their tool budget: a focused GitHub server, a docs/context server that cuts hallucinations, and one data server for whatever you actually query. Everything else is a liability, because Cursor's tool selection degrades past roughly 40 active tools and the average server ships 12 of them. So the real question isn't "which servers exist" — it's "which three or four are worth the slots."

This is the opinionated shortlist, with Cursor's config path, honest trade-offs, and what to skip. Every server here is real and linked; I've run the math from the Cursor tool-limit post so you don't hit the wall at server five.

Where Cursor reads MCP config (do this first)

Cursor reads MCP servers from ~/.cursor/mcp.json for global config, or .cursor/mcp.json in a repo for per-project config. It supports both local servers over stdio and remote servers over SSE/HTTP, so you can mix Docker-based and hosted servers in the same file.

A minimal entry looks like this:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "ghcr.io/github/github-mcp-server"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    }
  }
}

Save, and Cursor reloads servers automatically — check Settings → MCP for a green status dot. Prefer per-project config when a server needs repo-specific secrets or scope. Full setup lives in how to add an MCP server and the Cursor client guide.

The tool budget: why three servers, not thirty

Cursor works best under about 40 active MCP tools, and the average server exposes around 12. That means you hit the wall at roughly four servers, not fifty. Past the budget, the model has too many near-identical tools and starts picking the wrong one — which reads like the model got worse but is really a config problem.

So treat slots as scarce. Every server below is chosen because it does one job the others don't, and most of them run locally over stdio (as ≈90% of MCP servers do), which keeps latency low and your tokens off someone else's logs. When in doubt, fewer focused servers beat one do-everything agent.

The shortlist: MCP servers worth adding to Cursor

Start with a code server, a context server, and one data server. Add a fourth only if you'll use it weekly.

Server	Best for	Transport	Add it if
GitHub MCP Server	Repos, issues, PRs, Actions	Local (Docker) or remote	You do PR/issue work from Cursor
GitMCP	Live docs for any repo	Remote, free	You want fewer hallucinated APIs
Octocode	Deep code research (FS + LSP)	Local	You investigate large codebases
Package Registry MCP	NPM/PyPI/crates versions + advisories	Local	You get burned by stale package data
Anyquery	SQL over files, DBs, 40+ apps	Local	You query structured data often
Graphlit MCP Server	RAG over Slack/Drive/Jira/Linear	Remote	Your context lives across SaaS tools

The one everyone should have: GitHub

The GitHub MCP Server is GitHub's official server, and "official" matters here — it tracks the API and won't quietly break the way abandoned community forks do. It handles repos, issues, PRs, and Actions, and you can run it locally in Docker or point Cursor at the hosted remote. Trade-off: it's tool-heavy, so it eats a real chunk of your budget. If you only read issues, scope the token tightly and don't feel obligated to enable every toolset.

Cut hallucinations: GitMCP

GitMCP turns any GitHub repo into a live documentation source, which is the cheapest fix for the model inventing method signatures. It's a free remote server, so there's no install — just add the URL. I reach for this over shoving a whole SDK into context: it grounds Cursor on the actual repo docs instead of the model's stale memory. Skip it only if you already run a broader RAG server.

Go deep on code: Octocode

Octocode is the pick when "search" isn't enough and you need to actually trace how code works. It wires GitHub, the local filesystem, and LSP intelligence into Cursor, so the assistant can follow definitions and references like a staff engineer reading unfamiliar code. It overlaps with the GitHub server, so run both only if you do heavy investigation — otherwise this replaces it.

Stop trusting stale package data: Package Registry

The Package Registry MCP Server searches NPM, PyPI, crates.io, NuGet, and Go registries — plus GitHub Security Advisories — for current versions. The model's training data is months old; this makes "what's the latest and is it vulnerable" a live lookup instead of a guess. It's small and cheap on tools, so it's an easy fourth slot.

One data server, chosen by your workflow

Pick exactly one here. Anyquery runs SQL over files, databases, and 40+ apps (GitHub, Notion, Chrome, Todoist) and exposes them to Cursor over MCP — reach for it if you think in queries. Graphlit MCP Server is the RAG option: ingest and search across Slack, Discord, Google Drive, Jira, and Linear when your real context is scattered across SaaS. Running both is how you blow the budget.

What to skip

Skip the maximalist bundles. Kitchen-sink servers that expose 30+ tools each will eat your entire budget in two installs and tank tool selection — the exact failure the tool-limit math predicts.

Skip duplicate coverage. Running GitHub, Octocode, and a third code server means three sets of overlapping tools competing for the same call. Pick the one that matches how you work.

Skip community forks of things that have an official server. When an official option exists, the maintenance and security story is simply better — check the official-vs-community badge before you add anything. For deeper comparisons, the best MCP servers list and best servers for coding agents rank options by category.

My default Cursor stack

For most engineers: GitHub (official) + GitMCP (docs) + Package Registry (versions) + one data server. That's four servers, comfortably under the ~40-tool ceiling, each doing a distinct job. Swap Octocode in for the GitHub server if your day is code archaeology rather than PR management. Add nothing else until you notice a real gap — then remove one server before you add the next.