PaperclipOrg
Claude Agent Skill · by Github

Go Mcp Server Generator

Go-mcp-server-generator creates a complete, production-ready Model Context Protocol (MCP) server project in Go with proper module structure, the official MCP SD

Install
Terminal · npx
$npx skills add https://github.com/github/awesome-copilot --skill go-mcp-server-generator
Works with Paperclip

How Go Mcp Server Generator fits into a Paperclip company.

Go Mcp Server Generator drops into any Paperclip agent that handles this kind of work. Assign it to a specialist inside a pre-configured PaperclipOrg company and the skill becomes available on every heartbeat — no prompt engineering, no tool wiring.

S
SaaS FactoryPaired

Pre-configured AI company — 18 agents, 18 skills, one-time purchase.

$27$59
Explore pack
Source file
SKILL.md334 lines
Expand
---name: go-mcp-server-generatordescription: 'Generate a complete Go MCP server project with proper structure, dependencies, and implementation using the official github.com/modelcontextprotocol/go-sdk.'--- # Go MCP Server Project Generator Generate a complete, production-ready Model Context Protocol (MCP) server project in Go. ## Project Requirements You will create a Go MCP server with: 1. **Project Structure**: Proper Go module layout2. **Dependencies**: Official MCP SDK and necessary packages3. **Server Setup**: Configured MCP server with transports4. **Tools**: At least 2-3 useful tools with typed inputs/outputs5. **Error Handling**: Proper error handling and context usage6. **Documentation**: README with setup and usage instructions7. **Testing**: Basic test structure ## Template Structure ```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 Template ```gomodule github.com/yourusername/{{PROJECT_NAME}} go 1.23 require (    github.com/modelcontextprotocol/go-sdk v1.0.0)``` ## main.go Template ```gopackage 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 Template ```gopackage 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 Template ```gopackage tools import "github.com/modelcontextprotocol/go-sdk/mcp" func RegisterTools(server *mcp.Server) {    RegisterTool1(server)    RegisterTool2(server)    // Register additional tools here}``` ## config/config.go Template ```gopackage 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 Template ```gopackage 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 Template ```markdown# {{PROJECT_NAME}} A Model Context Protocol (MCP) server built with Go. ## Description {{PROJECT_DESCRIPTION}} ## Installation \`\`\`bashgo mod downloadgo build -o {{PROJECT_NAME}}\`\`\` ## Usage Run the server with stdio transport: \`\`\`bash./{{PROJECT_NAME}}\`\`\` ## Configuration Configure via environment variables: - `SERVER_NAME`: Server name (default: "{{PROJECT_NAME}}")- `VERSION`: Server version (default: "v1.0.0")- `LOG_LEVEL`: Logging level (default: "info") ## Available Tools ### tool1{{TOOL1_DESCRIPTION}} **Input:**- `param1` (string, required): First parameter- `param2` (int, optional): Second parameter **Output:**- `result` (string): Operation result- `status` (string): Status of the operation ## Development Run tests: \`\`\`bashgo test ./...\`\`\` Build: \`\`\`bashgo build -o {{PROJECT_NAME}}\`\`\` ## License MIT``` ## Generation Instructions When generating a Go MCP server: 1. **Initialize Module**: Create `go.mod` with proper module path2. **Structure**: Follow the template directory structure3. **Type Safety**: Use structs with JSON schema tags for all inputs/outputs4. **Error Handling**: Validate inputs, check context, wrap errors5. **Documentation**: Add clear descriptions and examples6. **Testing**: Include at least one test per tool7. **Configuration**: Use environment variables for config8. **Logging**: Use structured logging (log/slog)9. **Graceful Shutdown**: Handle signals properly10. **Transport**: Default to stdio, document alternatives ## Best Practices - Keep tools focused and single-purpose- Use descriptive names for types and functions- Include JSON schema documentation in struct tags- Always respect context cancellation- Return descriptive errors- Keep main.go minimal, logic in packages- Write tests for tool handlers- Document all exported functions