Best MCP Servers: The Reference Set and How to Judge the Rest

There are roughly ten thousand MCP servers now, and a list of the "top 20" goes stale in a month. Two things don't: the seven official reference servers the Model Context Protocol project publishes, and the criteria that separate a server worth running from one that eats your context window and fails quietly.

The reference set is the right starting point for almost everyone:

These live in the MCP project's reference servers repository, one of the most-starred repositories in the ecosystem. It sits under the modelcontextprotocol organization — managed by Anthropic, built with the community — alongside the specification and SDKs, and MCP's governance moved to the Linux Foundation's Agentic AI Foundation in December 2025. They're deliberately small and well-documented, which makes them both useful in their own right and the best available reading material for writing your own.

Start with filesystem and fetch

If you install two servers and stop, make them these.

filesystem is the one that changes what an assistant can do most obviously. Without it, a chat window can discuss your files only if you paste them in. With it, the agent reads directories, searches across files, and writes results back.

The important part is the permission model: you specify which directories the server is allowed to touch, and it can't reach outside them. That's not a formality — it's the difference between a scoped tool and giving a model your home directory. Configure the narrowest set of paths that makes the task work.

fetch retrieves a URL and converts the page to markdown so the model can read it. It sounds trivial and it removes a real limitation: without it, an agent reasons entirely from training data and whatever you paste. With it, it can check a current documentation page before answering.

Together these two cover the majority of what people actually want when they say they want an agent connected to things.

memory and sequentialthinking are the interesting ones

memory implements a knowledge graph that persists across sessions. Entities, relations, observations — the agent writes facts into it and reads them back next time.

This is the most misunderstood server in the set. People install it expecting the assistant to "remember everything," and what they get is a structured store the model has to deliberately write to and query. It's a tool, not ambient recall. Used well — recording project decisions, people, or recurring constraints — it's genuinely useful. Used passively, it does nothing.

sequentialthinking gives the model a structured way to break a problem into steps, revise earlier steps, and branch. Current models do a fair amount of this natively, so the marginal value is lower than it once was. It still helps on problems where the shape of the answer isn't obvious at the start.

The four checks before installing any other server

Past the reference set, you're evaluating third-party code that runs on your machine with access to your data. Four questions, in order of how much trouble they save.

1. How many tools does it expose, and what do their descriptions cost?

In the common setup, every tool definition from every connected server sits in the model's context before your question does. A server exposing forty tools with verbose descriptions can consume a serious share of the window and degrade performance on everything else.

That's the default rather than a rule of the protocol, and it's worth knowing which side of it your host is on. Some now defer tool definitions instead of loading them all up front: Anthropic's tool search tool lets tools — including whole MCP toolsets — be marked defer_loading: true so they only enter context once the model searches and finds them, and the MCP documentation points clients that federate many servers at the same progressive tool discovery pattern.

The advice holds either way, because deferral isn't universal and tool-selection accuracy still falls as the list grows. This is the most common way a "working" MCP setup gets worse as you add to it. Connect servers you're using for the current task, not every server you've ever installed.

2. Who wrote it, and does it need credentials?

A server that wants an API key, a database connection string, or OAuth access is receiving real access to a real system. The question isn't whether MCP is secure in the abstract — it's whether you'd run this specific repository's code with those credentials.

Prefer official servers published by the vendor whose API they wrap. The official MCP registry exists partly to make that provenance checkable, and it's backed by Anthropic, GitHub, Microsoft, and PulseMCP.

3. Does it support the transport your client uses?

Servers run either locally over stdio or remotely over HTTP, and clients differ in what they support. A remote server your client can't reach is a non-starter, and the failure is usually a silent absence rather than an error. Our guide to MCP clients covers which apps support what.

4. Is it maintained?

The specification moves. The current revision, released 28 July 2026, restructured the protocol core to be stateless, changed how server-initiated requests work, and hardened authorization. A server last updated well before that is running against an older shape of the protocol.

