Model Context Protocol (mcp) Implementation In Go

🚀 Implementation of Model Context Protocol (MCP) in Go

This repository contains a Go implementation of a JSON-RPC based protocol for interactions between clients and servers in large language model (LLM) applications. The protocol, named Model Context Protocol (MCP), aims to enhance LLM capabilities.

📦 Repository Contents

• mcp/schema.go: Go struct definitions for the MCP schema converted from a TypeScript schema.
• mcp/client.go: Client implementation for interacting with an MCP server.
• examples/mcp_client_example.go: A simple example demonstrating how to use the client.

✨ MCP Overview

The Model Context Protocol (MCP) enables communication between model "hosts" (e.g., LLM clients or systems interfacing with LLMs) and servers (systems that provide context information, tools, prompts, or resources to enhance LLM capabilities).

Key features of MCP include:

• Resources: Files, documents, and other data that hosts can read.
• Tools: Functions that hosts can call on behalf of the model.
• Prompts: Templates or predefined message sequences that hosts can use.
• Root Directory: The root of the file system or data that the server can operate on.

🚀 Quick Start

Prerequisites

• Go 1.18 or higher

Running the Example

# Set the MCP server URL (optional, default is http://localhost:3000/jsonrpc)
export MCP_SERVER_URL=http://your-mcp-server/jsonrpc

# Run the example
go run examples/mcp_client_example.go

💻 Usage Examples

Basic Usage

import (
    "fmt"
    
    "path/to/mcp"
)

func main() {
    // Create a new client
    client := mcp.NewClient("http://your-mcp-server/jsonrpc")
    
    // Initialize the client
    clientInfo := mcp.Implementation{
        Name:    "My MCP Client",
        Version: "1.0.0",
    }
    
    capabilities := mcp.ClientCapabilities{
        // Specify the capabilities your client supports
    }
    
    err := client.Initialize(clientInfo, capabilities)
    if err != nil {
        // Handle the error
    }
    
    // Now you can use various client methods:
    
    // List resources
    resources, err := client.ListResources("")
    
    // Read a resource
    resource, err := client.ReadResource("resource-uri")
    
    // Call a tool
    result, err := client.CallTool("tool-name", map[string]interface{}{
        "argument1": "value1",
        "argument2": 123,
    })
    
    // Get a prompt
    prompt, err := client.GetPrompt("prompt-name", map[string]string{
        "argName": "argValue",
    })
}

🔧 Technical Details

Schema

The Go schema definitions in mcp/schema.go provide a type-safe structure for MCP messages. This includes:

• JSON-RPC protocol structures
• Definitions for resources, prompts, and tools
• Content structures for text, image, and embedded resources
• Helper functions for handling polymorphic types via json.RawMessage

Client

The client implementation in mcp/client.go provides the following methods:

• Initializing a connection to an MCP server
• Sending requests and handling responses
• Converting Go structs to JSON-RPC messages
• Helper methods for common MCP operations

🤝 Contribution

Contributions are welcome! You can contribute in the following ways:

• Implement a server
• Submit issues or feature requests
• Submit code fixes or new features

Please refer to CONTRIBUTING.md for detailed information.

📄 License

This project is licensed under the MIT License.