servers

Implements the Model Context Protocol as a standardized JSON-RPC 2.0 server that exposes capabilities (Tools, Resources, Prompts, Roots) to LLM clients through bidirectional message passing. Uses transport-agnostic architecture supporting stdio, HTTP, and WebSocket transports, with automatic request/response routing and error handling via the MCP SDK. The protocol enables clients to discover and invoke server capabilities through a well-defined capability negotiation handshake.

Enables servers to define tools as JSON Schema-validated functions that LLM clients can discover and invoke. Tools are registered with the MCP server using the SDK's tool registry, which validates input parameters against their schemas before execution and returns typed results. The schema-based approach allows clients to understand tool capabilities, required/optional parameters, and return types without documentation, enabling automatic tool selection and parameter binding by LLM agents.

Provides official SDKs in TypeScript and Python that abstract MCP protocol details and provide high-level APIs for building MCP servers. The SDKs handle JSON-RPC message routing, transport management, capability registration, and error handling, allowing developers to focus on implementing business logic. The TypeScript SDK uses class-based server definitions with decorators for capability registration, while the Python SDK uses similar patterns with Python conventions. Both SDKs support multiple transport mechanisms (stdio, HTTP, WebSocket) through a pluggable transport layer.

Implements a pluggable transport layer that allows MCP servers to communicate over multiple protocols (stdio for local processes, HTTP for remote clients, WebSocket for bidirectional web communication) without changing server code. The transport layer handles protocol-specific details like message framing, connection management, and error handling, exposing a unified interface to the server implementation. This enables the same server code to be deployed in different environments (CLI, web service, embedded) by simply changing the transport configuration.

Implements MCP protocol handshake that allows clients to discover what capabilities (Tools, Resources, Prompts, Roots) a server exposes before invoking them. The handshake includes server metadata, protocol version negotiation, and capability listings with full schemas. Clients can query the server's capabilities and use this information to determine what operations are available, enabling dynamic tool selection and parameter binding by LLM agents. The implementation ensures version compatibility and allows graceful degradation when clients and servers support different protocol versions.

Implements comprehensive error handling across the MCP protocol with typed error codes, error messages, and optional error data. Servers can return structured errors for invalid requests, tool execution failures, resource access errors, and protocol violations. The error handling includes automatic validation of tool parameters against schemas, resource access checks, and graceful error propagation to clients. Clients can parse error codes to determine error types and implement appropriate recovery strategies.

Allows servers to expose resources (files, documents, data) through a URI-based interface that clients can request by name. Resources are registered with metadata (name, description, MIME type) and content is served on-demand when clients request a specific resource URI. This enables LLM clients to access server-side data without direct filesystem access, with support for text, binary, and structured content types. The URI scheme allows servers to implement custom resource resolution logic (e.g., database queries, API calls) behind a simple resource interface.

Enables servers to define reusable prompt templates that LLM clients can request and use for specific tasks. Prompts are registered with the MCP server and can include dynamic parameters that clients provide at invocation time. The server can inject context, examples, or instructions into prompts before returning them to clients, allowing centralized prompt management and versioning. This capability supports multi-turn conversations where prompts can be updated server-side without client changes.

Provides a reference implementation of an MCP server that exposes filesystem operations (read, write, list, search) within a sandboxed root directory. The filesystem server validates all paths against the root directory to prevent directory traversal attacks, implements recursive directory listing with filtering, and supports file operations through MCP tools. The implementation demonstrates security best practices including path canonicalization, root directory enforcement, and operation-level access control, making it suitable as a template for building secure file-serving servers.

Provides a reference MCP server implementation that exposes Git operations (clone, status, diff, log, commit) as tools that LLM clients can invoke. The server supports multiple repository roots, validates repository paths to prevent escape attacks, and implements operations like branch listing, file history, and repository status. The implementation demonstrates how to wrap command-line Git operations (via subprocess calls) into MCP tools with proper error handling and output parsing, making it a template for building Git-aware LLM agents.

Provides a reference MCP server that exposes HTTP fetch operations as tools, allowing LLM clients to make web requests and retrieve content. The server handles HTTP methods (GET, POST, etc.), manages request headers and authentication, parses response content based on MIME types, and implements error handling for network failures. The implementation demonstrates how to safely expose external API access to LLM clients while managing timeouts, redirects, and content encoding.

Provides a reference MCP server that implements persistent key-value storage accessible to LLM clients through MCP tools. The server stores and retrieves arbitrary data (strings, JSON objects) with get/set operations, supports data persistence across server restarts, and allows LLM agents to maintain state and context between conversations. The implementation demonstrates how to build stateful MCP servers that can remember information across multiple client interactions.

Provides a reference MCP server that implements structured reasoning through sequential thinking tools. The server allows LLM clients to break down complex problems into steps, track reasoning progress, and build up solutions incrementally. The implementation demonstrates how to expose reasoning primitives as MCP tools, enabling LLM agents to use explicit step-by-step planning rather than single-shot responses. This pattern supports longer reasoning chains and more transparent decision-making processes.

Provides a comprehensive reference MCP server that demonstrates all MCP capabilities (Tools, Resources, Prompts, Roots) in a single implementation. The server serves as both a learning resource and a testing tool for MCP clients, implementing example tools for various operations, sample resources, prompt templates, and root directory configurations. The implementation is designed to showcase how different MCP primitives work together and to provide a testbed for validating MCP client implementations.