How to find servers without a listicle

The official registry is the answer that doesn't decay. It's a community-driven metadata service for publicly available servers, with the backing of the major ecosystem contributors, and it's searchable rather than curated by whoever wrote a blog post last spring.

Two habits make it more useful than any ranked list:

• Search for the system you want to connect, not for "best MCP server." You want the Postgres one, or the Sentry one, or the one for your ticketing system. Category browsing produces installs you don't use.
• Check the vendor's own documentation first. A growing number of SaaS companies ship official MCP servers, and an official one beats a community wrapper on both maintenance and credential handling.

Installing one

Mechanically, adding a server means telling your client how to start it — a command and arguments for a local server, a URL for a remote one. Each client stores that differently, and Anthropic's MCP documentation covers the Claude Code side.

Two things that catch people out. Servers usually need a client restart to be picked up. And approval prompts are not something the protocol guarantees: MCP doesn't specify a consent interface, so whether you're asked before a tool runs — and how often — is decided by the host and how it's configured. OpenAI's MCP tool, for example, exposes an approval policy with always and never settings, and an agent running unattended may well be set never to ask. When your host does prompt, read what the tool is about to do before approving it, particularly for anything that writes — but treat that dialog as the last line of defence, not the first.

If you're new to the protocol itself rather than the servers, our explainer on what MCP is covers the host, client, and server roles before you start wiring things together.

The step nobody mentions is that all of this assumes a working agent environment to plug the servers into. Getting the servers right is the easy half; getting to the point where you have something running that can use them is where most people stop. Taku closes that half — you mirror an AI setup someone already got working into your own desktop workspace and run it, rather than assembling the environment first. The free app library is the quickest way to see the difference. Taku is in Beta, and the Mac app is available now.

Key points

• The seven official reference servers cover most real needs. filesystem and fetch are the two that change the most.
• memory is a store the model writes to deliberately, not ambient recall. It rewards being used on purpose.
• Tool definitions usually consume context before your question does, unless your host defers them. Connect what the task needs, not everything you own.
• Prefer vendor-official servers over community wrappers, especially where credentials are involved.
• Check the server tracks the current specification — the protocol changed substantially in the July 2026 revision.
• Search the official registry for the system you want to connect. Ranked lists go stale faster than the registry does.

FAQ

What are the official MCP servers?

Seven reference implementations in the MCP project's servers repository: everything, fetch, filesystem, git, memory, sequentialthinking, and time.

How many MCP servers should I run at once?

As few as the task needs. On most hosts, each connected server's tool definitions occupy context that would otherwise go to your actual problem, so more servers can mean worse answers. Hosts that defer tool loading soften that, but a long tool list still makes the model's choice between tools harder.

Are MCP servers safe?

Treat the server, not the prompt, as the thing you're trusting. Whether a host asks before running a tool is a host decision and a configuration setting, not a protocol guarantee, so don't plan around always being asked. The real controls are the ones you set up front: connect servers you have reason to trust, give them the narrowest credentials and scopes that let them work, authenticate properly, and know your host's approval policy. Each server is third-party code with whatever access you gave it — judge it the way you'd judge any dependency.

Do I need to write code to use an MCP server?

No. Using one is configuration: a command or a URL in your client's settings. Writing a new server is a development task, and the mcp-builder Skill in Anthropic's Skills repository scaffolds it.

What's the difference between an MCP server and an MCP client?

The server exposes capabilities — tools, resources, prompts. The client connects to it on behalf of a host application like Claude Code or an IDE. The pairing is one-to-one: a host that talks to five servers creates five clients, each holding its own dedicated connection. So when people say an app "supports several MCP servers," the thing doing the juggling is the host, not a single client.

Where do I find MCP servers?

The official registry at registry.modelcontextprotocol.io, and the vendor's own documentation for whatever system you're connecting. Search for the specific integration rather than browsing a top-ten list.