modelcontextprotocol/typescript-sdk

Features

• Model Context Protocol - Provides a foundational TypeScript SDK for implementing the Model Context Protocol to connect language models with external tools and data sources.
• AI Agent Tool Integrations - Provides a toolkit for defining executable functions, prompt templates, and data resources for AI tool integration.
• Model Completion Requests - Allow servers to trigger model completions through the client, facilitating agentic behaviors while maintaining security.
• Language Model Orchestration - Exposes tools, resources, and prompts to allow language models to interact with external data and systems.
• Model Context Protocol Clients - Provides the foundational client-side connectivity for language models to access external tools and data.
• Model Context Protocol Servers - Provides standardized server-side interfaces for exposing tools, resources, and prompts to AI models.
• Structured Resource Exposure - Exposes structured data resources via URI-based addressing to provide context for language model reasoning.
• Tool Use and Function Calling - Allows language models to request and execute external tools through standardized function calling.
• Agentic Tool-Use Frameworks - Enables models to utilize external tools during generation flows for complex multi-step interactions.
• Capability Negotiation Protocols - Negotiates protocol versions and feature sets during initialization to ensure compatibility between clients and servers.
• JSON-RPC Message Buses - Facilitates structured bidirectional communication between clients and servers using a JSON-RPC message bus.
• Communication Protocols - Establishes standardized bidirectional communication protocols for bridging AI models with external environments.
• Connection Handshake Protocols - Manages the negotiation of configuration and security parameters during the initial establishment of communication sessions.
• Transport Abstractions - Abstracts communication to support local stdio and remote HTTP/SSE connections for AI applications.
• Standardized Interfaces - Provides standardized interfaces for applications to discover and invoke functions, retrieve data, and use prompt templates.
• User Input Elicitation - Enables dynamic elicitation of structured user input during request processing.
• Interactive Input Prompts - Enables servers to prompt users for structured data or external actions during automated task execution.
• Agentic Web Interaction - Supports server-initiated requests to facilitate autonomous agent behaviors and interactions.
• Model Request Orchestrators - Provides mechanisms for language models to offload tasks and request additional information from the host during execution.
• Contextual Data Providers - Supplies structured data and content to models to provide necessary background information for tasks.
• External Server Connectivity - Builds client applications that discover and interact with external data sources and tools.
• Function-to-Tool Converters - Defines executable functions with structured input schemas that allow models to interact with external systems.
• Interactive AI Interfaces - Delivers rich, interactive HTML-based components from servers to host applications for enhanced user interaction.
• Model Capability Extensions - Provides specialized data and functional capabilities to models through standardized interfaces for external interaction.
• Data Source Connectivity Tools - Establishes client-server connections to integrate external tools and data into language model workflows.
• Change Notification Streams - Provides asynchronous event streams to push real-time updates and state changes to connected clients.
• Workspace Action Execution - Exposes executable operations with typed inputs and outputs for model-driven system interaction.
• AI Agent Development Tools - Provides utilities for building autonomous agent behaviors, including model sampling and multi-step tool execution.
• URI Resource Identifiers - Uses unique identifiers to allow models to reference and manage resources across operations.
• Resource Content Readers - Retrieves the actual data or text content of a specific resource identified by its unique URI.
• Server Capability Exposure - Broadcasts supported protocol versions and available features to ensure client-server compatibility during initialization.
• Server Metadata Registries - Retrieves lists of available servers and version details from a centralized registry to facilitate discovery.
• Server Metadata Publishers - Registers server information and installation locations to make them discoverable by host applications.
• Negotiation and Extension Frameworks - Negotiates feature support and compatibility between clients and servers during the initial handshake.
• Protocol Error Handlers - Provides robust application-level reporting and recovery logic for protocol-level violations and handshake failures.
• Communication APIs - Facilitates secure bidirectional communication between embedded applications and hosts via JSON-RPC.
• HTTP Transports - Handles message framing and connection establishment using standard HTTP streaming patterns.
• Integration Servers - Exposes local interfaces for external software to launch and control application functionality.
• Protocol-Agnostic Transport Layers - Abstracts communication details to support interchangeable transport mechanisms like stdio and HTTP.
• API Access Security - Protects resources by requiring clients to obtain and present access tokens issued by an authorization server.
• Enterprise AI Security - Enforces granular access control and authentication policies to secure connections between language models and data.
• Enterprise Identity Providers - Connects servers to centralized identity management systems to enforce organizational access control policies.
• Access Control - Integrates with centralized identity providers to manage and validate user permissions across the application environment.
• Filesystem Access Boundaries - Restricts server operations to specific filesystem directories to ensure secure access boundaries.
• Server Authenticity Verification - Validates server ownership and identity through authentication flows and domain verification.
• OAuth Authentication - Validates OAuth access tokens from incoming request headers for protected resources.
• OpenID Connect Providers - Integrates OpenID Connect for identity discovery and secure access management.
• Transport Layer Security - Implements authentication frameworks for HTTP-based transports and environment-based credential retrieval.
• Schema Validation Tools - Enforces data contracts by validating tool inputs and outputs against predefined schemas.
• Tool Discovery Interfaces - Enables dynamic discovery of available tools and their input schemas from connected servers.
• View Composers - Aggregate specialized capabilities from different sources into a unified interface to enable complex workflows across disparate data.
• AI Aggregators - Aggregates specialized capabilities from multiple servers into a unified interface for complex workflows.
• Context Management Tools - Optimizes context management by deferring tool definition loading until explicitly required.
• External Knowledge Integrators - Integrates remote services and local filesystems to provide context for model interaction.
• External Tool Execution - Registers functions that models can trigger to perform external actions or retrieve information.
• Prompt Templates - Defines structured message templates that clients can discover and customize to guide language model interactions.
• Parameterized - Offers parameterized templates that guide models on how to interact with a domain or utilize server capabilities.
• Remote Tool Integrations - Facilitates the invocation of tools hosted on remote servers by passing arguments and processing results.
• Development and Debugging Tools - Official TypeScript library for developing MCP servers and clients.
• Remote Data Source Connectors - Provides secure interfaces for connecting assistants to internet-hosted tools and data services.
• API Client Management - Manages the full lifecycle of client connections, including initialization and graceful shutdown.
• Real-time Notification Broadcasters - Sends asynchronous notifications to clients to signal changes in tools, resources, or server state.
• Server-to-Client Event Emissions - Enables servers to push real-time status updates to clients, eliminating the need for manual polling.
• Stdio Transports - Exchanges JSON-RPC messages between client and server subprocesses using standard input and output streams.
• Custom Transport Protocols - Enables the definition and registration of specialized data transport mechanisms for flexible communication.
• Request Timeout Management - Enforces time limits on pending requests to prevent resource exhaustion from hung connections.
• HTTP Servers - Exchanges JSON-RPC messages over HTTP endpoints for remote communication.
• Type Safety - Enforces protocol type safety to ensure reliable interaction between components.
• Access Authentication - Secures access to remote servers using standard protocols to ensure authorized communication.
• Client Credentials - Supports automated machine-to-machine authentication using client credentials.
• Execution Consent - Requires manual user approval for installation commands and configuration parameters before execution.
• Granular Access Controls - Configures granular access controls to restrict which specific tools an assistant is permitted to execute.
• Access Control and Authorization - Controls connection lifecycles and enforces consent requirements to maintain secure boundaries between hosts and services.
• Authorization Server Discovery Mechanisms - Provides mechanisms for programmatically discovering and verifying authorization server endpoints and capabilities.
• External Service Authorizers - Implements supplementary authentication and authorization flows to secure server-client communication.
• API and Machine Authentication - Authenticates automated systems using client credentials and signed tokens for machine-to-machine communication.
• Conditional Role Access - Secures sensitive resources by requiring authentication and authorization via standardized roles.
• Identity Mapping - Verifies tokens from enterprise identity providers to map user claims and scopes to permissions.
• Stateful Interaction Workflows - Coordinate complex workflows by passing state between client and server to enable iterative data collection across request cycles.
• Server Management - Provides tools for managing server lifecycle and dynamic configuration updates on demand.
• Agent Input and Output Validators - Validates tool inputs and returns errors to allow models to interpret failures and self-correct.
• Interactive Chat Interfaces - Embeds sandboxed applications within chat interfaces to enable direct interaction with data visualizations.
• Sandboxed Rendering Components - Renders interactive components within isolated containers to safely display data and collect user input.
• Sandboxed UI Components - Sandboxes interface content within iframes and enforces auditable messaging for secure host-component interaction.
• External User Interaction Requests - Directs users to a specific URL to perform out-of-band tasks like authorization, resuming operations once complete.
• Component Versioning - Coordinates compatible communication versions to ensure both parties support the same standards.
• Real-Time Data Streaming - Facilitates real-time communication between clients and servers using SSE streams.
• Context Provider Frameworks - Manages multiple client instances and aggregates data to provide a unified context for models.
• Prompt Change Notifications - Sends notifications to clients when the collection of available prompt templates is updated to ensure synchronization.
• Event Subscribers - Notifies clients automatically when specific resources change to ensure access to current information.
• API Lifecycle Management - Manages the end-to-end lifecycle of communication sessions, including configuration and progress tracking.
• Server Capability Inspection - Enables real-time browsing and testing of server resources, prompt templates, and tool schemas.
• External Server Package Registries - Integrates third-party tools into the environment by referencing packages from public registries and binary artifacts.
• Paginated Resource Lists - Supports discovery of all resources provided by a server with pagination for managing large collections.
• Dynamic Client Registrations - Supports multiple registration methods including metadata documents and dynamic endpoints to establish trust.
• Interactive Prompts - Provides templates and instructions to guide model interactions through interactive prompts.
• Spam Prevention Mechanisms - Maintains registry integrity through namespace validation and moderation policies to prevent malicious submissions.
• Transport Protocols - Establishes communication between clients and servers using configurable local or remote transport mechanisms.
• Authentication Enforcement Policies - Enforces organizational security policies by passing custom parameters during authentication flows.
• Authorization Issuer Validators - Verifies issuer identifiers in authorization responses to prevent security mismatches.
• Device Authentication Flows - Verifies identity for publishing using automated device flows initiated through the command line.
• Domain Ownership Verification - Proves domain ownership for publishing by creating specific text records in domain configuration.
• Resource Access Control Layers - Uses resource indicators to explicitly identify intended servers for authorization requests and token scoping.
• Domain Metadata Verifiers - Authenticates clients by fetching and validating JSON metadata documents hosted at specific URLs.
• Permission Management - Implements least-privilege access by managing requested scopes and supporting incremental authorization.
• Remote Client Authentication Handlers - Instructs clients to include custom HTTP headers for authenticating remote requests.
• Sensitive Data Access Controls - Binds task identifiers to specific authorization contexts to ensure secure access to sensitive task data.
• Session Token Refreshers - Manages OAuth refresh tokens to maintain persistent access for long-lived connections.
• Tool Change Broadcasting - Broadcasts updates to clients whenever the set of available tools is modified to ensure an accurate tool inventory.
• Asynchronous Task Execution - Enables offloading long-running operations to background processes with durable handles for status polling.
• Tool Execution Error Reporters - Communicates actionable feedback through tool results to allow models to self-correct and retry failed operations.
• Tool Processing Error Reporters - Communicates failures during tool processing by returning a result marked as an error to distinguish logic failures.
• Interface-Based Module Registries - Defines an open specification for consistent server discovery and interface management.
• Remote Server Registrations - Exposes external services to clients via HTTP or SSE transport protocols by defining remote endpoints in configuration.
• Metadata Exchange - Enables flexible data exchange by attaching custom metadata to protocol messages.
• Resource Change Notifications - Alerts clients when the list of available resources has been modified, enabling dynamic discovery of new data.
• Notification Channels - Provides persistent communication streams for receiving asynchronous updates from servers outside standard request-response cycles.
• Host Communication Interfaces - Provides a client-side interface for embedded applications to connect to the host and trigger server-side operations.
• Interactive Embeds - Integrates interactive functionality directly into applications for seamless data interaction.
• Interactive UI Elements - Renders dynamic components like forms and charts directly within conversational interfaces.
• User Interface Components - Transmits HTML-based components via URI schemes to enable rich, interactive user experiences.
• Registry Interfaces - Exposes server metadata through a compliant interface to allow host applications to aggregate information from multiple sources.
• Tool Access Configurations - Configures server access via environment variables and path permissions to link tools securely.
• HTTP Authentication Middleware - Proves domain ownership by hosting public key files at standardized locations on web servers.
• Task Input Elicitation - Allows servers to request and collect client-provided data during task execution to resolve dependencies.
• Input Validation Schemas - Enforces constraints on selection inputs using type-based schema definitions for model interactions.
• Sampling Request Handlers - Allows models to invoke tools during sampling processes by passing definitions and preferences within requests.
• Model Provider Configurations - Configures model preferences to guide clients in selecting appropriate providers and characteristics.
• Structured Return Objects - Supports transmitting arbitrary JSON values as tool output to ensure flexible data exchange between systems.
• Resource Metadata Annotators - Attaches metadata hints to resources to improve client-side filtering and display logic.
• Debugging and Inspection Tools - Includes interactive tools for inspecting protocol interactions, tool execution, and notification streams during development.
• Client Capability Declarations - Includes client feature support in every request to ensure servers remain stateless and informed of capabilities.
• Contextual Autocompletion Providers - Suggests valid argument values for prompts and resource templates based on user input to assist in data entry.
• Server CLI - Provides command-line utilities for launching and managing protocol-compliant server instances.
• Durable Task Orchestrators - Provides state persistence and tracking for long-running operations that exceed single request cycles.
• Semantic Versioning Systems - Applies semantic rules to resolve and select the most appropriate server version for aggregators.
• Custom Request Headers - Maps tool input parameters to custom HTTP headers to facilitate network routing.
• Connection Establishment Protocols - Maintains persistent, stateful communication channels between clients and servers using standardized message formats.
• WebSocket Connection Verifiers - Sends heartbeat signals to confirm communication channel responsiveness.
• Network Traffic Analyzers - Provides diagnostic tools for inspecting network traffic and message payloads between clients and servers.
• Tracing Context Propagation - Propagates distributed tracing information through request metadata to maintain observability across connected systems.
• Task - Provides a mechanism for signaling the completion of asynchronous tasks to allow client-side resumption.
• Server Versioning - Ensures metadata integrity by assigning unique version strings to published server configurations.
• Server Metadata Injections - Allows attaching domain-specific information like ratings or security status to server definitions for consumer context.
• Missing Resource Reporters - Signals that a requested resource does not exist by returning a specific error code and the associated URI.
• Remote Task Cancellation - Allows termination of pending requests to stop processing tasks that are no longer needed.
• Chat Widgets - Integrates UI components like forms and pickers directly into the chat interface to enhance interaction with tools.
• Multi-modal Response Handlers - Supports embedding multi-modal content within prompt messages for rich context.

Star history