Go MCP

🚀 go-mcp

go-mcp is a Go SDK for building MCP (Model Context Protocol) servers. It emphasizes type safety and intuitive interfaces.

🚀 Quick Start

Example Directory Structure

The project directory structure is as follows:

your-project/
  cmd/temperature/
    main.go
    handler.go
  cmd/mcpgen/
    main.go

Example Code

Step 1: Define the MCP Server

Run the mcpgen tool to generate code:

go run ./cmd/mcpgen

Step 2: Implement the MCP Server Logic

Implement the logic in handler.go, for example, a temperature conversion tool:

package main

import (
	"context"
	"fmt"
	"math"
)

type toolHandler struct{}

func NewHandler(h *toolHandler) mcp.Handler {
	return mcp.HandlerFunc(func(ctx context.Context, req *mcp.Request) (*mcp.Response, error) {
		if req.IsPing() {
			return &mcp.Response{Id: req.Id}, nil
		}
		if req.IsCallTool() {
			content := req.GetCallTool().Content
			tool := content[0].GetTool()
			switch tool.ID {
			case "temperature-converter":
				fromUnit := string(tool.Params["from_unit"])
				toUnit := string(tool.Params["to_unit"])
				temp, err := tool.Params["temperature"].(float64)
				if err != nil {
					return nil, fmt.Errorf("invalid temperature value")
				}
				result := convertTemperature(temp, fromUnit, toUnit)
				return &mcp.Response{
					Id:    req.Id,
					Data:  mcp.NewData(map[string]interface{}{
						"result": result,
					}),
				}, nil
			default:
				return nil, fmt.Errorf("tool not found")
			}
		}
		return nil, nil
	})
}

func convertTemperature(value float64, fromUnit string, toUnit string) float64 {
	switch fromUnit {
	case "celsius":
		switch toUnit {
		case "fahrenheit":
			return (value * 9.0 / 5.0) + 32
		default:
			return value
		}
	case "fahrenheit":
		switch toUnit {
		case "celsius":
			return (value - 32) * 5.0 / 9.0
		default:
			return value
		}
	default:
		return value
	}
}

func main() {
	handler := NewHandler(new(toolHandler))
	server := mcp.NewServer(":8080", handler)
	if err := server.Start(); err != nil {
		fmt.Printf("Failed to start server: %v\n", err)
	}
}

Run the following command in the terminal to start the server:

go run ./cmd/temperature/main.go

✨ Features

• Type Safety: Ensure static typing of tool and prompt parameters through code generation, capturing errors at compile time.
• Simple and Intuitive API: Provide natural, Go-style interfaces to reduce the learning curve.
• Developer-Friendly: Focus on the usability of the API.

💻 Usage Examples

Send a Ping Request

Send a ping request using the curl command:

curl -X POST http://localhost:8080/ping

Call the Temperature Conversion Tool

Call the predefined "temperature-converter" tool:

curl -X POST http://localhost:8080/call_tool \
  --data '{"tool_id":"temperature-converter","params":{"from_unit":"celsius","to_unit":"fahrenheit","temperature":32}}'

View the Tool List

List all registered tools:

curl -X GET http://localhost:8080/tools

📚 Documentation

• Ping: Verify server connectivity.
• Tools: Manage tool registration and invocation.
• Prompts: Handle user prompt requests.

For more features, please refer to the project documentation.

📄 License

This project is licensed under the MIT License. See the LICENSE file for details.