SKILL.md
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:
- Project Structure: Proper Go module layout
- Dependencies: Official MCP SDK and necessary packages
- Server Setup: Configured MCP server with transports
- Tools: At least 2-3 useful tools with typed inputs/outputs
- Error Handling: Proper error handling and context usage
- Documentation: README with setup and usage instructions
- 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.gogo.mod Template
module github.com/yourusername/{{PROJECT_NAME}}
go 1.23
require (
github.com/modelcontextprotocol/go-sdk v1.0.0
)main.go Template
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 Template
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 Template
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 Template
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 Template
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 Template
# {{PROJECT_NAME}}
A Model Context Protocol (MCP) server built with Go.
## Description
{{PROJECT_DESCRIPTION}}
## Installation
\`\`\`bash
go mod download
go 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:
\`\`\`bash
go test ./...
\`\`\`
Build:
\`\`\`bash
go build -o {{PROJECT_NAME}}
\`\`\`
## License
MITGeneration Instructions
When generating a Go MCP server:
- Initialize Module: Create
go.modwith proper module path
- Structure: Follow the template directory structure
- Type Safety: Use structs with JSON schema tags for all inputs/outputs
- Error Handling: Validate inputs, check context, wrap errors
- Documentation: Add clear descriptions and examples
- Testing: Include at least one test per tool
- Configuration: Use environment variables for config
- Logging: Use structured logging (log/slog)
- Graceful Shutdown: Handle signals properly
- 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