Best MCP Servers for Coding: The 4 to Install First

Most "best MCP servers" articles list thirty of them. That is the wrong shape of answer, because installing thirty MCP servers makes your coding agent measurably worse at using any of them.

Every server you connect injects its tool definitions into the context window before the agent writes a single line. Twenty servers means hundreds of tool descriptions competing for attention, and the practical result is an agent that picks the wrong tool, or burns half its context deciding which one to pick.

So this is a shortlist, not a catalogue. Whether you run Claude Code or Cursor, four servers cover most real coding work. Everything after that is situational, and the last section covers when to add and when to stop.

If you are still fuzzy on what the protocol actually is, start with what MCP is and why it matters and come back. This article assumes you know what a server is and want to know which ones earn their place.

The starter stack

Install those four, use them for a week, and only then go looking for a fifth.

Context7: the one that stops invented APIs

The single most common failure in AI-assisted coding is confident code written against a library version that does not exist. The model learned an API surface at training time, the library moved on, and you get a function signature that was deprecated two releases ago. Context7 fixes this by fetching current documentation at request time.

The Context7 repository now leads with a setup CLI that handles authentication and configuration in one step. It needs Node.js 18 or newer:

npx ctx7 setup

That authenticates via OAuth, generates an API key, and installs the right configuration for your client. It takes --claude, --cursor, or --opencode to target a specific agent. Setup also offers a choice between MCP mode and a CLI-plus-skill mode that skips MCP entirely, which is worth knowing if you are already watching your tool count.

The @upstash/context7-mcp package is still published if you prefer the direct MCP route, and for manual configuration the server URL is https://mcp.context7.com/mcp with your key passed as an Authorization: Bearer YOUR_API_KEY header. An API key is recommended rather than required, for higher rate limits.

Best for: any project on a fast-moving framework. The value scales with how quickly your dependencies change.

The honest caveat: Context7 serves the library's own documentation. Where those docs are thin, wrong, or out of date, you get thin, wrong, out of date context delivered very efficiently. It reduces hallucination, it does not eliminate it, and it cannot invent quality that the upstream project never wrote.

GitHub MCP: repository work without the tab-switching

The official GitHub MCP server connects your agent to issues, pull requests, code search, and workflow runs. In its own words, it lets AI assistants "manage repos, issues, PRs, and workflows through natural language."

This matters more than it sounds. Without it, a task like "look at issue 412 and open a PR that fixes it" is three context switches and a lot of pasting. With it, that is one instruction.

The remote server is the easy path. Point your client at:

https://api.githubcopilot.com/mcp/

Claude Code, Cursor, and VS Code all support remote MCP servers, and the repository's remote server documentation covers headers and per-client configuration.

Watch the toolset surface. This is one of the largest MCP servers by tool count, and connecting all of it is exactly the context bloat problem described above. The server supports toolsets so you can enable only what you need. If you only want issues and pull requests, enable those and leave the rest off. Anyone who tells you to install it wholesale and move on has not watched what it does to a context window.

Note on the archived version. There is an older GitHub server in the reference server repository, and it is archived. If a tutorial points you at modelcontextprotocol/servers/src/github, that tutorial is out of date. Use the official one above.

Filesystem and Git: the boring foundation

These two ship as reference implementations in the official MCP servers repository, and they are described there as "Secure file operations with configurable access controls" and "Tools to read, search, and manipulate Git repositories."

They are not exciting. They are load-bearing.

Filesystem gives the agent scoped access to directories you nominate. The word doing the work in that sentence is scoped. Point it at a project directory, not at your home folder, and definitely not at /. A filesystem server with broad access is a filesystem server that can read your SSH keys, your .env files, and every other project on the machine.

Git gives the agent real history: diffs, blame, branch state. This is the difference between an agent that says "this function looks wrong" and one that says "this function was changed three commits ago and the tests were not updated."

The overlap caveat: if you use Claude Code, it already has capable built-in file and shell tools, and running a Filesystem MCP server alongside them is partly redundant. It matters more in clients with weaker native file access. Check what your agent already does before adding a server that duplicates it.

Playwright: letting the agent check its own work

Playwright MCP closes the loop that most AI coding setups leave open. The agent writes a change, and then it can actually open the page and look.

claude mcp add playwright npx @playwright/mcp@latest

For Cursor, add a new MCP server in settings with the command npx @playwright/mcp@latest.

The design choice worth knowing: it drives the browser through the accessibility tree rather than screenshots. No vision model is required, which makes it faster, cheaper, and considerably more reliable than pixel-hunting. It is also the reason it works well with text-only models.

Best for: front-end work, and anything where "it compiles" and "it works" are different claims. If you build with tools like Lovable or Bolt, this pairs well with a locally exported project.

The catch: it is slow relative to a plain HTTP request. Do not reach for browser automation to check whether an API returns 200. Use it when rendering genuinely matters.

Beyond the core four

Once the starter stack is earning its keep, the sensible additions are the ones that match a bottleneck you actually have.

Error triage. Sentry runs an official MCP server at mcp.sentry.dev. Note that the Sentry server in the reference repository is archived, so use the vendor's own. Worth adding when you spend real time moving stack traces from a dashboard into an agent.

Issue tracking. If your team lives in Linear or Jira, a server for it removes the same copy-paste tax that GitHub MCP removes for pull requests.

Databases. Be careful here. The PostgreSQL server in the reference repository is also archived, and several third-party replacements exist with varying quality and varying levels of access. A database MCP server with write credentials is a production incident waiting for a plausible-sounding prompt. If you connect one, connect it read-only, against a replica if you have one.

