====== 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** | [[https://github.com/modelcontextprotocol/servers|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)

<mermaid>
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
</mermaid>

===== 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 =====

<code python>
# 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
</code>

===== References =====

  * [[https://github.com/modelcontextprotocol/servers|MCP Servers GitHub Repository]]
  * [[https://modelcontextprotocol.io|Model Context Protocol Specification]]
  * [[https://www.anthropic.com/news/model-context-protocol|Anthropic MCP Announcement]]
  * [[https://modelcontextprotocol.io/specification/2025-03-26|MCP Spec v2025-03-26]]

===== See Also =====

  * [[dify|Dify]] -- Agentic workflow platform with native MCP support
  * [[opencode|OpenCode]] -- AI coding agent with MCP client
  * [[mem0|Mem0]] -- Memory layer for AI agents
  * [[langfuse|Langfuse]] -- LLM observability platform