There are north of 5,000 MCP servers now. Almost none of them belong in your setup.
I build openseek, a coding agent, so I spend a lot of time watching what MCP servers actually pull their weight versus what just sits in the system prompt burning tokens on every turn. This is not a "here are 50 servers" listicle. It's the short list of best MCP servers for 2026 that survive contact with a real coding-agent workflow, grouped by what capability they unlock — plus the one gotcha each one bites you with.
If you're brand new to any of this, read what is an MCP server first. If you're ready to wire one up, jump to how to add an MCP server to Claude Code. This post assumes you know the concept and want a curated pick.
What makes an MCP server worth installing
Before the list, the rubric. Every MCP server you connect adds its tool descriptions to the system prompt on every single request, whether you invoke it or not. That's the cost. So a server earns its place only when:
- It calls a live system you can't reach otherwise. A database, a browser, an API with stored auth. If the "tool" is one
curl, a skill is cheaper. - It holds state between calls. A DB connection, a logged-in session, an OAuth token. Stateless one-shots don't need a server.
- Its tool count is lean. Five sharp tools beat fifteen fuzzy ones. Servers that expose 20+ near-identical tools drive up tool-confusion errors linearly.
- You'd actually use it this week. Aspirational installs are pure tax. Uninstall anything you haven't invoked in a month.
Fail two of these and the server is costing you more context than it returns. Keep that lens on as you read.
Filesystem & git: the two you install first
filesystem — the official reference server from the MCP project. Gives the agent scoped read/write access to directories you allow-list. For any agent that isn't already sandboxed into your repo, this is table stakes. When to add: immediately, if your host doesn't already have native file access (Claude Code does, so you often don't need it there — but Claude Desktop and most other hosts do). Gotcha: the allow-list is the whole security model. Point it at ~ and you've handed the model your entire home directory. Scope it to the project root, nothing wider.
git — the reference git server. Stage, diff, commit, read log — as structured tool calls instead of the model guessing at shell syntax. When to add: when your agent works across history a lot (blame archaeology, "what changed between these tags"). Gotcha: it overlaps heavily with just running git in bash. If your host already has a good shell, it's redundant weight — I mostly skip it in Claude Code and keep it for hosts without a terminal.
Both are free and open-source. They're the cleanest examples of the rubric: live system, real state, tiny tool count.
Databases: give the agent your schema, not your prod
postgres (official reference) and sqlite let the agent introspect schema and run queries against a real database. This is the single highest-leverage category for app developers — the moment the model can read your actual tables, its code stops hallucinating column names.
When to add: the instant you're writing code against a database whose schema you keep re-explaining. Gotcha, and it's a big one: connect it read-only, to a dev or replica DB, never to prod with write access. An agent that can DROP TABLE on your production database is a bad afternoon waiting to happen. Most of these servers support a read-only connection string — use it. For heavier needs there are richer community/vendor servers (Supabase's server, Postgres "Pro"-style servers) that add migration and RLS awareness, but start with the reference one.
Browser & web: eyes on live pages
Playwright (Microsoft's server) and the puppeteer reference server drive a real browser — navigate, click, screenshot, read the DOM, pull console errors. For anything involving "does this actually render", front-end debugging, or scraping a page behind JS, nothing text-based substitutes for actually opening the page. Playwright is the one I reach for; it's the more actively maintained of the two.
fetch (reference server) is the lightweight cousin: pull a URL and hand back clean, model-readable content. When you just need the text of a docs page, fetch beats spinning up a whole browser.
When to add: browser servers when you're doing UI work or E2E-style verification; fetch when you want cheap read-only web access. Gotcha: browser servers are the heaviest tool blocks in your prompt — a full browser server can add a dozen tools and thousands of tokens. Install it for a browser-heavy project, not "just in case," and toggle it off for pure backend work.
External APIs: GitHub, Slack, and the integration tier
GitHub — GitHub's own official MCP server, and for most teams the first non-reference one they install. Repos, issues, PRs, Actions, all as tool calls with stored auth. If your workflow lives on GitHub, this closes the loop between "agent wrote code" and "agent opened the PR." Gotcha: scope the token. A full-access PAT hands the agent every private repo you can touch. Fine-grained token, minimum scopes, per-project.
slack (reference server) — search history, read channels, post messages. Genuinely useful for "summarize what the team decided about X." Gotcha: it can post. Keep it read-only unless you specifically want the agent messaging your coworkers.
Notion and similar doc servers pull your written knowledge into context. Add them when your specs and decisions live there, not in the repo. Gotcha: these tend to expose broad tool surfaces — audit what you're actually paying for before committing.
The pattern across this tier: enormous power, and every one of them is a permissions decision, not just an install. The default posture should be read-only, minimum scope, and you widen deliberately.
Memory & context: the compounding one
The memory reference server gives the agent a persistent knowledge graph it can write to and recall across sessions — a durable notepad that survives context resets. When to add: long-running projects where you're tired of re-explaining the same architecture every session. Gotcha: it's only as good as your discipline. An unpruned memory graph turns into a junk drawer the model dredges up at the wrong moments. Treat it like a cache you occasionally clear.
This is also the category where the skill-vs-server line blurs. A lot of what people reach for memory servers to do — "remember our conventions," "here's how we deploy" — is stable knowledge that belongs in a skill, not a live server, because skills load only when triggered and cost zero tokens otherwise. Before you install a memory server, ask whether the thing you want remembered is really state (server) or just knowledge (skill). More on that trade-off in best Claude Code skills 2026.
My actual default set
If you made me commit to a starting lineup for a general coding-agent setup in 2026:
- GitHub — always, if you ship on GitHub.
- A database server (postgres/sqlite, read-only) — whenever there's a DB.
- Playwright — on for front-end and E2E work, off otherwise.
- Context7 — cheap insurance against stale API docs.
- filesystem — only on hosts without native file access.
That's four or five servers, not fifteen. Everything else I add per-project and remove when the project ends. The best free MCP servers — the reference ones plus GitHub, Playwright, and Context7 — cover the overwhelming majority of real work, so paid/hosted options are a "when you hit the wall" decision, not a starting one.
For the ones you decide to keep, how to add an MCP server to Claude Code walks the config end to end. And for the workflow layer that sits on top of these servers — the judgment about when to call them — browse the live skill index at orangebot.ai/skills.
The one-line version
The best MCP server is the one you'll actually invoke this week, scoped to the minimum access that does the job. Everything else is context tax. Audit your setup the way you'd audit dependencies: if it hasn't earned its tokens, cut it.
I write up the MCP and coding-agent landscape every week — what shipped, what's worth installing, what's hype — for builders who'd rather not read 5,000 changelogs. Subscribe to the OrangeBot weekly digest and get the signal without the noise.