echo-mcp

Wrapper MCP para o Framework Echo

Envolva qualquer API Echo existente em ferramentas MCP e permita que agentes de IA interajam com sua API por meio do Model Context Protocol.

Inspirado no gin-mcp, mas para o framework Echo.

Principais Recursos

• Zero Configuração: Funciona com qualquer API Echo existente
• Múltiplas Fontes de Schema: Suporte para Swaggo, OpenAPI YAML/JSON bruto e schemas manuais
• Filtragem: Inclua/exclua endpoints com padrões curinga
• Compatível com MCP: Funciona com qualquer agente que suporte MCP.

Instalação

go get github.com/BrunoKrugel/echo-mcp

Início Rápido

package main

import (
    "net/http"
    server "github.com/BrunoKrugel/echo-mcp"
    "github.com/labstack/echo/v4"
)

func main() {
    e := echo.New()

    // Existing API routes
    e.GET("/ping", func(c echo.Context) error {
        return c.JSON(http.StatusOK, map[string]string{"message": "pong"})
    })


    // Add MCP support
    mcp := server.New(e)
    mcp.Mount("/mcp")

    e.Start(":8080")
}

Agora a API está acessível em http://localhost:8080/mcp

Uso Avançado

Schemas Swagger Automáticos

Se você já usa Swaggo para documentação Swagger, habilite a geração automática de schemas:

// @Summary Get user by ID
// @Description Retrieve detailed user information
// @Tags users
// @Param id path int true "User ID" minimum(1)
// @Success 200 {object} User
// @Router /users/{id} [get]
func GetUser(c echo.Context) error {
    // Your handler code
}

func main() {
    e := echo.New()
    e.GET("/users/:id", GetUser)

    // Enable automatic swagger schema generation
    mcp := server.NewWithConfig(e, &server.Config{
        BaseURL:              "http://localhost:8080",
        EnableSwaggerSchemas: true,
    })
    mcp.Mount("/mcp")

    e.Start(":8080")
}

Suporte a Schema OpenAPI Bruto

Se você usa outras bibliotecas OpenAPI como swaggest/openapi-go, você pode passar uma string de schema YAML ou JSON bruta:

import (
    "github.com/swaggest/openapi-go/openapi3"
    server "github.com/BrunoKrugel/echo-mcp"
)

func main() {
    e := echo.New()

    // ... define your routes ...

    // Generate OpenAPI schema
    reflector := openapi3.Reflector{}
    reflector.SpecEns().WithOpenapi("3.0.3")
    reflector.SpecEns().Info.WithTitle("My API").WithVersion("1.0.0")

    // Add operations to reflector
    // ...

    // Export to YAML (or JSON)
    schema, _ := reflector.Spec.MarshalYAML()

    // Pass raw schema to MCP server
    // ... you can also embed the schema from an exiting openapi.yaml file
    mcp := server.NewWithConfig(e, &server.Config{
        OpenAPISchema: string(schema),
    })
    mcp.Mount("/mcp")

    e.Start(":8080")
}

O campo OpenAPISchema aceita strings formatadas em YAML e JSON. Quando fornecido, ele preenche automaticamente:

• Nome do servidor a partir do título do schema
• Descrição a partir da descrição do schema
• Versão a partir da versão do schema
• Schemas de ferramentas a partir das definições de operação

Filtragem de Endpoints

Exponha apenas os endpoints necessários para as ferramentas MCP:

mcp := server.New(e)

// Include only specific endpoints
mcp.RegisterEndpoints([]string{
    "/api/v1/users/:id",
    "/api/v1/orders",
})

// Or exclude internal endpoints
mcp.ExcludeEndpoints([]string{
    "/health",      // Exclude health checks
})

Registro Manual de Schema (Em Desenvolvimento)

Para maior controle, registre schemas manualmente:

type CreateUserRequest struct {
    Name  string `json:"name" jsonschema:"required,description=User full name"`
    Email string `json:"email" jsonschema:"required,description=User email address"`
    Age   int    `json:"age,omitempty" jsonschema:"minimum=0,maximum=150"`
}

type UserQuery struct {
    Page   int    `form:"page,default=1" jsonschema:"minimum=1"`
    Limit  int    `form:"limit,default=10" jsonschema:"maximum=100"`
    Active bool   `form:"active" jsonschema:"description=Filter by active status"`
}

mcp := server.New(e, &server.Config{BaseURL: "http://localhost:8080"})

// Register schemas for specific routes
mcp.RegisterSchema("POST", "/users", nil, CreateUserRequest{})
mcp.RegisterSchema("GET", "/users", UserQuery{}, nil)

Métodos de Geração de Schema

O Echo-MCP suporta quatro abordagens de geração de schema, com fallback automático:

Método	Caso de Uso	Prioridade
Schema OpenAPI Bruto	Uso de bibliotecas OpenAPI como swaggest/openapi-go	Primeira (se OpenAPISchema estiver definido)
Swagger	APIs de produção com anotações Swaggo	Primeira (se EnableSwaggerSchemas estiver definido)
Manual	Controle refinado, validação complexa	Segunda
Automático	Prototipagem rápida, endpoints simples	Fallback

// Option 1: Using raw OpenAPI schema (swaggest/openapi-go, etc.)
schema, _ := reflector.Spec.MarshalYAML()
mcp := server.New(e, &server.Config{
    OpenAPISchema: string(schema), // Use raw schema
})

// Option 2: Using Swaggo
mcp := server.New(e, &server.Config{
    EnableSwaggerSchemas: true, // Load from swaggo docs
})

// Option 3: Manual schemas for fine-grained control
mcp.RegisterSchema("POST", "/users", nil, CreateUserRequest{})

// Option 4: Automatic inference (fallback)
// No configuration needed - routes will use basic path/body inference

Integração com Cliente MCP

Depois que seu servidor estiver em execução:

Configuração manual

{
  "mcpServers": {
    "echo-api": {
      "type": "http",
      "url": "http://localhost:8080/mcp",
      "timeout": 120
    },
  }
}

Testes Locais

Para testes locais, use o MCP Inspector:

npx @modelcontextprotocol/inspector http://localhost:8080/mcp

Agradecimentos

• Swaggo - Gerador de documentação Swagger
• swaggest/openapi-go - Kit de ferramentas OpenAPI 3.0 para Go
• Framework Echo - Framework web Go de alto desempenho
• Echo Swagger - Middleware de interface Swagger para Echo
• Model Context Protocol - Protocolo universal para interação com ferramentas de IA