Who servers is for#
AI developers building custom MCP servers
The reference servers show the exact SDK calls, capability declarations, and transport patterns needed to write a compliant MCP server. Developers can copy and adapt the Filesystem or Fetch implementations as templates for connecting AI agents to internal data sources.
Skip if:
If you need a production-ready integration with a specific third-party SaaS API rather than a developer template, look at vendor-maintained MCP servers in the MCP Registry or a managed integration layer like Composio.
Teams connecting Claude or VS Code to local developer tools
The Git and Filesystem servers give AI clients auditable access to a codebase or file tree. VS Code and Cursor users add these servers to their client config with a few lines of JSON and immediately give their AI assistant access to local files and Git history.
Skip if:
If your use case involves connecting AI agents to SaaS applications (CRMs, ticketing systems, or communication tools) rather than local developer tools, Composio covers a much wider API catalog with authentication management included.
Developers evaluating the MCP protocol
The Everything server includes prompts, resources, and tools designed to exercise every capability in the MCP specification. It is the fastest way to understand what the protocol exposes to a client, test a client implementation, or demonstrate MCP capabilities to a team.
Skip if:
If you are looking for a catalog of community-built servers covering real-world applications rather than protocol demonstrations, the MCP Registry at registry.modelcontextprotocol.io is the right starting point.
The problem it solves#
Building an AI agent that can read files, query a database, or fetch web content requires a separate custom adapter for each data source. Without a shared protocol, every AI application builds its own integration code, creating fragile one-off connections that break when APIs change or when the underlying model swaps out. Paid integration services charge to manage these connectors as a hosted layer, adding per-call costs and routing your data through a third party.
The same problem exists on the server side: there is no standard contract for what an AI agent can ask a data source to do, or how that data source should respond. Development teams building internal agent tools spend significant time writing glue code to connect AI models to company files, version control, or databases, and that code is not reusable across different AI clients.
How it solves it#
Filesystem access with configurable access controls
The Filesystem server exposes secure file read, write, and directory listing operations. Access controls are configured at startup by specifying which directories the server is allowed to reach; requests outside those paths are rejected. This lets an AI agent work with a local codebase or document store without unrestricted disk access.
Git repository operations
The Git server exposes read, search, and manipulation operations against a Git repository. AI agents can inspect commit history, search diffs, read file contents at any revision, and perform basic Git operations without requiring direct shell access or a separate CLI tool.
Web content fetching and markdown conversion
The Fetch server retrieves URLs and converts the response to clean markdown, stripping HTML noise so the output is ready for LLM use. This lets AI agents read live documentation or public web pages without the HTML overhead that degrades prompt quality.
Persistent knowledge graph memory
The Memory server maintains a knowledge graph that persists between AI agent sessions. Agents write and query nodes and edges, giving them structured long-term memory that survives context resets. Start it with `npx -y @modelcontextprotocol/server-memory` and configure it in any MCP client.
Sequential reasoning tool
The Sequential Thinking server gives AI agents a structured mechanism for breaking complex problems into ordered thought steps. The agent can revise earlier steps as new information emerges during a reasoning chain, which suits multi-step planning tasks where intermediate conclusions affect later ones.
Multi-language SDK coverage
Reference implementations target TypeScript and Python, but MCP SDKs exist for C#, Go, Java, Kotlin, PHP, Ruby, Rust, and Swift. Teams can write their own MCP servers in their native stack using the same contract the reference servers demonstrate.
Strengths and trade-offs#
Strengths
- 90,000+ GitHub stars with active maintenanceWith 90,816 GitHub stars and 11,723 forks, this is one of the most widely followed protocol repositories in the AI tooling space. The repository received its most recent commit on 2026-10-01 and is managed by Anthropic with contributions from the broader community.
- Apache-2.0 and MIT dual licensingNew contributions are Apache-2.0 licensed; older code remains under MIT. Both licenses permit unrestricted self-hosting, commercial use, modification, and redistribution. Running MCP servers internally carries no licensing cost, and neither license restricts using the servers as part of a hosted internal service.
- Single-command startupTypeScript servers start with one `npx` command (no build step, no global install required); Python servers start with one `uvx` command. Client configuration is a two-line JSON addition to Claude Desktop, VS Code, or Cursor. The low setup cost makes evaluation fast.
- Broad client ecosystem supportMCP is supported across Claude, ChatGPT, VS Code, Cursor, and MCPJam, among others. Servers built to the reference contract work across all these clients without modification, so development effort carries over to every MCP-compatible client.
Trade-offs
- -Reference implementations, not production-ready codeThe README states that these servers are educational examples for developers building their own MCP servers, not hardened production deployments. Teams should evaluate their own security requirements and implement appropriate safeguards, particularly for the Filesystem server, before using any reference server in a production environment.
- -Twelve servers archived and moved outAWS KB Retrieval, Brave Search, GitHub, GitLab, Google Drive, Google Maps, PostgreSQL, Puppeteer, Redis, Sentry, Slack, and SQLite reference servers have been moved to a separate archived repository. Several are now maintained by community or vendor teams. The main repository covers only the small set maintained by the MCP steering group.
- -566 open GitHub issuesThe repository carries 566 open issues. For a reference-implementation collection this is manageable, but teams building production tooling on top of these servers will need to triage relevant issues themselves rather than relying on a commercial support track.
servers vs alternatives#
MCP Reference Servers vs Composio
Both MCP reference servers and Composio connect AI agents to external tools and data sources, but they operate at different levels of the stack. MCP is an open protocol specification with open-source reference implementations; Composio is a managed integration service with a paid tier that handles authentication and API connections on your behalf. The primary decision is whether you want to own and run your integration layer or pay to have it managed.
| Feature | MCP Reference Servers | Composio |
|---|---|---|
| License | Apache-2.0 / MIT | Proprietary |
| Self-hosting | Yes | No |
| API coverage | Developer tools (files, Git, web, memory) | 250+ SaaS APIs |
| Auth management | Manual | Included |
| Pricing | Free | Paid plans |
| Production-ready | No (reference implementations) | Yes |
MCP reference servers are the better choice when your use case centers on developer tooling: giving an AI agent access to a local codebase, filesystem, or web pages. They run on your infrastructure with no data leaving your network, and the Apache-2.0 and MIT licenses place no restrictions on commercial internal use. Because the implementations are open source, you can adapt the access controls and tool definitions to match your exact security requirements.
Composio is the better choice when you need AI agents to connect to a broad catalog of SaaS applications (CRMs, ticketing systems, communication tools) and don't want to manage OAuth flows and credential storage yourself. Composio handles authentication across hundreds of APIs without additional engineering effort. If your priority is breadth of integration coverage rather than infrastructure control, Composio is the more practical starting point.
Quick start#
Requires Node.js 18+ for TypeScript servers or Python 3.10+ with uv for Python servers. No external infrastructure needed.
```bash
git clone https://github.com/modelcontextprotocol/servers.git
npm install
npx @modelcontextprotocol/server-memory
```What it's built on#
- Languages
- PythonTypeScript
- Frameworks
- Express
FAQ#
Are MCP reference servers production-ready?
No. The repository README states that these servers are reference implementations intended as educational examples for developers building their own MCP servers, not hardened production deployments. Teams should evaluate their own security requirements and implement appropriate safeguards before deploying any reference server in a production environment, particularly the Filesystem server where misconfigured access controls could expose unintended paths.
How do I connect an MCP reference server to Claude Desktop?
Add a server entry to Claude Desktop's mcpServers config object. For the Memory server, set command to 'npx' and args to ['-y', '@modelcontextprotocol/server-memory']. For the Git server using uvx, set command to 'uvx' and args to ['mcp-server-git', '--repository', 'path/to/repo']. On Windows, wrap npx-based entries by changing command to 'cmd' and prepending '/c' and 'npx' to the args list. Restart Claude Desktop after adding any entry. The official README includes complete JSON config examples for Filesystem, Git, and PostgreSQL servers.
What is the license for MCP reference servers?
New contributions are licensed under Apache-2.0; older code not yet relicensed remains under MIT. Both licenses permit unrestricted self-hosting, modification, commercial use, and redistribution. Apache-2.0 requires retaining copyright notices and marking modified files; MIT requires retaining the copyright notice. Neither license restricts running the servers as an internal hosted service, and there are no usage fees for any deployment scenario.
How does MCP compare to Composio for connecting AI agents to external tools?
MCP defines an open protocol; Composio is a managed integration service. The MCP reference servers are self-hosted, open source, and focused on developer tooling (files, Git, web fetch, memory). Composio offers a paid hosted layer connecting AI agents to hundreds of SaaS APIs with authentication management included. Use MCP reference servers when you want full infrastructure control and are building against local developer tools. Use Composio when you need breadth of API coverage and don't want to manage OAuth credentials or maintain server code.
Where did the Slack, GitHub, and PostgreSQL reference servers go?
These servers were archived and moved to the servers-archived repository on GitHub. Several have been transferred to official or community maintainers: the Brave Search server is now maintained by Brave, and the Slack server is maintained by Zencoder. The main MCP servers repository now contains only the small set of reference servers maintained by the MCP steering group, with the full community catalog available at registry.modelcontextprotocol.io.
Similar open-source tools#
treg
One token for 2,600+ agent tools across 47 providers
Jentic Mini
Self-host API execution for AI agents
GenericAgent
Autonomous agent that evolves skills over time
FckSignups
Open-source tools that work instantly, no signup required
browser-use
Python library giving any LLM full browser control, MIT licensed
Omnara
Open-source agent deployment API. Self-host or use Omnara Cloud.