The general pattern: official vendor servers first, reference servers second, community servers only when you have read the source. The official registry is the place to check what exists and who publishes it.

For a worked example of evaluating a single server in depth, our Apidog MCP server review walks through one in detail.

Security: the part most roundups skip

MCP servers run with whatever access you hand them, and an agent that can be persuaded by text it reads is an agent that can be persuaded to misuse them. The threat is not theoretical: any server that reads external content can carry instructions written by someone who is not you.

A short checklist that covers most of the risk:

• Scope filesystem roots explicitly. Nominate project directories. Never your home folder.
• Issue read-only tokens by default. Grant write access to one server, deliberately, when a workflow needs it.
• Prefer official servers. The vendor who owns the product has the strongest incentive to secure the integration with it.
• Read the source of community servers. They are npm packages running on your machine with your credentials. Treat them accordingly.
• Keep secrets out of config files that get committed. Use environment variables and check your .gitignore.
• Review what a server can do before connecting, not after. The tool list is the permission list.

None of this is exotic. It is the same care you would apply to any dependency, which is precisely the framing to hold onto, because the conversational interface makes it feel less like installing software than it actually is.

How many is too many

There is no vendor-published hard ceiling, and anyone quoting you a precise number is guessing. What is observable is the direction: as connected tool count rises, tool selection accuracy falls and context cost rises before the agent does any work.

Directional only. The shape is the point, not the values: there is no published benchmark here, and we are not pretending to have measured one.

Our working heuristic, and it is a heuristic rather than a measurement:

• Three to five servers: comfortable. The agent picks well.
• Six to ten: workable if the servers cover genuinely distinct domains, and if you have trimmed toolsets on the large ones.
• More than ten: you are paying context tax on every request for capability you use occasionally.

The better instinct is per-project rather than global. Configure servers at the project level so a React app gets Context7 and Playwright while a data pipeline gets neither. Most clients support this, and it is a cleaner solution than a permanently maxed-out global config.

If you are thinking about agent context as a budget to be spent well, that is the right frame, and it generalises past MCP into how you structure agentic development workflows.

What developers are actually saying

The most useful signal about Context7 showed up this week in an argument, which is usually where the honest opinions are.

Mintlify announced a competing product, Mintlify Index, and led with a direct comparison: "In our benchmark against Context7, agents using Mintlify Index finished tasks at twice the speed, and with 9% higher factual accuracy." Worth reading as what it is, a vendor's own benchmark against a competitor, which is the weakest class of evidence there is. But it tells you Context7 is the incumbent worth attacking.

The reply underneath is the part that stuck with us. Developer Darsh, responding to that announcement, wrote: "Context7 is the one MCP I've always kept throughout all the bloat cleanups."

That sentence contains this entire article. Not "the best MCP server" or "the fastest," but the one that survived repeated culls. Everyone who runs these things seriously goes through cleanup cycles, because the bloat is real and the context cost is real. What survives your third cleanup is your actual stack.

Angular educator Dmytro Mezhenskyi made the mechanism explicit in a separate thread the following day: "Context7 fetches the latest lib docs for Agent, so it uses modern syntax." That is the whole value proposition in fourteen words, and it is why this server tends to outlast the others.

What to actually do

Install Context7 and GitHub MCP today. Add Filesystem and Git if your client's native tools are weak. Add Playwright when you next do front-end work and catch yourself manually checking a page the agent just changed.

Then stop, and use them for a week before adding anything else. The most common mistake in this space is not picking the wrong server, it is picking twelve of them and wondering why the agent got worse.

Browse the full vibe coding tools directory to see how these fit alongside the agents themselves.

FAQ

What are the best MCP servers for coding? Context7 for live library documentation, the GitHub MCP server for issues and pull requests, the reference Filesystem and Git servers for local repository work, and Playwright MCP for browser verification. Those four cover the majority of day-to-day coding agent workflows.

Which MCP server should I install first? Context7, if your agent keeps writing code against library versions that do not exist. GitHub MCP first if your bottleneck is moving between the agent and pull requests rather than writing the code itself.

Is Context7 free? It works without an account, and the project recommends generating a free API key for higher rate limits. Check current paid tiers on the Context7 dashboard rather than trusting any roundup, including this one.

How do I install MCP servers in Cursor? Cursor Settings, then MCP, then Add new MCP Server. Use the command type with the relevant npx command, for example npx @playwright/mcp@latest.

How do I install MCP servers in Claude Code? Use claude mcp add <name> <command> from the terminal, for example claude mcp add playwright npx @playwright/mcp@latest. Remote servers are added by URL.

Are MCP servers safe? Treat them like npm packages, because that is essentially what they are. Prefer official servers, scope filesystem access to specific directories, and issue read-only credentials unless a server genuinely needs to write.

How many MCP servers should I run? Fewer than you want to. Three to five is comfortable, beyond ten you are paying context cost on every request for capability you rarely use. Configure per project rather than globally.

What is the GitHub MCP server? The official server from GitHub that connects AI assistants to repositories, letting them manage repos, issues, pull requests, and workflows through natural language. The remote endpoint is https://api.githubcopilot.com/mcp/.

Does Playwright MCP need a vision model? No. It drives the browser through the structured accessibility tree rather than screenshots, so it works with text-only models and is faster than pixel-based automation.

Where is the official MCP registry? At registry.modelcontextprotocol.io. Use it to check who publishes a server before you install it.