Go MCP Server プロジェクトジェネレータ

Go で完全で本番対応の Model Context Protocol (MCP) サーバープロジェクトを生成します。

プロジェクト要件

以下を備えた Go MCP サーバーを作成します：

1. プロジェクト構造: 適切な Go モジュールレイアウト
2. 依存関係: 公式 MCP SDK と必要なパッケージ
3. サーバー設定: トランスポートが設定された MCP サーバー
4. ツール: 型付き入出力を備えた 2〜3 個以上の有用なツール
5. エラーハンドリング: 適切なエラーハンドリングとコンテキスト使用
6. ドキュメント: セットアップと使用方法を記載した README
7. テスト: 基本的なテスト構造

テンプレート構造

myserver/
├── go.mod
├── go.sum
├── main.go
├── tools/
│   ├── tool1.go
│   └── tool2.go
├── resources/
│   └── resource1.go
├── config/
│   └── config.go
├── README.md
└── main_test.go

go.mod テンプレート

module github.com/yourusername/{{PROJECT_NAME}}

go 1.23

require (
    github.com/modelcontextprotocol/go-sdk v1.0.0
)

main.go テンプレート

package main

import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/modelcontextprotocol/go-sdk/mcp"
    "github.com/yourusername/{{PROJECT_NAME}}/config"
    "github.com/yourusername/{{PROJECT_NAME}}/tools"
)

func main() {
    cfg := config.Load()
    
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // Handle graceful shutdown
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-sigCh
        log.Println("Shutting down...")
        cancel()
    }()

    // Create server
    server := mcp.NewServer(
        &mcp.Implementation{
            Name:    cfg.ServerName,
            Version: cfg.Version,
        },
        &mcp.Options{
            Capabilities: &mcp.ServerCapabilities{
                Tools:     &mcp.ToolsCapability{},
                Resources: &mcp.ResourcesCapability{},
                Prompts:   &mcp.PromptsCapability{},
            },
        },
    )

    // Register tools
    tools.RegisterTools(server)

    // Run server
    transport := &mcp.StdioTransport{}
    if err := server.Run(ctx, transport); err != nil {
        log.Fatalf("Server error: %v", err)
    }
}

tools/tool1.go テンプレート

package tools

import (
    "context"
    "fmt"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

type Tool1Input struct {
    Param1 string `json:"param1" jsonschema:"required,description=First parameter"`
    Param2 int    `json:"param2,omitempty" jsonschema:"description=Optional second parameter"`
}

type Tool1Output struct {
    Result string `json:"result" jsonschema:"description=The result of the operation"`
    Status string `json:"status" jsonschema:"description=Operation status"`
}

func Tool1Handler(ctx context.Context, req *mcp.CallToolRequest, input Tool1Input) (
    *mcp.CallToolResult,
    Tool1Output,
    error,
) {
    // Validate input
    if input.Param1 == "" {
        return nil, Tool1Output{}, fmt.Errorf("param1 is required")
    }

    // Check context
    if ctx.Err() != nil {
        return nil, Tool1Output{}, ctx.Err()
    }

    // Perform operation
    result := fmt.Sprintf("Processed: %s", input.Param1)

    return nil, Tool1Output{
        Result: result,
        Status: "success",
    }, nil
}

func RegisterTool1(server *mcp.Server) {
    mcp.AddTool(server,
        &mcp.Tool{
            Name:        "tool1",
            Description: "Description of what tool1 does",
        },
        Tool1Handler,
    )
}

tools/registry.go テンプレート

package tools

import "github.com/modelcontextprotocol/go-sdk/mcp"

func RegisterTools(server *mcp.Server) {
    RegisterTool1(server)
    RegisterTool2(server)
    // Register additional tools here
}

config/config.go テンプレート

package config

import "os"

type Config struct {
    ServerName string
    Version    string
    LogLevel   string
}

func Load() *Config {
    return &Config{
        ServerName: getEnv("SERVER_NAME", "{{PROJECT_NAME}}"),
        Version:    getEnv("VERSION", "v1.0.0"),
        LogLevel:   getEnv("LOG_LEVEL", "info"),
    }
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

main_test.go テンプレート

package main

import (
    "context"
    "testing"

    "github.com/yourusername/{{PROJECT_NAME}}/tools"
)

func TestTool1Handler(t *testing.T) {
    ctx := context.Background()
    input := tools.Tool1Input{
        Param1: "test",
        Param2: 42,
    }

    result, output, err := tools.Tool1Handler(ctx, nil, input)
    if err != nil {
        t.Fatalf("Tool1Handler failed: %v", err)
    }

    if output.Status != "success" {
        t.Errorf("Expected status 'success', got '%s'", output.Status)
    }

    if result != nil {
        t.Error("Expected result to be nil")
    }
}

README.md テンプレート

# {{PROJECT_NAME}}

Go で構築された Model Context Protocol (MCP) サーバー。

## 説明

{{PROJECT_DESCRIPTION}}

## インストール

\`\`\`bash
go mod download
go build -o {{PROJECT_NAME}}
\`\`\`

## 使用方法

stdio トランスポートを使用してサーバーを実行します：

\`\`\`bash
./{{PROJECT_NAME}}
\`\`\`

## 設定

環境変数で設定します：

- `SERVER_NAME`: サーバー名 (デフォルト: "{{PROJECT_NAME}}")
- `VERSION`: サーバーバージョン (デフォルト: "v1.0.0")
- `LOG_LEVEL`: ログレベル (デフォルト: "info")

## 利用可能なツール

### tool1
{{TOOL1_DESCRIPTION}}

**入力:**
- `param1` (文字列、必須): 最初のパラメータ
- `param2` (整数、オプション): 2 番目のパラメータ

**出力:**
- `result` (文字列): 操作の結果
- `status` (文字列): 操作のステータス

## 開発

テストを実行：

\`\`\`bash
go test ./...
\`\`\`

ビルド：

\`\`\`bash
go build -o {{PROJECT_NAME}}
\`\`\`

## ライセンス

MIT

生成手順

Go MCP サーバーを生成する際：

1. モジュール初期化: 適切なモジュールパスで go.mod を作成
2. 構造: テンプレートディレクトリ構造に従う
3. 型安全性: すべての入出力に JSON スキーマタグを備えた構造体を使用
4. エラーハンドリング: 入力を検証し、コンテキストを確認し、エラーをラップ
5. ドキュメント: 明確な説明と例を追加
6. テスト: ツールごとに少なくとも 1 つのテストを含める
7. 設定: 設定に環境変数を使用
8. ログ: 構造化ログ (log/slog) を使用
9. グレースフルシャットダウン: シグナルを適切に処理
10. トランスポート: デフォルトは stdio、代替方法をドキュメント化

ベストプラクティス

• ツールは焦点を絞り、単一の目的に保つ
• 型と関数に対して説明的な名前を使用
• JSON スキーマドキュメントを構造体タグに含める
• コンテキストキャンセルを常に尊重
• 説明的なエラーを返す
• ロジックを main.go で最小限に保つ、パッケージに配置
• ツールハンドラーのテストを作成
• すべてのエクスポートされた関数をドキュメント化