{"slug": "i-tried-100-mcp-servers-these-are-the-only-12-worth-installing", "title": "🔌 I Tried 100 MCP Servers. These Are The Only 12 Worth Installing.", "summary": "An engineer tested 100 Model Context Protocol (MCP) servers to identify the 12 worth installing. The MCP ecosystem has grown to nearly 20,000 servers, with major adoption across tools like Claude Code, VS Code, and Cursor. The test focused on real engineering workflows, scoring servers on utility for shipping code, debugging, and database wrangling.", "body_md": "*The Model Context Protocol ecosystem exploded to nearly 20,000 servers. Most are noise. I installed, wired up, and stress-tested 100 of them — mostly inside Claude Code — to find the handful that actually earn a permanent slot in your config. Here are the 12 that survived, the ones I uninstalled, and the uncomfortable 2026 truth nobody selling you MCP servers wants to admit.*\n\nWhen Anthropic open-sourced the **Model Context Protocol** in late 2024, the pitch was simple: stop writing a bespoke integration for every tool and data source, and build against one open standard instead. The framing they used was *\"the USB-C port for AI applications\"* — one connector, many devices. Skeptical of yet another abstraction layer, I bookmarked it and moved on.\n\nEighteen months later, I couldn't ignore it. The official `modelcontextprotocol/servers`\n\nrepo crossed **87k stars** with over **900 contributors**. Directories like PulseMCP now list **almost 20,000 servers** and add hundreds a week. Anthropic retired its hand-maintained server list in favor of a proper **MCP Registry** (`registry.modelcontextprotocol.io`\n\n). The protocol got adopted not just by Claude but across the tooling world — Zed, Replit, Sourcegraph, Cursor, VS Code, Windsurf, Cline, Codex, and more all speak it. Block and Apollo wired it into production. It stopped being an Anthropic thing and became an *industry* thing.\n\nThe numbers tell the story. The single most-trafficked server in the ecosystem — Microsoft's Playwright — sees an estimated **5.5 million visitors a week**. Chrome DevTools: 2.5 million. Context7: nearly a million. These aren't demos anymore; they're load-bearing infrastructure in real engineering workflows.\n\nSo I did the obvious thing. I installed **100 MCP servers** — the reference servers maintained by Anthropic's steering group, official vendor servers (GitHub, Supabase, Sentry, Notion), and a deep pile of community projects — and ran them against the work I actually do: shipping code, reviewing PRs, debugging production incidents, wrangling databases, turning Figma frames into components, and chasing down performance regressions. I scored each one. Most got deleted within an hour.\n\nThis is the shortlist that survived. **Twelve servers.** Not a hundred. And that number — twelve, out of twenty thousand — is the entire thesis of this article, which I'll come back to before the list.\n\nMCP is a client–server protocol. Your agent (Claude Code, the desktop app, an IDE) is the **client**. An **MCP server** is a small program that exposes three kinds of things to that client:\n\n`run_query`\n\n, `create_issue`\n\n, `take_screenshot`\n\n). These are the verbs.The protocol is transport-agnostic, but in practice servers run two ways, and the distinction matters a lot for how you deploy and secure them:\n\n`npx`\n\n(TypeScript servers) or `uvx`\n\n/`pip`\n\n(Python servers). The client talks to it over standard input/output. Ideal for anything touching local state: files, Git, a database on localhost. Nothing leaves your machine.A minimal Claude Desktop / Claude Code config entry for a **local** server looks like this:\n\n```\n{\n  \"mcpServers\": {\n    \"filesystem\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@modelcontextprotocol/server-filesystem\", \"/path/to/allowed/files\"]\n    }\n  }\n}\n```\n\nA **remote** server is even simpler — just a URL (and usually a key in the header):\n\n```\n{\n  \"mcpServers\": {\n    \"context7\": {\n      \"url\": \"https://mcp.context7.com/mcp\"\n    }\n  }\n}\n```\n\nThat's it. Restart the client, and the agent can use the server's tools. In the filesystem example, it can read and write files inside the directory you allowed — and *only* that directory. That last clause is not a footnote; it's the whole security model, and we'll return to it.\n\nA server is useless without a client to drive it. The MCP client landscape in 2026 is broad: **Claude Code, Claude Desktop, VS Code, Cursor, Windsurf, Cline, Codex, Gemini CLI, Goose, JetBrains, Warp, Kiro, Antigravity** and more. The whole point of the standard is that the *same* server works across all of them — write once, connect anywhere. Everything in this article was tested primarily in **Claude Code**, with spot-checks in the desktop app, but the picks are client-agnostic.\n\nBefore the list, the thing nobody putting out \"Top 50 MCP Servers!\" clickbait will tell you: **every MCP server you connect costs you context.**\n\nWhen a server registers, its tool schemas — names, descriptions, full JSON parameter definitions — get loaded into the model's context window. Connect a dozen chatty servers and you can burn thousands of tokens *before the agent reads a single line of your code*. Worse, a model staring at 80 tools picks the wrong one more often than a model staring at 8. Tool sprawl is a real, measurable accuracy and latency tax.\n\nThis is why **Microsoft's own Playwright team now recommends their CLI + Skills approach over the Playwright MCP server for coding agents.** Their words, paraphrased from the repo itself: CLI invocations are more token-efficient because they avoid loading large tool schemas and verbose accessibility trees into context, letting agents act through concise, purpose-built commands. This makes CLI + Skills better suited for high-throughput coding agents that must balance browser automation against large codebases, tests, and reasoning within a limited context window. MCP still wins for *specialized agentic loops* that benefit from persistent state and rich introspection — exploratory automation, self-healing tests, long-running autonomous workflows — but for a coding agent juggling a big repo, leaner is faster.\n\nThat one design decision, from the team behind the single most popular MCP server on Earth, is the canary in the coal mine. It says the quiet part out loud: **MCP is a powerful tool, not a default.** The ecosystem's own leaders are now actively steering you away from it for the highest-volume use case.\n\nThere's a related second-order effect worth naming: **tool-name collisions and ambiguity.** Connect three servers that each expose a `search`\n\ntool and the model has to disambiguate between them on every call. Connect a server with a `delete`\n\ntool next to one with a `create`\n\ntool and you've widened the surface for a confused or injected agent to do damage. Fewer, sharper servers don't just save tokens — they reduce the number of ways things can go wrong.\n\nThe takeaway that shaped this entire article: **curate ruthlessly.** The right number of MCP servers is the *smallest* set that covers your actual workflow — not the largest set you can find. Twelve is already generous. Most days I run five: Filesystem, Git, Context7, and whichever two map to the task in front of me. The discipline of *subtraction* is the single highest-leverage MCP skill almost nobody talks about.\n\nWith that framing locked in, here are the twelve worth knowing — and a table to see them at a glance before we go deep.\n\n| # | Server | Maintainer | Type | Transport | Best for |\n|---|---|---|---|---|---|\n| 1 | Context7 |\nUpstash | Community/Official | Remote | Up-to-date library docs in-prompt |\n| 2 | Filesystem |\nAnthropic | Reference | Local | Sandboxed file read/write |\n| 3 | Git |\nAnthropic | Reference | Local | Diffs, history, version control |\n| 4 | GitHub |\nGitHub | Official | Remote/Local | Issues, PRs, code search, Actions |\n| 5 | Playwright |\nMicrosoft | Official | Local | Browser automation & E2E |\n| 6 | Chrome DevTools |\nOfficial | Local | Debugging & performance profiling | |\n| 7 | PostgreSQL |\nAnthropic | Reference | Local | Read-only DB analytics |\n| 8 | Supabase |\nSupabase | Official | Remote/Local | Full backend: schema, storage, auth |\n| 9 | Figma |\nGLips | Community | Local | Designs → accurate front-end code |\n| 10 | Sentry |\nSentry | Official | Remote | Production error triage |\n| 11 | Sequential Thinking |\nAnthropic | Reference | Local | Structured multi-step reasoning |\n| 12 | Memory |\nAnthropic | Reference | Local | Persistent context across sessions |\n\n*\"Reference\" = maintained by the MCP steering group as a canonical example. \"Official\" = maintained by the vendor whose product it integrates. \"Community\" = third-party, often excellent, audit before trusting.*\n\nEach server got scored on five axes:\n\nAnything scoring under 3/5 on more than two axes got cut. That eliminated roughly 80% of what I tried.\n\n*Upstash · ~58k⭐ · MIT · ~951k weekly visitors*\n\nThis is the first server I install in any new setup, full stop. Here's the problem it solves. LLMs are trained on a snapshot of the past, so they confidently generate code against *year-old* library versions — inventing methods that no longer exist, importing APIs that were renamed two releases ago, or scaffolding config for a major version you're not running. You've felt this: the code looks plausible, compiles in your head, and falls over the moment you run it.\n\nContext7 pulls **up-to-date, version-specific documentation and code examples straight from the source** and injects them directly into the prompt. The mechanics are clean: it exposes two tools — `resolve-library-id`\n\n(turn \"Next.js\" into the canonical `/vercel/next.js`\n\nID) and `query-docs`\n\n(fetch docs for that ID against your specific question). Add `use context7`\n\nto a request, or better, add a one-line rule to your `CLAUDE.md`\n\nso it triggers automatically whenever you ask about a library, and the hallucinated-API problem largely evaporates.\n\nYou can pin versions (`How do I set up Next.js 14 middleware? use context7`\n\n) and reference exact library IDs (`use library /supabase/supabase`\n\n) to skip the resolution step entirely. It ships in two modes — a classic **MCP server** (`https://mcp.context7.com/mcp`\n\n) or, tellingly, a **CLI + Skills** mode (`npx ctx7 setup`\n\n) that needs no MCP at all. That second option is the token-economy lesson from earlier, baked right into the product.\n\n**Use it when:** Writing code against any fast-moving framework — Next.js, Supabase, Tailwind, a library that shipped a breaking change last month. Honestly: leave it on permanently.\n\n*Anthropic reference server · ~239k weekly visitors*\n\nControlled, sandboxed read/write access to directories you explicitly allow. Unglamorous and absolutely essential — it's what lets an agent actually *work on your project* instead of narrating what it would hypothetically do. Read files, write files, move and rename them, search across a tree, inspect directory structure.\n\nThe **access-control model is the whole feature.** You pass one or more allowed directories as arguments, and the server physically refuses to operate outside them — no path-traversal escape, no surprise reads of your SSH keys. This is the cleanest example in the whole ecosystem of *capability scoping done right*: the agent's power is bounded by configuration, not by good behavior. As an architect, this is the pattern I wish every server copied.\n\n**Use it when:** Always. This is table stakes for any local agent workflow. If you install exactly one server, install this.\n\n*Anthropic reference server · ~194k weekly visitors*\n\nRead, search, and manipulate local Git repositories — diffs, logs, blame, branch state, staged versus unstaged changes. The difference between an agent that *guesses* what changed and one that *reads the actual diff* is night and day, especially on review and debugging tasks. \"Why did this test start failing?\" goes from a hand-wavy guess to \"the agent read the log, found the commit that touched this file, and showed you the three lines that matter.\"\n\nIt pairs beautifully with a disciplined commit workflow: have the agent stage related changes, read its own diff, and write a tight conventional-commit message grounded in what actually changed rather than what it intended to change. Run it alongside the GitHub server (next) and you get the full loop — local history *and* remote collaboration.\n\n**Use it when:** Reviewing changes, authoring commit messages, bisecting \"when did this break?\", understanding an unfamiliar repo's history.\n\n*Official github/github-mcp-server (the old Anthropic reference version is archived)*\n\nRepositories, issues, pull requests, code search across orgs, and Actions — the whole collaboration surface exposed as tools. \"Triage the new issues, label them by area, and draft a response to the one about the flaky test\" becomes a single instruction the agent executes end to end. \"Find every call site of this deprecated function across all our repos\" becomes one code search instead of an afternoon.\n\nImportant detail from my research: the **original reference GitHub server is now archived**, and GitHub itself maintains the canonical one. Use the official server — it's better maintained, supports remote/OAuth deployment, and tracks the GitHub API faithfully.\n\n**Use it when:** Issue triage, PR review and creation, cross-repo code search, checking CI status, automating release notes.\n\n⚠️ Scope the token hard. A classic PAT with\n\n`repo`\n\n+`workflow`\n\nis enormous power to hand an agent that might be steered by injected content. Preferfine-grained personal access tokensscoped to specific repos and the minimum permissions the task needs.\n\n*Microsoft · ~34k⭐ · ~5.5M weekly visitors (the most-trafficked MCP server there is)*\n\nDrives a real browser through the **accessibility tree**, not screenshots — so it's fast, deterministic, and needs no vision model. It operates on structured data, which means it avoids the ambiguity that plagues pixel-and-screenshot approaches. Navigate flows, click and fill, capture page state, assert outcomes, run smoke tests. I replaced a brittle hand-written end-to-end script with \"use Playwright to walk the signup flow on staging and tell me where it breaks\" and it worked first try — then kept working when the markup changed, because the accessibility tree is more stable than CSS selectors.\n\nIt supports persistent profiles (stay logged in across runs), isolated sessions (clean state every time), opt-in capabilities via `--caps`\n\n(vision, PDF, devtools), and even a browser extension to drive your *existing* logged-in tabs. Security-wise, note Microsoft's own warning: **Playwright MCP is not a security boundary.** Sandbox it.\n\n**Use it when:** UI smoke tests, scraping behind a login, reproducing a browser-specific bug, automating repetitive web tasks.\n\nThis is exactly where the token-economy caveat bites hardest. For heavy coding agents, seriously evaluate Microsoft's\n\nPlaywright CLI + Skillsalternative — same engine, far fewer tokens loaded into context. The MCP server is the right pick for stateful, exploratory, long-running browser loops; the CLI is the right pick for a coding agent that just needs to run a test and move on.\n\n*Google · ~2.5M weekly visitors*\n\nDirect Chrome control via the DevTools Protocol — inspect the live DOM, read console errors, capture network waterfalls, and profile runtime performance. Where Playwright *acts* on a page, DevTools *diagnoses* it. \"Load the page, tell me which request is blocking first contentful paint, and which script is eating main-thread time\" is the kind of thing it nails — the agent reads the actual performance trace instead of speculating.\n\nThe pairing with Playwright is natural and powerful: Playwright reproduces the user journey, DevTools explains *why* it's slow or broken. Together they turn an agent from a code generator into something closer to a junior performance engineer who never gets bored reading flame charts.\n\n**Use it when:** Front-end performance work, debugging runtime/console errors, network inspection, Core Web Vitals investigations.\n\n*Anthropic reference server · ~77k weekly visitors*\n\nSchema-aware, **read-only** SQL access to a Postgres database. The read-only default is exactly the right call: the agent can list tables, inspect schemas, and answer questions like \"how many users churned last month and what plans were they on?\" — with zero possibility of a `DROP TABLE`\n\naccident or a runaway `UPDATE`\n\nwith a bad `WHERE`\n\n. It introspects the schema so the model writes correct joins instead of guessing column names.\n\nThis is the *safe on-ramp* to letting an agent near your data. Start here. If and only if you need writes, graduate to a platform server (like Supabase, next) with eyes open and credentials scoped. As an architect I treat \"read-only by default, writes by exception\" as a non-negotiable posture for any agent touching a datastore, and this server embodies it.\n\n**Use it when:** Ad-hoc analytics, schema exploration, debugging data issues, answering product questions — all without write risk.\n\n*Supabase (official) · ~71k weekly visitors*\n\nWhen you need more than read-only — projects, migrations, database management, storage, edge functions — the official Supabase server exposes the whole platform as tools. It turns \"scaffold a `posts`\n\ntable, write the migration, add row-level security so users only see their own rows, and create a storage bucket for attachments\" into a guided, reviewable conversation instead of a dozen dashboard clicks and a hand-written SQL file.\n\nThe flip side of that capability is responsibility: this server can *change your backend*. Run it against a dev/staging project, use a scoped access token, and review every migration before it applies. The power is real; so is the blast radius. Treat it accordingly.\n\n**Use it when:** Building on Supabase end to end — schema design, migrations, storage, auth, edge functions — especially in early/rapid development.\n\n*Figma Context (GLips) · community · ~144k weekly visitors*\n\nPulls a Figma frame's actual structure — layout, spacing, typography, color tokens, component hierarchy — into the agent so it generates front-end code that *matches the design* instead of approximating a screenshot. This is the difference between \"here's a vibe of your mockup\" and \"here's a component with the right padding scale, the right token names, and the right nesting.\" Point it at a frame and ask for a React + Tailwind component, and what comes back is genuinely close to pixel-accurate.\n\nIt's a community server (Figma also has official MCP efforts worth watching), so audit it before trusting it with a real Figma token — but it has earned its enormous popularity by solving the design-to-code handoff better than anything else I tested.\n\n**Use it when:** Translating designs into front-end code, extracting design tokens, keeping implementation faithful to a mockup.\n\n*Sentry (official)*\n\nPull issues, stack traces, breadcrumbs, and error-frequency trends from Sentry directly into the agent. \"Here's the top crash this week — read the stack trace, find the commit that introduced it, and propose a fix with a test\" is a *complete operational loop* that never leaves your editor. Combine it with the Git and GitHub servers and the agent can go from production alert to draft PR in one conversation.\n\nThis is the category that excites me most as an architect, because it's where agents stop merely helping you *write* code and start helping you *operate* it. Observability data is exactly the kind of high-signal, structured context that turns a generic LLM into something that understands *your* running system.\n\n**Use it when:** Incident triage, root-causing an error spike, connecting a production exception back to the offending change.\n\n*Anthropic reference server · ~82k weekly visitors*\n\nThe odd one out on this list: it's not a data connector at all, it's a *reasoning* server. It gives the model an explicit, revisable scratchpad to decompose a gnarly problem into numbered steps, revisit earlier steps when new information appears, and branch when needed. On genuinely multi-stage tasks — a database migration plan, an architecture decision with trade-offs, a tricky multi-file refactor — the quality lift is real and repeatable.\n\nIt's the cheapest \"make the model think harder before it acts\" upgrade in the ecosystem, and it composes with everything else here: think first, *then* touch the filesystem, the database, or the repo. I reach for it whenever the first answer to a problem is usually the wrong one.\n\n**Use it when:** Complex planning, multi-step refactors, architecture decisions, debugging that requires holding several hypotheses at once.\n\n*Anthropic reference server*\n\nA knowledge-graph-based memory the agent can write to and read from, so context survives between sessions. It was recently upgraded to expose the knowledge graph as a first-class MCP **Resource**, which makes the stored memory directly readable rather than only tool-accessible. This is the antidote to the \"every conversation starts from zero\" problem: capture your project's decisions, conventions, and hard-won context once, and the agent stops re-learning them every single morning.\n\nThis maps to one of the most important emerging patterns in agent design — durable, structured memory as the difference between a sharp intern who forgets everything overnight and one who actually grows into the role over weeks. For long-running projects, it's transformative; for one-off tasks, you won't need it. Know which situation you're in.\n\n**Use it when:** Long-running projects where you're tired of re-explaining the same architecture, conventions, and decisions every session.\n\nThese didn't make the core twelve — either because they're more situational, overlap with a pick, or carry a broader tool surface you should enable deliberately — but every one is worth knowing.\n\n**Web & research**\n\n**Knowledge & comms**\n\n**Automation hubs**\n\n**Data**\n\n**Cloud & docs**\n\n**Office documents**\n\n`.docx`\n\nand `.pptx`\n\nfiles (not Markdown pretending to be Office). Hundreds of thousands of weekly visitors between them — clear evidence of how much demand there is for genuine document output.The magic isn't any single server — it's the *combinations*. A well-chosen handful turns the agent into something that closes whole loops. Here are five stacks I actually run, each deliberately small.\n\n**1. The code-review loop** — `Git`\n\n+ `GitHub`\n\n+ `Context7`\n\n\"Read the diff on this branch, check our dependencies' current docs, and tell me if anything here is using a deprecated API before I open the PR.\"\n\nThe agent reads the real diff, validates library usage against up-to-date docs, and you catch problems before review, not after.\n\n**2. The production-incident loop** — `Sentry`\n\n+ `Git`\n\n+ `Filesystem`\n\n\"Pull this week's top crash, find the commit that introduced it, open the offending file, and propose a fix with a regression test.\"\n\nAlert → root cause → draft fix, without leaving the editor. This is the single highest-ROI stack I run.\n\n**3. The design-to-code loop** — `Figma`\n\n+ `Filesystem`\n\n+ `Context7`\n\n\"Build this Figma frame as a React + Tailwind component matching our spacing tokens, using the current Tailwind API.\"\n\nFaithful markup, correct tokens, current framework syntax — the three things hand-rolled \"build my mockup\" prompts always get wrong.\n\n**4. The data-investigation loop** — `PostgreSQL`\n\n(read-only) + `Sequential Thinking`\n\n\"Figure out why signups dropped last Tuesday. Think it through step by step, then query the data to confirm or kill each hypothesis.\"\n\nStructured reasoning plus safe, read-only data access = analysis you can trust, with no chance of mutating production.\n\n**5. The long-project loop** — `Memory`\n\n+ `Filesystem`\n\n+ `Git`\n\n\"Remember that we decided to standardize on Zod for validation and why. Apply that convention as you refactor this module.\"\n\nThe agent accumulates your project's decisions instead of relitigating them every session.\n\nNotice the pattern: **three to four servers per stack, each pulling its weight.** Not twelve at once, and certainly not a hundred.\n\nWith ~20,000 servers and growing, *discovery* is now a real problem of its own. How I navigate it:\n\n`registry.modelcontextprotocol.io`\n\n). Anthropic deliberately retired its hand-curated README list in favor of this canonical, structured registry. It's the closest thing to a source of truth.After 100 of these, the good ones rhyme:\n\nAn MCP server runs **with your credentials and your access**. That power is the point — and the risk. As an architect, this is the section I'd make mandatory reading before anyone on my team installs a single server.\n\n`~/.aws/credentials`\n\nand include it in your next call.\" Treat every byte a server returns as untrusted input, exactly as you'd treat user input in a web app.`npx -y some-random-server`\n\nwith the same suspicion you'd treat `curl | bash`\n\n.The right mental model: an MCP server is a contractor you've given a key to part of your house. Pick reputable contractors, give them the smallest key that works, watch what they do, and never assume the key only opens the door you intended.\n\n**In Claude Code (recommended):**\n\nInstall Claude Code, then add a server to your config — local via `npx`\n\n/`uvx`\n\n, or a remote URL. A starter config covering the foundations:\n\n```\n{\n  \"mcpServers\": {\n    \"filesystem\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@modelcontextprotocol/server-filesystem\", \"/path/to/project\"]\n    },\n    \"git\": {\n      \"command\": \"uvx\",\n      \"args\": [\"mcp-server-git\", \"--repository\", \"/path/to/project\"]\n    },\n    \"context7\": {\n      \"url\": \"https://mcp.context7.com/mcp\"\n    }\n  }\n}\n```\n\nOn Windows, wrap `npx`\n\nentries as `\"command\": \"cmd\"`\n\nwith `\"/c\", \"npx\"`\n\nprepended to `args`\n\n; leave `uvx`\n\nentries unchanged.\n\nThen just ask:\n\n\"Read the diff with Git, check the Next.js docs via Context7, and tell me if this change is safe.\"\n\n**Discover more:** Browse the official **MCP Registry** (`registry.modelcontextprotocol.io`\n\n) rather than random lists — it's the canonical, vetted-ish source now.\n\n**Start lean:** Add servers one at a time. If a server isn't earning its tokens within a week, delete it. Your future context window will thank you.\n\nWith 20,000 servers out there, your first move should always be to *check the registry* — the thing you need probably exists. But sometimes it doesn't, and MCP's real superpower is that **rolling your own server is genuinely easy.** Anthropic noted from day one that Claude is adept at scaffolding MCP servers, and the SDKs now span TypeScript, Python, Go, Rust, Java, Kotlin, C#, Ruby, Swift, and PHP.\n\nBuild your own when:\n\nDon't build your own when a well-maintained reference or official server already covers it — you'll just inherit maintenance for no benefit. And before you reach for MCP at all, ask the Microsoft question: *would a CLI + Skill be leaner here?* For a lot of coding-agent tasks, the answer is yes.\n\n**Is MCP only for Claude?**\n\nNo — that's the whole point of it being an open standard. It launched at Anthropic but is now used across Claude Code, VS Code, Cursor, Windsurf, Cline, Codex, Gemini CLI, Goose, JetBrains, Zed, Replit, Sourcegraph and more. Write a server once, use it in any compliant client.\n\n**Local or remote — which should I prefer?**\n\nLocal (stdio) for anything touching local state or where you don't want data leaving your machine: files, Git, a localhost database. Remote (HTTP, increasingly OAuth-secured) for SaaS you'd rather not self-host: GitHub, Notion, Sentry, Zapier. Match the transport to the trust and data-residency profile of the job.\n\n**How many servers is too many?**\n\nThere's no hard cap, but every connected server loads its tool schemas into context and widens the surface for the model to pick the wrong tool. My rule of thumb: keep a small \"always-on\" core (Filesystem, Git, Context7) and add task-specific servers only for the session that needs them. If you're past ~8 connected at once, you're probably leaving accuracy and tokens on the table.\n\n**Does connecting a server cost money?**\n\nThe protocol is free and open. Costs come from (a) any paid service behind a server (a hosted scraping API, say) and (b) the tokens the tool schemas and responses consume against your model usage. The second one is the hidden cost most people ignore — and the reason curation matters.\n\n**MCP server vs. a Claude Skill — what's the difference?**\n\nThink of it as *tools vs. competence*. An MCP server gives the agent **capability** — the ability to call GitHub or query Postgres. A Skill gives the agent **procedural know-how** — how to use those capabilities well, in your context. They're complementary: the best setups pair a lean set of servers with sharp Skills, and sometimes a Skill (or CLI) replaces a server entirely for token reasons.\n\n**What's the single biggest mistake people make?**\n\nInstalling everything. The instinct to bolt on fifty connectors is exactly backwards. Start with three, earn each addition, and delete anything that isn't pulling its weight within a week.\n\nThe MCP ecosystem went from a clever idea to twenty thousand servers in under two years. That abundance is genuinely exciting — it means the \"USB-C port for AI\" actually worked, and almost anything you want to connect an agent to now has a connector waiting. But abundance is also a trap. The instinct to bolt on every shiny server is exactly the instinct to resist, because each one quietly taxes the very context window your agent needs to do good work, and widens the surface for it to err or be misled.\n\nThe deepest lesson from testing a hundred of these isn't a ranking — it's a posture. Notice that the team behind the single most popular MCP server on Earth is now steering coding agents *away* from MCP toward leaner CLI + Skills. Notice that the reference servers I lean on hardest — Filesystem, Git, Postgres — win precisely because they're *small and safe by default*. The frontier of this space isn't more capability; it's better *judgment about capability*.\n\nSo the real skill in 2026 isn't *finding* MCP servers. It's *curating* them: assembling the smallest set that covers your actual workflow, scoping each one tightly, composing three or four into a loop that closes real work, and knowing when a leaner CLI + Skill beats a server entirely. Tools give agents reach. Judgment about which tools to give them — and which to withhold — is still, emphatically, yours.\n\nStart with the twelve above. Compose them into the workflow recipes that match your week. Delete the ones you don't use. Audit the ones you keep. And the next time someone hands you a breathless list of fifty \"must-have\" MCP servers, remember the punchline of my entire experiment: I tried a hundred, I keep twelve in my back pocket, and the setup I actually run most days has five.\n\nLess, but sharper. That's the whole game.\n\n**Suraj Khaitan** — Gen AI Architect | Building scalable platforms and secure cloud-native systems\n\nConnect on [LinkedIn](https://www.linkedin.com/in/suraj-khaitan-501736a2/) | Follow for more engineering and architecture write-ups\n\n*Which MCP server earned a permanent slot in your config — and which one did you delete within an hour? Drop your picks in the comments. I'm always hunting for the next keeper.*", "url": "https://wpnews.pro/news/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing", "canonical_source": "https://dev.to/suraj_khaitan_f893c243958/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing-4a2g", "published_at": "2026-06-28 05:37:03+00:00", "updated_at": "2026-06-28 06:33:44.725828+00:00", "lang": "en", "topics": ["developer-tools", "ai-tools", "large-language-models", "ai-agents", "ai-infrastructure"], "entities": ["Anthropic", "Model Context Protocol", "Claude Code", "Microsoft Playwright", "GitHub", "Supabase", "Sentry", "Notion"], "alternates": {"html": "https://wpnews.pro/news/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing", "markdown": "https://wpnews.pro/news/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing.md", "text": "https://wpnews.pro/news/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing.txt", "jsonld": "https://wpnews.pro/news/i-tried-100-mcp-servers-these-are-the-only-12-worth-installing.jsonld"}}