The Model Context Protocol (MCP) stopped being a novelty sometime in 2025. Anthropic published the spec in late 2024, and by now the major coding editors — Cursor, VS Code via Copilot, Zed, and the Claude desktop and CLI clients — all read the same mcp.json-style config. That means a server you wire up once tends to work across the tools you already use, instead of being locked to one vendor.
The problem isn't finding servers anymore. Public registries list hundreds, and most of them are thin wrappers around an API that you'd be better off calling directly. We spent time running a handful inside a real project to separate the ones that change how you work from the ones that just add latency and a new failure mode. Here's where we landed.
What an MCP server actually buys you
An MCP server gives your editor's AI three things: tools it can call, resources it can read, and prompts it can reuse. The practical effect is that the model stops guessing about your environment. Instead of inventing a plausible table name, it queries your schema. Instead of hallucinating an API response shape, it fetches the real one.
That only pays off when the server closes a gap the model genuinely has. The model already knows your open files and, in most editors, your git diff. It does not know your production database schema, the contents of a Linear ticket, or what a page in your team wiki says. Those gaps are where servers earn their config slot.
Every MCP server you enable is code running with your editor's permissions, and many ship with broad tool scopes. A database server with write access can run
DROP TABLEif the model is confused and you click approve. Read the tool list before enabling, prefer read-only credentials for anything touching a real datastore, and keep auto-approval off for write tools.
The four that consistently pulled their weight
Filesystem and fetch (the built-ins). The reference filesystem server scoped to a project root, plus a fetch/web server, cover the most common gaps: reading files outside the current editor window and pulling a live URL into context. These ship from the MCP project itself, so they're the lowest-risk place to start. If you do nothing else, scope filesystem access to one directory and stop there.
A database server (Postgres/SQLite). This is the one that changed our day-to-day the most. Pointed at a read replica with a read-only role, it lets the model inspect schema, check column types, and validate a query against real data before it writes migration code. The difference between "here's a query that should work" and "I ran it against your schema and it returns 14 rows" is the difference between a suggestion and an answer.
A version-control / issue server (GitHub, Linear). Wiring in the GitHub server means the model can read a PR's review comments or an issue thread without you copy-pasting. We found this most useful for the boring half of code work — summarizing what a long PR thread actually decided, or pulling the acceptance criteria off a ticket before writing the implementation.
A docs/knowledge server (Notion, Sentry). When your design decisions and runbooks live in a wiki, a server that reads them lets the model ground its answers in your team's actual conventions instead of generic best practice. A Sentry server does the equivalent for errors: paste a stack trace, and the model can pull the full event context rather than working from the truncated snippet you happened to copy.
Picking servers without bloating your config
More servers is not better. Each one adds to the tool list the model has to reason over, and a crowded tool list measurably degrades tool selection — the model picks the wrong tool, or calls three when one would do. We saw the cleanest behavior keeping the active set small and project-specific rather than enabling everything globally.
A reasonable starting config for most projects is three to five servers: filesystem scoped to the repo, your database on a read-only role, your VCS or issue tracker, and one knowledge source. Add a fourth or fifth only when you hit a concrete gap, not speculatively.
Most editors let you define MCP servers per-project, not just globally. Put the database and issue-tracker servers in a project-level config that lives next to the repo, and keep your global config limited to genuinely universal tools like filesystem and fetch. This keeps a client's production database out of context when you're working on an unrelated side project.
Where it still breaks down
Two rough edges are worth setting expectations on. First, authentication. Servers that talk to a SaaS API need a token, and the storage story varies by editor — some read from environment variables, some from the config file in plaintext. Treat any token you put in an MCP config as if it could leak, and scope it to the minimum it needs.
Second, reliability. An MCP server is a separate process, and when it crashes or hangs, the failure shows up as the model mysteriously "not knowing" something it should. When a server-backed answer looks wrong, check whether the server is actually running before you blame the model. The tooling around health and observability is still thin compared to the protocol itself.
None of this is a reason to skip MCP. It's a reason to start narrow: two or three servers that close gaps you actually feel, read-only where a datastore is involved, and approval kept on for anything that writes.
Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.
Top comments (0)