GoMCP

┌──────────────────────────────────────────────────────────────┐
│ User Code │
│ s.Tool() / s.ToolFunc() / s.Resource() / s.Prompt() │
├──────────────────────────────────────────────────────────────┤
│ Framework Core │
│ Router → Middleware Chain → Validation → Handler → Result │
├────────────┬─────────────┬───────────────┬───────────────────┤
│ Schema │ Validator │ Adapters │ Observability │
│ Generator │ Engine │ Gin/OpenAPI/ │ OTel / Logger │
│ (mcp tags) │ (auto) │ gRPC │ / Inspector │
├────────────┴─────────────┴───────────────┴───────────────────┤
│ Protocol Layer │
│ JSON-RPC 2.0 / MCP / Capability Negotiation │
├──────────────────────────────────────────────────────────────┤
│ Transport Layer │
│ stdio / Streamable HTTP + SSE │
└──────────────────────────────────────────────────────────────┘

gomcp/
├── server.go # Server core, tool/resource/prompt registration
├── context.go # Request context with typed accessors
├── group.go # Tool groups with prefix naming
├── middleware.go # Middleware interface and chain execution
├── middleware_builtin.go # Logger, Recovery, RequestID, Timeout, RateLimit
├── middleware_auth.go # BearerAuth, APIKeyAuth, BasicAuth, RBAC
├── middleware_otel.go # OpenTelemetry tracing
├── schema/ # struct tag → JSON Schema generator + validator
├── transport/ # stdio + Streamable HTTP
├── adapter/ # Gin, OpenAPI, gRPC adapters
├── mcptest/ # Testing utilities
├── task.go # Async task support
├── completion.go # Auto-completions
├── inspector.go # Web debug UI
├── provider.go # Hot-reload from YAML
└── examples/ # Working examples

go get github.com/zhangpanda/gomcp

package main

import (
 "fmt"
 "github.com/zhangpanda/gomcp"
)

type SearchInput struct {
 Query string `json:"query" mcp:"required,desc=Search keyword"`
 Limit int `json:"limit" mcp:"default=10,min=1,max=100"`
}

type SearchResult struct {
 Items []string `json:"items"`
 Total int `json:"total"`
}

func main() {
 s := gomcp.New("my-server", "1.0.0")

 s.ToolFunc("search", "Search documents by keyword", func(ctx *gomcp.Context, in SearchInput) (SearchResult, error) {
 items := []string{fmt.Sprintf("Result for %q", in.Query)}
 return SearchResult{Items: items, Total: len(items)}, nil
 })

 s.Stdio()
}

{
 "type": "object",
 "properties": {
 "query": { "type": "string", "description": "Search keyword" },
 "limit": { "type": "integer", "default": 10, "minimum": 1, "maximum": 100 }
 },
 "required": ["query"]
}

validation failed: query: required; limit: must be <= 100

s.Tool("hello", "Say hello", func(ctx *gomcp.Context) (*gomcp.CallToolResult, error) {
 return ctx.Text("Hello, " + ctx.String("name")), nil
})

type Input struct {
 Name string `json:"name" mcp:"required,desc=User name"`
 Email string `json:"email" mcp:"required,pattern=^[^@]+@[^@]+$"`
}

s.ToolFunc("create_user", "Create user", func(ctx *gomcp.Context, in Input) (User, error) {
 return db.CreateUser(in.Name, in.Email)
})

// Static
s.Resource("config://app", "App config", func(ctx *gomcp.Context) (any, error) {
 return map[string]any{"version": "1.0"}, nil
})

// Dynamic URI template
s.ResourceTemplate("db://{table}/{id}", "DB record", func(ctx *gomcp.Context) (any, error) {
 return db.Find(ctx.String("table"), ctx.String("id")), nil
})

s.Prompt("code_review", "Code review",
 []gomcp.PromptArgument{gomcp.PromptArg("language", "Language", true)},
 func(ctx *gomcp.Context) ([]gomcp.PromptMessage, error) {
 return []gomcp.PromptMessage{
 gomcp.UserMsg(fmt.Sprintf("Review this %s code for bugs.", ctx.String("language"))),
 }, nil
 },
)

s.Use(gomcp.Logger()) // Log tool name + duration
s.Use(gomcp.Recovery()) // Recover from panics
s.Use(gomcp.RequestID()) // Unique request ID
s.Use(gomcp.Timeout(10 * time.Second)) // Deadline enforcement
s.Use(gomcp.RateLimit(100)) // 100 calls/minute
s.Use(gomcp.OpenTelemetry()) // Distributed tracing
s.Use(gomcp.BearerAuth(tokenValidator)) // JWT auth
s.Use(gomcp.APIKeyAuth("X-API-Key", keyValidator)) // API key auth

func AuditLog() gomcp.Middleware {
 return func(ctx *gomcp.Context, next func() error) error {
 start := time.Now()
 err := next()
 log.Printf("tool=%s duration=%s err=%v", ctx.String("_tool_name"), time.Since(start), err)
 return err
 }
}

user := s.Group("user", authMiddleware)
user.Tool("get", "Get user", getUser) // → user.get
user.Tool("update", "Update user", updateUser) // → user.update

admin := user.Group("admin", gomcp.RequireRole("admin"))
admin.Tool("delete", "Delete user", deleteUser) // → user.admin.delete

adapter.ImportGin(s, ginRouter, adapter.ImportOptions{
 IncludePaths: []string{"/api/v1/"},
})
// GET /api/v1/users/:id → Tool get_api_v1_users_by_id (id = required param)

adapter.ImportOpenAPI(s, "./swagger.yaml", adapter.OpenAPIOptions{
 TagFilter: []string{"pets"},
 ServerURL: "https://api.example.com",
})

adapter.ImportGRPC(s, grpcConn, adapter.GRPCOptions{
 Services: []string{"user.UserService"},
})

s.ToolFunc("search", "v1", searchV1, gomcp.Version("1.0"))
s.ToolFunc("search", "v2 with embeddings", searchV2, gomcp.Version("2.0"))
// "search" → latest, "search@1.0" → exact version

s.AsyncTool("report", "Generate report", func(ctx *gomcp.Context) (*gomcp.CallToolResult, error) {
 // long-running work
 return ctx.Text("done"), nil
})
// Client gets taskId immediately, polls tasks/get, can tasks/cancel

s.LoadDir("./tools/", gomcp.DirOptions{Watch: true})

s.Dev(":9090") // http://localhost:9090 — browse and test all tools

func TestSearch(t *testing.T) {
 c := mcptest.NewClient(t, setupServer())
 c.Initialize()

 result := c.CallTool("search", map[string]any{"query": "golang"})
 result.AssertNoError(t)
 result.AssertContains(t, "golang")

 mcptest.MatchSnapshot(t, "search_result", result)
}

s.Stdio() // Claude Desktop, Cursor, Kiro
s.HTTP(":8080") // Remote deployment with SSE
s.Handler() // Embed in existing HTTP server

{
 "mcpServers": {
 "my-server": {
 "command": "/path/to/your/binary"
 }
 }
}