Générateur de Projet Go MCP Server

Génère un projet Model Context Protocol (MCP) server complet et prêt pour la production en Go.

Prérequis du Projet

Vous allez créer un serveur Go MCP avec :

1. Structure du Projet : Organisation appropriée du module Go
2. Dépendances : SDK MCP officiel et packages nécessaires
3. Configuration du Serveur : Serveur MCP configuré avec transports
4. Outils : Au moins 2-3 outils utiles avec entrées/sorties typées
5. Gestion des Erreurs : Gestion appropriée des erreurs et utilisation du contexte
6. Documentation : README avec instructions de configuration et d'utilisation
7. Tests : Structure de test de base

Structure du Template

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

Template go.mod

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

go 1.23

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

Template 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)
    }
}

Template 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,
    )
}

Template 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
}

Template 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
}

Template 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")
    }
}

Template README.md

# {{PROJECT_NAME}}

Un serveur Model Context Protocol (MCP) construit avec Go.

## Description

{{PROJECT_DESCRIPTION}}

## Installation

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

## Utilisation

Exécutez le serveur avec le transport stdio :

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

## Configuration

Configurez via les variables d'environnement :

- `SERVER_NAME` : Nom du serveur (défaut : "{{PROJECT_NAME}}")
- `VERSION` : Version du serveur (défaut : "v1.0.0")
- `LOG_LEVEL` : Niveau de journalisation (défaut : "info")

## Outils Disponibles

### tool1
{{TOOL1_DESCRIPTION}}

**Entrée :**
- `param1` (string, requis) : Premier paramètre
- `param2` (int, optionnel) : Deuxième paramètre

**Sortie :**
- `result` (string) : Résultat de l'opération
- `status` (string) : Statut de l'opération

## Développement

Exécutez les tests :

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

Construisez :

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

## Licence

MIT

Instructions de Génération

Lors de la génération d'un serveur Go MCP :

1. Initialiser le Module : Créer go.mod avec le chemin du module approprié
2. Structure : Suivre la structure du répertoire template
3. Sécurité des Types : Utiliser des structs avec des tags JSON schema pour toutes les entrées/sorties
4. Gestion des Erreurs : Valider les entrées, vérifier le contexte, encapsuler les erreurs
5. Documentation : Ajouter des descriptions et des exemples clairs
6. Tests : Inclure au moins un test par outil
7. Configuration : Utiliser les variables d'environnement pour la configuration
8. Journalisation : Utiliser la journalisation structurée (log/slog)
9. Arrêt Gracieux : Gérer correctement les signaux
10. Transport : Par défaut stdio, documenter les alternatives

Bonnes Pratiques

• Garder les outils focalisés et monofonctionnels
• Utiliser des noms descriptifs pour les types et fonctions
• Inclure la documentation JSON schema dans les tags de struct
• Toujours respecter l'annulation du contexte
• Retourner des erreurs descriptives
• Garder main.go minimal, la logique dans les packages
• Écrire des tests pour les handlers d'outils
• Documenter toutes les fonctions exportées