Skip to main content
Glama
deenesjakoruzh
breezykalama

MCPGen

by breezykalama
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

MCPGen

Genera servidores MCP seguros y conscientes de las políticas a partir de especificaciones OpenAPI.

MCPGen es un framework de Python MVP orientado a producción que convierte especificaciones OpenAPI en servidores de herramientas seguros por defecto. Puede generar un servidor de demostración FastAPI o un servidor stdio estilo MCP, manteniendo las operaciones de escritura bloqueadas a menos que el trabajo futuro de políticas las habilite explícitamente.

Problema

Las aplicaciones de IA a menudo necesitan acceso a muchas API, bases de datos y sistemas internos. Sin un framework, los equipos tienden a reconstruir las mismas integraciones repetidamente, exponer demasiadas herramientas al modelo y omitir controles de seguridad como la clasificación de riesgos, registros de auditoría y barreras para operaciones de escritura.

Los servidores MCP hacen que las herramientas estén disponibles para los sistemas de IA, pero los prototipos rápidos pueden exponer accidentalmente operaciones peligrosas como DELETE, POST, PATCH o PUT sin revisión.

Solución

MCPGen lee un archivo YAML o JSON de OpenAPI y genera:

  • descriptores de herramientas estructurados

  • listas de herramientas seguras expuestas

  • informes de herramientas retenidas

  • esquemas de entrada

  • un servidor FastAPI o MCP consciente de las políticas

  • vistas previas de ejecución (dry-run)

  • ejecución segura de GET

  • registros de auditoría en formato JSONL

  • enrutamiento semántico de herramientas con respaldo de palabras clave

El comportamiento predeterminado es intencionalmente conservador: solo se exponen herramientas GET de bajo riesgo.

Características

  • Análisis de YAML/JSON de OpenAPI

  • Generación de herramientas a partir de endpoints

  • Clasificación de riesgos:

    • GET = bajo

    • POST, PUT, PATCH = medio

    • DELETE = alto

  • Filtrado seguro por defecto

  • Generación de esquemas de entrada a partir de parámetros de ruta/consulta y cuerpos de solicitud JSON

  • Enrutamiento semántico de herramientas con respaldo de palabras clave

  • Modo FastAPI

  • Modo MCP stdio con tools/list y tools/call

  • Vistas previas de solicitudes (dry-run)

  • Ejecución real segura solo para herramientas GET de bajo riesgo

  • Motor de políticas central

  • Registro de auditoría en formato JSONL

  • Comandos CLI: generate, inspect

  • Configuración mediante mcpgen.yaml

Flujo de arquitectura

OpenAPI spec
  -> parser
  -> tool generator
  -> risk classifier
  -> safety filter
  -> tools.json / tools.all.json / tools.embeddings.json / safety_report.json
  -> generated FastAPI or MCP server
  -> policy engine
  -> semantic/keyword router
  -> dry-run or safe GET execution
  -> audit log

Inicio rápido

Instalar localmente:

pip install -e .[dev]

Inspeccionar una especificación:

mcpgen inspect --from examples/jsonplaceholder.openapi.yaml

Generar un servidor FastAPI:

mcpgen generate --from examples/jsonplaceholder.openapi.yaml --mode fastapi --output generated_jsonplaceholder

Ejecutarlo:

cd generated_jsonplaceholder
export API_BASE_URL=https://jsonplaceholder.typicode.com
uvicorn server:app --reload --port 8001

PowerShell:

cd generated_jsonplaceholder
$env:API_BASE_URL = "https://jsonplaceholder.typicode.com"
uvicorn server:app --reload --port 8001

Abrir:

http://127.0.0.1:8001/
http://127.0.0.1:8001/docs
http://127.0.0.1:8001/tools
http://127.0.0.1:8001/safety

Ejemplo de entrada OpenAPI

Especificación de demostración:

examples/jsonplaceholder.openapi.yaml

Incluye:

  • GET /users

  • GET /users/{id}

  • GET /posts

  • GET /posts/{id}

  • POST /posts

  • DELETE /posts/{id}

Extracto:

