modelcontextprotocol/go-sdk
Go Sdk
This is a software development kit and framework for implementing the Model Context Protocol in Go. It provides a standardized system for building servers and clients that exchange external resources, proprietary data, and executable tools to provide context for large language models.
The SDK includes a JSON-RPC communication library and an integration framework to expose local data, prompt templates, and typed functions to AI models. It enables the development of both protocol servers that provide external context and clients that consume these remote tools and resources.
The project covers connection lifecycle management and protocol version negotiation to ensure interoperability. It provides transport abstractions for message exchange via standard input/output or HTTP, alongside capabilities for resource mapping and session management.
Security and observability features include OAuth identity integration, directory access restrictions for servers, and tools for traffic inspection and capability verification.
Features
- Model Context Protocol Clients - Provides the client-side integration layers that allow Go applications to connect to MCP servers and consume tools.
- Model Context Protocol Servers - Provides the core framework for implementing servers that expose tools, resources, and prompts to AI applications.
- Client Connection Lifecycles - Manages the complete session lifecycle, including initialization, capability negotiation, and termination between clients and servers.
- AI Tool and Resource Provisioning - Enables the creation of executable functions and read-only data interfaces for AI agents to interact with local files and services.
- API Client Connectivity - Provides the mechanisms for linking AI clients to local or remote servers.
- Client Development - Provides the development framework for building client applications that consume AI tools and data via a standardized interface.
- LLM Tooling Integrations - Provides a system for exposing local data, executable tools, and prompt templates to LLMs via a standardized protocol.
- Executable Tool Definitions - Provides standardized definitions for executable tools, including metadata and logic for LLM invocation.
- External Server Connectivity - Implements connectivity to external servers for the discovery and aggregation of AI tools.
- Prompt Templates - Provides tools for defining prompt templates that guide AI models on the use of specific tools and resources.
- Resource Exposure - Exposes read-only data resources, such as file contents or API responses, to be used as AI model context.
- AI Context Interfaces - Provides a standardized architecture for delivering external resources and proprietary data as context to AI models.
- Model Context Protocol Implementations - Provides a comprehensive Go SDK for building interoperable servers and clients that implement the Model Context Protocol.
- Prompt Templates - Implements systems for defining reusable prompt structures that guide users through tasks within a client application.
- AI Context Resource Management - Manages data resources accessed via unique URIs to provide grounding and context for LLM responses.
- Local Tool Exposure - Enables providing local data and tools to AI models through a standardized communication protocol.
- Context Data Sources - Provides structured, URI-addressable data sources that AI applications can retrieve and use as external context.
- Read-Only Resource Exposure - Provides mechanisms for sharing structured data from files or databases via unique identifiers.
- JSON-RPC Implementations - Implements the JSON-RPC protocol to enable structured request and notification exchanges between clients and servers.
- AI Protocol Server Integrations - Model Context Protocol support for creating custom servers that integrate proprietary tools and services via a standardized communication protocol.
- Model Tool Schemas - Maps executable functions to a standardized schema that allows large language models to discover and invoke tools.
- User Information Collection - Implements mechanisms for pausing AI operations to collect structured data from users via prompts.
- Local Server Launchers - Configures host applications to launch and communicate with local server instances for tool and resource access.
- LLM Completion Requests - Supports requesting text completions from a language model through a client while enforcing permission controls.
- Capability Negotiation Protocols - Implements protocols that manage the exchange and agreement of functional capabilities between clients and servers during initialization.
- MCP Transport Channels - Implements communication channels using standard input/output for local processes or HTTP for remote services.
- Version Negotiation - Handles version agreement between client and server during initialization to ensure protocol interoperability.
- Session Lifecycle Management - Coordinates the sequential states of an interactive session, from initialization handshakes to secure termination.
- Custom Transport Implementations - Allows replacing default transport layers with custom implementations like HTTP for web or container deployments.
- Transport Abstractions - Provides unified interfaces that decouple protocol logic from the underlying communication backends like HTTP or standard I/O.
