MCP Wrapper for Echo Framework

1# MCP Wrapper for Echo Framework
2 
3[![Build Status](https://github.com/BrunoKrugel/echo-mcp/actions/workflows/run-test.yaml/badge.svg?branch=main)](https://github.com/features/actions)
4[![Codecov branch](https://img.shields.io/codecov/c/github/BrunoKrugel/echo-mcp/main.svg)](https://codecov.io/gh/BrunoKrugel/echo-mcp)
5[![Go Report Card](https://goreportcard.com/badge/github.com/BrunoKrugel/echo-mcp)](https://goreportcard.com/report/github.com/BrunoKrugel/echo-mcp)
6[![Release](https://img.shields.io/github/release/BrunoKrugel/echo-mcp.svg?style=flat-square)](https://github.com/BrunoKrugel/echo-mcp/releases)
7 
8Wrap any existing Echo API into MCP tools, enabling AI agents to interact with your API through [Model Context Protocol](https://modelcontextprotocol.io/introduction).
9 
10Inspired by [gin-mcp](https://github.com/ckanthony/gin-mcp) but for the [Echo framework](https://echo.labstack.com/).
11 
12## Key Features
13 
14- **Zero Configuration**: Works with any existing Echo API
15- **Multiple Schema Sources**: Support for Swaggo, raw OpenAPI YAML/JSON, and manual schemas
16- **Filtering**: Include/exclude endpoints with wildcard patterns
17- **MCP Compatible**: Works with any agent that supports MCP.
18 
19## Installation
20 
21```bash
22go get github.com/BrunoKrugel/echo-mcp
23```
24 
25## Quick Start
26 
27```go
28package main
29 
30import (
31    "net/http"
32    server "github.com/BrunoKrugel/echo-mcp"
33    "github.com/labstack/echo/v4"
34)
35 
36func main() {
37    e := echo.New()
38 
39    // Existing API routes
40    e.GET("/ping", func(c echo.Context) error {
41        return c.JSON(http.StatusOK, map[string]string{"message": "pong"})
42    })
43 
44 
45    // Add MCP support
46    mcp := server.New(e)
47    mcp.Mount("/mcp")
48 
49    e.Start(":8080")
50}
51```
52 
53Now the API is accessible at `http://localhost:8080/mcp`
54 
55## Advanced Usage
56 
57### Automatic Swagger Schemas
58 
59If you already use Swaggo for Swagger documentation, enable automatic schema generation:
60 
61```go
62// @Summary Get user by ID
63// @Description Retrieve detailed user information
64// @Tags users
65// @Param id path int true "User ID" minimum(1)
66// @Success 200 {object} User
67// @Router /users/{id} [get]
68func GetUser(c echo.Context) error {
69    // Your handler code
70}
71 
72func main() {
73    e := echo.New()
74    e.GET("/users/:id", GetUser)
75 
76    // Enable automatic swagger schema generation
77    mcp := server.NewWithConfig(e, &server.Config{
78        BaseURL:              "http://localhost:8080",
79        EnableSwaggerSchemas: true,
80    })
81    mcp.Mount("/mcp")
82 
83    e.Start(":8080")
84}
85```
86 
87### Raw OpenAPI Schema Support
88 
89If you use other OpenAPI libraries like `swaggest/openapi-go`, you can pass a raw YAML or JSON schema string:
90 
91```go
92import (
93    "github.com/swaggest/openapi-go/openapi3"
94    server "github.com/BrunoKrugel/echo-mcp"
95)
96 
97func main() {
98    e := echo.New()
99 
100    // ... define your routes ...
101 
102    // Generate OpenAPI schema
103    reflector := openapi3.Reflector{}
104    reflector.SpecEns().WithOpenapi("3.0.3")
105    reflector.SpecEns().Info.WithTitle("My API").WithVersion("1.0.0")
106 
107    // Add operations to reflector
108    // ...
109 
110    // Export to YAML (or JSON)
111    schema, _ := reflector.Spec.MarshalYAML()
112 
113    // Pass raw schema to MCP server
114    // ... you can also embed the schema from an exiting openapi.yaml file
115    mcp := server.NewWithConfig(e, &server.Config{
116        OpenAPISchema: string(schema),
117    })
118    mcp.Mount("/mcp")
119 
120    e.Start(":8080")
121}
122```
123 
124The `OpenAPISchema` field accepts both YAML and JSON formatted strings. When provided, it automatically populates:
125- Server name from schema title
126- Description from schema description
127- Version from schema version
128- Tool schemas from operation definitions
129 
130### Endpoint Filtering
131 
132Expose only the necessary endpoints to MCP tools:
133 
134```go
135mcp := server.New(e)
136 
137// Include only specific endpoints
138mcp.RegisterEndpoints([]string{
139    "/api/v1/users/:id",
140    "/api/v1/orders",
141})
142 
143// Or exclude internal endpoints
144mcp.ExcludeEndpoints([]string{
145    "/health",      // Exclude health checks
146})
147```
148 
149### Manual Schema Registration (WIP)
150 
151For better control, register schemas manually:
152 
153```go
154type CreateUserRequest struct {
155    Name  string `json:"name" jsonschema:"required,description=User full name"`
156    Email string `json:"email" jsonschema:"required,description=User email address"`
157    Age   int    `json:"age,omitempty" jsonschema:"minimum=0,maximum=150"`
158}
159 
160type UserQuery struct {
161    Page   int    `form:"page,default=1" jsonschema:"minimum=1"`
162    Limit  int    `form:"limit,default=10" jsonschema:"maximum=100"`
163    Active bool   `form:"active" jsonschema:"description=Filter by active status"`
164}
165 
166mcp := server.New(e, &server.Config{BaseURL: "http://localhost:8080"})
167 
168// Register schemas for specific routes
169mcp.RegisterSchema("POST", "/users", nil, CreateUserRequest{})
170mcp.RegisterSchema("GET", "/users", UserQuery{}, nil)
171```
172 
173## Schema Generation Methods
174 
175Echo-MCP supports four schema generation approaches, with automatic fallback:
176 
177| Method | Use Case | Priority |
178|--------|----------|----------|
179| **Raw OpenAPI Schema** | Using OpenAPI libraries like swaggest/openapi-go | First (if OpenAPISchema is set) |
180| **Swagger** | Production APIs with Swaggo annotations | First (if EnableSwaggerSchemas is set) |
181| **Manual** | Fine-grained control, complex validation | Second |
182| **Automatic** | Quick prototyping, simple endpoints | Fallback |
183 
184```go
185// Option 1: Using raw OpenAPI schema (swaggest/openapi-go, etc.)
186schema, _ := reflector.Spec.MarshalYAML()
187mcp := server.New(e, &server.Config{
188    OpenAPISchema: string(schema), // Use raw schema
189})
190 
191// Option 2: Using Swaggo
192mcp := server.New(e, &server.Config{
193    EnableSwaggerSchemas: true, // Load from swaggo docs
194})
195 
196// Option 3: Manual schemas for fine-grained control
197mcp.RegisterSchema("POST", "/users", nil, CreateUserRequest{})
198 
199// Option 4: Automatic inference (fallback)
200// No configuration needed - routes will use basic path/body inference
201```
202 
203## MCP Client Integration
204 
205Once your server is running:
206 
207### Manual configuration
208 
209```json
210{
211  "mcpServers": {
212    "echo-api": {
213      "type": "http",
214      "url": "http://localhost:8080/mcp",
215      "timeout": 120
216    },
217  }
218}
219```
220 
221## Local Testing
222 
223For local testing, use MCP Inspector:
224 
225```bash
226npx @modelcontextprotocol/inspector http://localhost:8080/mcp
227```
228 
229## Acknowledgments
230 
231- [Swaggo](https://github.com/swaggo/swag) - Swagger documentation generator
232- [swaggest/openapi-go](https://github.com/swaggest/openapi-go) - OpenAPI 3.0 toolkit for Go
233- [Echo Framework](https://echo.labstack.com/) - High performance Go web framework
234- [Echo Swagger](https://github.com/swaggo/echo-swagger) - Swagger UI middleware for Echo
235- [Model Context Protocol](https://modelcontextprotocol.io/) - Universal protocol for AI-tool interaction
236