paths:
  /users/{id}:
    get:
      operationId: getUserById
      summary: Get user by ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer

Ejemplo de herramienta generada

Herramienta segura generada:

{
  "name": "get_user_by_id",
  "description": "Get user by ID",
  "method": "GET",
  "path": "/users/{id}",
  "risk_level": "low",
  "enabled": true,
  "operation_id": "getUserById",
  "input_schema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "integer",
        "description": "User ID",
        "x-mcpgen-location": "path"
      }
    },
    "required": ["id"]
  }
}

Las herramientas retenidas como create_post y delete_post permanecen en tools.all.json y se explican en safety_report.json.

Comandos de demostración de FastAPI

Desde la raíz del proyecto:

mcpgen generate --from examples/jsonplaceholder.openapi.yaml --mode fastapi --output generated_jsonplaceholder
cd generated_jsonplaceholder
export API_BASE_URL=https://jsonplaceholder.typicode.com
uvicorn server:app --reload --port 8001

PowerShell:

mcpgen generate --from examples/jsonplaceholder.openapi.yaml --mode fastapi --output generated_jsonplaceholder
cd generated_jsonplaceholder
$env:API_BASE_URL = "https://jsonplaceholder.typicode.com"
uvicorn server:app --reload --port 8001

Listar herramientas seguras expuestas:

curl http://127.0.0.1:8001/tools

Enrutar herramientas por consulta:

curl -X POST http://127.0.0.1:8001/tools \
  -H "Content-Type: application/json" \
  -d "{\"query\":\"get user by id\"}"

Equivalente en PowerShell:

