MCP Go Sdk

🚀 MCP-Go SDK

A Go SDK for building Model Communication Protocol (MCP) tools and servers. This SDK provides the basic modules required to implement MCP-compatible tools, which can be used in AI applications such as Cursor IDE.

🚀 Quick Start

Check out the example server in servers/example to see the minimum implementation of a simple MCP tool for echoing messages:

package main

import (
    "encoding/json"
    "mcp-go/server"
    "mcp-go/transport"
)

// EchoTool 实现了一个简单的回显工具
type EchoTool struct{}

func (t *EchoTool) Name() string {
    return "echo"
}

func (t *EchoTool) Description() string {
    return "A simple echo tool that returns the input message"
}

func (t *EchoTool) Schema() json.RawMessage {
    return json.RawMessage(`{
        "type": "object",
        "properties": {
            "message": {
                "type": "string",
                "description": "The message to echo back"
            }
        },
        "required": ["message"]
    }`)
}

func (t *EchoTool) Execute(params json.RawMessage) (interface{}, error) {
    var input struct {
        Message string `json:"message"`
    }
    if err := json.Unmarshal(params, &input); err != nil {
        return nil, err
    }
    
    return map[string]interface{}{
        "content": []map[string]interface{}{
            {
                "type": "text",
                "text": input.Message,
            },
        },
        "metadata": map[string]interface{}{
            "length": len(input.Message),
        },
    }, nil
}

func main() {
    // 创建一个带有标准输入输出传输的新服务器
    srv := server.NewServer(transport.NewStdioTransport())
    
    // 注册你的工具
    if err := srv.RegisterTool(&EchoTool{}); err != nil {
        panic(err)
    }
    
    // 启动服务器
    if err := srv.Start(); err != nil {
        panic(err)
    }
}

📚 Documentation

✨ Core Concepts

🔧 Tools

Tools in MCP are services that can be invoked by AI applications. Each tool must implement the mcp.Tool interface:

type Tool interface {
    // Name returns the unique identifier of this tool
    Name() string
    
    // Description returns a human-readable description
    Description() string
    
    // Schema returns the JSON schema of the tool's parameters
    Schema() json.RawMessage
    
    // Execute runs the tool with the given parameters
    Execute(params json.RawMessage) (interface{}, error)
}

📄 Response Format

Tools should return responses in the MCP format:

{
    "content": [
        {
            "type": "text",
            "text": "Your response text"
        }
    ],
    "metadata": {
        // Optional response metadata
    }
}

🚚 Transport Layer

The SDK provides a flexible transport layer implemented through the Transport interface:

type Transport interface {
    // Send a data packet
    Send() error
    
    // Receive a data packet
    Receive() ([]byte, error)
    
    // Close the transport
    Close()
}

By default, the SDK provides a transport based on standard input and output for command-line tools.

⚙️ Configuration

To use MCP tools, create a file named .mcp.json in the project root directory and add the following content:

{
    "command": "your_command",
    "args": ["arg1", "arg2"],
    "env": {
        "VAR1": "VALUE1",
        "VAR2": "VALUE2"
    }
}

🤝 Contribution Guidelines

To contribute to the MCP-Go SDK, please follow these steps:

1. Report bugs or feature requests: Submit issues on the GitHub Issues page.
2. Fix bugs or add new features: Clone the repository, create a branch, and submit your changes.
3. Add test cases: Ensure that appropriate unit tests are added for all new features and fixes.
4. Submit a pull request: Submit your changes on the GitHub Pull Request page.

By following these steps, you can help improve the MCP-Go SDK and make it even better.