@modelcontextprotocol/sdk

Implements the Model Context Protocol specification as a TypeScript server that establishes bidirectional JSON-RPC 2.0 communication channels with MCP clients. Uses transport-agnostic architecture supporting stdio, HTTP, and SSE transports, with automatic message serialization/deserialization and request-response correlation via message IDs. Handles concurrent requests with promise-based async/await patterns and built-in error propagation.

Implements MCP client-side connection handling with automatic transport selection, connection lifecycle management (initialization, capability negotiation, reconnection), and request multiplexing over a single bidirectional channel. Manages client state machines for protocol handshakes and handles server-initiated requests through callback registration patterns.

Implements server-to-client request capabilities where MCP servers can send requests to clients (e.g., asking for user input or sampling) and wait for responses. Uses callback registration patterns where clients register handlers for server-initiated request types. Maintains request-response correlation and error handling for bidirectional communication.

Implements MCP protocol capability negotiation during server initialization where clients and servers exchange supported features, protocol versions, and implementation details. Uses a structured capability exchange mechanism that allows clients to discover server capabilities and servers to understand client constraints. Supports graceful degradation when capabilities don't match.

Provides a declarative schema system for defining tools with JSON Schema validation, parameter typing, and automatic schema generation from TypeScript types. Tools are registered in a central registry that handles schema validation, type coercion, and parameter marshaling before passing arguments to tool handler functions. Supports nested object parameters, arrays, enums, and conditional schema validation.

Implements a resource system where servers expose files, documents, or data through URI-based routing with content type negotiation and streaming support. Resources are registered with URI patterns and handler functions that return content on demand. Supports text and binary content types, with automatic MIME type detection and optional caching hints for client-side optimization.

Implements a prompt system where servers expose reusable prompt templates with typed arguments that clients can discover and invoke. Prompts are registered with argument schemas, descriptions, and handler functions that generate prompt text dynamically. Supports argument validation and allows prompts to be composed or chained by clients.

Implements stdio-based transport for MCP using child process stdin/stdout streams with line-delimited JSON message framing. Handles process spawning, stream buffering, message parsing, and graceful shutdown. Supports both server mode (listening for client connections via spawned processes) and client mode (connecting to server processes).

Implements HTTP and Server-Sent Events (SSE) transport for MCP with request-response correlation over HTTP POST for client-to-server messages and SSE streams for server-to-client messages. Handles HTTP connection pooling, automatic reconnection on SSE stream loss, and message ordering guarantees across multiple HTTP requests.

Implements MCP-compliant error handling with standardized error codes, error propagation through JSON-RPC error responses, and automatic error serialization. Handles protocol violations, invalid requests, tool execution failures, and resource access errors with appropriate error codes and messages. Provides error context preservation for debugging.

Provides TypeScript-first handler registration with compile-time type checking for tool and resource handlers. Handlers are registered with explicit type signatures that are validated against their implementation, ensuring parameter types match schema definitions and return types are compatible with MCP response formats. Uses TypeScript generics and overloads for type inference.

Implements request multiplexing over a single bidirectional MCP connection using JSON-RPC message IDs for request-response correlation. Handles concurrent tool calls, resource reads, and prompt invocations without blocking, using Promise-based async/await patterns and a message ID registry for tracking in-flight requests. Supports request cancellation and timeout handling.