MCP Servers

MCP Servers is the official repository of reference server implementations for the Model Context Protocol (MCP), an open standard released by Anthropic that enables bidirectional communication between LLM applications and external data sources/tools. With over 82,000 GitHub stars, it provides production-ready integrations for GitHub, Slack, filesystem, databases, and more.

Repository	github.com/modelcontextprotocol/servers
License	MIT
Language	TypeScript, Python
Stars	82K+
Category	LLM Integration Protocol

What is MCP?

The Model Context Protocol provides a unified, JSON-RPC 2.0-based protocol for AI applications to access live data, tools, and resources at runtime. Inspired by the Language Server Protocol (LSP), MCP standardizes how LLM hosts discover and invoke external capabilities without custom integrations.

Key benefits include:

Reduced hallucinations by grounding responses in authoritative data sources with provenance metadata
Bidirectional communication where clients invoke server tools and servers can request sampling or user input
Composable integrations that work across any MCP-compatible host

Available Server Implementations

The repository hosts standalone MCP servers, each focused on a specific integration:

GitHub – Repository access, issues, pull requests, code search
Slack – Messaging, channels, notifications
Filesystem – Local file read/write/operations with security boundaries
PostgreSQL – Database queries, schema inspection
Google Drive – Document access and search
Puppeteer – Browser automation and web scraping
Brave Search – Web search integration
Memory – Persistent memory via knowledge graph
Fetch – HTTP request capabilities
SQLite – Local database operations

Architecture

MCP follows a three-layer client-server model:

Hosts – LLM applications (Claude Desktop, Cursor IDE, etc.) that coordinate sessions and permissions
Clients – Embedded in hosts; translate LLM intents to MCP requests and relay responses
Servers – Provide prompts (reusable templates), resources (versioned data), and tools (executable functions)

graph TB subgraph Hosts["Host Applications"] CD[Claude Desktop] Cursor[Cursor IDE] Custom[Custom LLM App] end subgraph Clients["MCP Clients"] C1[Client Instance 1] C2[Client Instance 2] C3[Client Instance 3] end subgraph Servers["MCP Servers"] GH[GitHub Server] FS[Filesystem Server] DB[PostgreSQL Server] Slack[Slack Server] Search[Brave Search] end subgraph Transport["Transport Layer"] STDIO[STDIO - Local] HTTP[HTTP + SSE - Remote] end Hosts --> Clients Clients --> Transport Transport --> Servers

MCP Primitives

Servers expose capabilities through structured primitives:

Server-Side	Client-Side
Prompts – Reusable templates	Roots – Session contexts
Resources – Typed, versioned data	Sampling – LLM inference requests
Tools – Executable functions	Elicitation – User input requests

Transport Protocols

STDIO – Local, same-environment communication via stdin/stdout pipes; ideal for on-premises deployments
HTTP + SSE – Remote communication; HTTP for requests, Server-Sent Events for streaming responses

Both transports carry JSON-RPC 2.0 messages for methods like tools/call, resources/list, and notifications/send.

Code Example

# Building a simple MCP server in Python
from mcp.server import Server
from mcp.types import Tool, TextContent
 
server = Server("my-tool-server")
 
@server.tool()
async def search_database(query: str) -> list[TextContent]:
    """Search the project database for relevant records."""
    results = await db.search(query)
    return [TextContent(
        type="text",
        text=f"Found {len(results)} results:\n" +
             "\n".join(r["title"] for r in results)
    )]
 
@server.tool()
async def get_user_info(user_id: str) -> list[TextContent]:
    """Retrieve user information by ID."""
    user = await db.get_user(user_id)
    return [TextContent(type="text", text=str(user))]
 
# Run with: python -m mcp.server.stdio my_server

Table of Contents