Invoke-RestMethod -Method Post http://127.0.0.1:8001/tools `
  -ContentType "application/json" `
  -Body '{"query":"get user by id"}'

Ejecutar una herramienta segura en modo dry-run:

curl -X POST http://127.0.0.1:8001/tools/get_user_by_id/dry-run \
  -H "Content-Type: application/json" \
  -d "{\"inputs\":{\"id\":1}}"

Ejecutar una herramienta GET segura:

curl -X POST http://127.0.0.1:8001/execute \
  -H "Content-Type: application/json" \
  -d "{\"tool_name\":\"get_user_by_id\",\"params\":{\"id\":1}}"

Equivalente en PowerShell:

Invoke-RestMethod -Method Post http://127.0.0.1:8001/execute `
  -ContentType "application/json" `
  -Body '{"tool_name":"get_user_by_id","params":{"id":1}}'

Mostrar comportamiento bloqueado de POST:

curl -X POST http://127.0.0.1:8001/tools/create_post/dry-run \
  -H "Content-Type: application/json" \
  -d "{\"inputs\":{\"title\":\"Hello\",\"body\":\"Demo\",\"userId\":1}}"

Mostrar comportamiento bloqueado de DELETE:

curl -X POST http://127.0.0.1:8001/tools/delete_post/dry-run \
  -H "Content-Type: application/json" \
  -d "{\"inputs\":{\"id\":1}}"

Mostrar registro de auditoría:

cat logs/audit.log

Equivalente en PowerShell:

Get-Content logs\audit.log

Modo MCP

Generar un servidor stdio estilo MCP:

mcpgen generate --from examples/jsonplaceholder.openapi.yaml --mode mcp --output generated_jsonplaceholder_mcp

Ejecutar:

cd generated_jsonplaceholder_mcp
export API_BASE_URL=https://jsonplaceholder.typicode.com
python server.py

PowerShell:

cd generated_jsonplaceholder_mcp
$env:API_BASE_URL = "https://jsonplaceholder.typicode.com"
python server.py

Ejemplo de entrada JSON-RPC tools/list:

{"jsonrpc":"2.0","id":1,"method":"tools/list"}

Ejemplo de entrada de dry-run tools/call:

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_user_by_id","arguments":{"id":1}}}

El modo MCP utiliza los mismos tools.json, motor de políticas y registro de auditoría que el modo FastAPI. En el MVP actual, tools/call se ejecuta en modo dry-run por defecto. Con execution_mode: safe-execute, solo puede ejecutar herramientas GET de bajo riesgo.

Enrutamiento semántico de herramientas

MCPGen escribe tools.embeddings.json durante la generación y lo utiliza cuando:

routing_mode: semantic

Si las incrustaciones (embeddings) no están disponibles o el ranking semántico falla, MCPGen recurre automáticamente al enrutamiento por palabras clave. Puedes forzar el enrutamiento por palabras clave con:

routing_mode: keyword

El texto de la herramienta combina el nombre de la herramienta, la descripción y etiquetas opcionales. Ejemplo:

create_invoice create invoice for customer billing payments

Por defecto, MCPGen utiliza un respaldo de incrustación local determinista para que las demostraciones y pruebas funcionen sin descargas de modelos. Para usar sentence-transformers, configura:

export MCPGEN_EMBEDDING_BACKEND=sentence-transformers

PowerShell:

$env:MCPGEN_EMBEDDING_BACKEND = "sentence-transformers"

Compara los modos de enrutamiento cambiando routing_mode en mcpgen.yaml y regenerando el servidor. El modo semántico clasifica por similitud vectorial; el modo de palabras clave clasifica por superposición de tokens normalizados e incluye términos coincidentes.

Modelo de seguridad

MCPGen es seguro por defecto:

  • Solo las herramientas GET de bajo riesgo se exponen en tools.json.

  • Las herramientas de escritura de riesgo medio se retienen a menos que una configuración futura las habilite explícitamente.

  • Las herramientas DELETE de alto riesgo siempre están bloqueadas.

  • La ejecución real está restringida a herramientas GET de bajo riesgo.

  • La ejecución de escritura no está implementada.

  • La autenticación no está implementada.

Las decisiones de política devuelven:

{
  "allowed": false,
  "status": "blocked",
  "reason": "Medium-risk tool is not listed in enabled_tools.",
  "risk_level": "medium",
  "tool_name": "create_post"
}

Registro de auditoría

Los registros de auditoría son registros JSONL escritos en:

logs/audit.log

Configuración:

audit_enabled: true
audit_log_path: logs/audit.log
routing_mode: semantic

Cada evento incluye:

  • marca de tiempo

  • nombre de la herramienta

  • método

  • ruta

  • nivel de riesgo

  • modo

  • estado

  • permitido

  • motivo

  • fuente

  • acción

Las acciones incluyen:

  • policy_evaluation

  • dry_run

  • execution_started

  • execution_success

  • execution_error

  • execution_blocked

Configuración

Configuración por defecto:

max_tools: 5
allowed_methods:
  - GET
output_dir: generated_mcp_server
api_base_url: https://api.example.com
enabled_tools: []
execution_mode: dry-run
audit_enabled: true
audit_log_path: logs/audit.log

Para la demostración de JSONPlaceholder, configura:

api_base_url: https://jsonplaceholder.typicode.com

Limitaciones actuales

  • Este es un MVP orientado a producción, no un framework listo para producción.

  • Sin autenticación o manejo de secretos más allá de la preparación de variables de entorno.

  • Sin ejecución de escritura.

  • Sin interfaz de usuario para el flujo de confirmación.

  • Sin base de datos vectorial u optimización de caché de incrustaciones.

  • Sin limitación de tasa (rate limiting).

  • Sin sumidero de auditoría respaldado por base de datos.

  • El modo MCP utiliza un andamiaje stdio mínimo si el SDK oficial de MCP para Python no está disponible.

Hoja de ruta

  • Integración oficial del SDK de MCP

  • Gestión de autenticación y secretos

  • Flujo de trabajo de confirmación para herramientas de riesgo medio habilitadas

  • Limitación de tasa

  • Validación de solicitud/respuesta

  • Mejor soporte para esquemas OpenAPI

  • Sumideros de auditoría conectables

  • Mejores modelos de enrutamiento semántico y optimización de caché de incrustaciones

  • Plantillas de despliegue

This server cannot be installed

F
license - not found
-
quality - not tested
B
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
0dRelease cycle
4Releases (12mo)

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/breezykalama/mcpgen'

If you have feedback or need assistance with the MCP directory API, please join our Discord server