Reference MCP servers

What “reference” means here#

The modelcontextprotocol/servers GitHub repo is the reference catalogue — example implementations maintained by the Model Context Protocol working group (Anthropic-led, with broad contributor base). These servers are:

• Protocol-correct — they implement the MCP spec faithfully
• Documented with READMEs
• Useful starting points for understanding what an MCP server looks like

They are NOT individually security-audited at the package-content level (each server’s behaviour is whatever its code + dependencies do). And “reference” doesn’t mean “permanent” — over time, some servers move to vendor-owned repos (e.g. the GitHub MCP server now lives at github/github-mcp-server), and some are archived to a sister repo when active maintenance stops.

The currently-active set is smaller than it once was. See the archived list further down.

Currently active reference servers#

These live in modelcontextprotocol/servers/src/ and are actively maintained.

filesystem#

Package: @modelcontextprotocol/server-filesystem

Tools: read_text_file, read_media_file, read_multiple_files, write_file, edit_file, create_directory, list_directory, list_directory_with_sizes, move_file, search_files, directory_tree, get_file_info, list_allowed_directories

When to use: when you need Claude to read or write files outside the working directory. Common pattern: scope it to ~/Documents or a specific project folder, NOT your entire home directory.

Config:

"filesystem": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents", "/Users/you/projects"]
}

Each path after the package name is an allowed root. Claude can read/write within these paths, nothing outside.

Don’t: point it at / or ~. Either gives the agent full disk access. Scope to specific directories.

git#

Package: @modelcontextprotocol/server-git

Tools: git_status, git_diff_unstaged, git_diff_staged, git_diff, git_commit, git_add, git_reset, git_log, git_create_branch, git_checkout, git_show, git_init

When to use: for deep git operations the basic shell tool can’t easily do — complex log queries, structured diffs, programmatic commit creation. Most use cases work fine with the built-in shell tool; reach for this when you want safer, typed git operations.

Don’t: authorise destructive operations without confirms. Tighten the host’s permissions.deny for any force-push / branch-deletion equivalents.

fetch#

Package: @modelcontextprotocol/server-fetch

Tools: fetch (HTTP fetch with content-type-aware extraction — converts HTML to readable Markdown)

When to use: Claude can already do basic web fetches via the model’s built-in browsing in some hosts; this server adds reliable HTML-to-Markdown conversion and lets you use it from hosts that don’t have native fetch.

Don’t: point it at internal admin APIs without an allowlist. The server has no built-in URL filter; that’s the host’s job to add via permissions.

time#

Package: @modelcontextprotocol/server-time

Tools: get_current_time, convert_time

When to use: any time you need timezone math. Models are surprisingly bad at this without a tool — “what time is 3pm NZST in PST?” trips them up regularly. Give them the tool, get reliable answers.

Why this matters: small server, narrow use case, sharp accuracy win on a category of question models otherwise hallucinate.

memory#

Package: @modelcontextprotocol/server-memory

Tools: create_entities, create_relations, add_observations, delete_entities, delete_observations, delete_relations, read_graph, search_nodes, open_nodes

The memory server stores a knowledge graph — entities (people, projects, concepts), relations between them, and observations attached to entities. Backed by a JSONL file on disk. Despite the name, it’s not a generic key-value store; you tell Claude “remember that X is an entity of type Y, related to Z, with observation W” and it lays that into the graph.

When to use: when you want Claude to remember structured facts across sessions — your colleagues, your projects, recurring entities you discuss.

Don’t: treat it as a secure secret store. Anything stored is plaintext-accessible to any future session and anyone with disk access.

sequentialthinking#

Package: @modelcontextprotocol/server-sequential-thinking

Tool: sequentialthinking (a single tool that takes a thought string + metadata and helps Claude lay out structured chains of reasoning)

When to use: complex multi-step problems where you want the agent to lay out its plan before executing. Useful for code refactors, complex bug investigations, anything where “show me the plan first” pays off.

Don’t: use it for simple tasks. The protocol overhead isn’t worth it for short responses.

everything#

Package: @modelcontextprotocol/server-everything

A demonstration server that exercises every protocol feature — tools, resources, prompts, sampling. Not for production use; it’s the reference for “what an MCP server can do.” Worth running once when learning the spec.

Archived reference servers#

These servers are no longer in active development in the main reference repo. They’ve moved to github.com/modelcontextprotocol/servers-archived. Most are still functional and many people still use them; some (notably github) have official replacements maintained by the vendor:

Package	Status	Where to look now
@modelcontextprotocol/server-github	Archived	Official replacement at github/github-mcp-server — maintained by GitHub directly
@modelcontextprotocol/server-postgres	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-sqlite	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-slack	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-gdrive	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-brave-search	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-puppeteer	Archived	Still functional · check servers-archived
@modelcontextprotocol/server-redis	Archived	Still functional · check servers-archived

ℹ️ There is no official @modelcontextprotocol/server-playwright — that was never published under the reference namespace. Several community-published playwright MCP servers exist; vet them like any other community server (see §MCP.3).

The archive doesn’t mean “broken.” It means “not getting active patches from the MCP working group.” For production use, prefer the vendor-owned replacement (where one exists) or carefully assess maintenance signal on the archived version before adopting.

How to pick which to install#

Start narrow. Two servers for a new project is usually plenty:

• filesystem scoped to your project root + a docs folder
• git (or the vendor-maintained github-mcp-server if you need GitHub state)

Add more only when a specific workflow needs them. Each MCP server inflates the tool manifest the model sees → more input tokens → more cost per request. Every server you don’t use is paying tax for nothing.

Common pitfalls#

Symptom	Cause	Fix
filesystem server can’t read a file	Path isn’t under an allowed root	Add the path to the args list
github-mcp-server returns 401 / 403	Token revoked or scope insufficient	Check token in GitHub → Settings → Developer settings
postgres returns “permission denied”	DB user lacks SELECT on that schema	Grant access OR use a different user
memory “forgets” between sessions	Backing JSONL path not writable	Check the server’s README for storage config; pin a writable path
Many tools but model never calls them	Tool descriptions too vague	Edit the server source OR add a hint in CLAUDE.md / system prompt

What to do next#

• §MCP.3 Community MCP servers — beyond the reference set, with trust gates
• §MCP.4 Build your own MCP server — when no existing server fits
• §CC.5 MCP integration — wiring servers specifically in Claude Code