MCP-Anything

Un comando para convertir cualquier base de código en un servidor MCP. No solo APIs REST. No solo especificaciones OpenAPI.

Primeros pasos

pip install mcp-anything

# Generate an MCP server from any codebase
mcp-anything generate /path/to/your/app

# Or from a URL (OpenAPI, GraphQL, gRPC spec)
mcp-anything generate https://api.example.com/openapi.json

# Or directly from a local spec file
mcp-anything generate ./openapi.json

Obtendrás un servidor MCP completo, instalable mediante pip, en ./mcp-<name>-server/. Añádelo a tu agente en segundos:

stdio (local, predeterminado): añade mcp.json a tu .mcp.json de Claude Code:

{
  "mcpServers": {
    "my-app": { "command": "mcp-my-app", "args": [] }
  }
}

HTTP (remoto/compartido, recomendado): inicia el servidor y apunta tu agente hacia él:

mcp-anything generate /path/to/app --transport http
mcp-my-app  # server runs on http://localhost:8000/sse

{
  "mcpServers": {
    "my-app": { "url": "http://localhost:8000/sse" }
  }
}

Objetivos

Por defecto, mcp-anything genera un servidor Python / FastMCP. Usa --target=mcp-use para generar un servidor TypeScript / mcp-use en su lugar:

mcp-anything generate /path/to/app --target mcp-use

El servidor TypeScript utiliza el SDK mcp-use e incluye un inspector integrado.

Qué es compatible

mcp-anything detecta y envuelve código fuente en 8 ecosistemas: frameworks REST, herramientas CLI, especificaciones de API y servicios basados en protocolos.

Pasa una URL directamente para especificaciones de API: mcp-anything generate https://api.example.com/openapi.json

Alcance: controla qué se expone

Las bases de código grandes pueden tener cientos o miles de endpoints. No querrás que todos sean herramientas MCP. Tres mecanismos te permiten controlar el alcance:

Filtro rápido con --include / --exclude:

# Only expose /api/v2 endpoints
mcp-anything generate ./my-app --include "/api/v2/*"

# Exclude internal and debug routes
mcp-anything generate ./my-app --exclude "/internal/*" --exclude "debug_*"

Modo de revisión — curar antes de generar:

# Step 1: analyze and pause
mcp-anything generate ./my-app --review

# Step 2: edit the generated scope.yaml (enable/disable per capability)
vim mcp-my-app-server/scope.yaml

# Step 3: resume generation with your curated scope
mcp-anything generate ./my-app --resume

Archivo de alcance reutilizable:

# Use a pre-built scope file (check it into your repo)
mcp-anything generate ./my-app --scope-file ./mcp-scope.yaml

Los patrones coinciden con los nombres de las capacidades, las rutas de los archivos fuente y las descripciones utilizando sintaxis glob. En el archivo de alcance, también puedes establecer enabled: false en capacidades individuales para un control preciso.

Sobrescritura de descripciones: personaliza las descripciones de las herramientas

Las descripciones autogeneradas provienen del código fuente (docstrings, resúmenes de OpenAPI, comentarios de rutas). Suelen ser lo suficientemente buenas, pero a veces querrás una redacción más clara para tu agente LLM.

Después de la generación, se escribe un archivo descriptions.yaml en el directorio de salida con la descripción de cada herramienta y parámetro. Edítalo y luego vuelve a ejecutar con --description para aplicar tus cambios:

# 1. Generate as usual
mcp-anything generate ./my-app

# 2. Edit descriptions
vim mcp-my-app-server/descriptions.yaml

El archivo se ve así:

# Edit tool descriptions below. Run `mcp-anything generate --description` to apply.
tools:
  list_users:
    description: "List all users with optional filtering"
    parameters:
      role:
        description: "Filter by user role"
      limit:
        description: "Max results to return"
  create_user:
    description: "Create a new user account"
    parameters:
      name:
        description: "Full name of the user"

# 3. Apply overrides — run from the generated server directory
cd mcp-my-app-server
mcp-anything generate --description

# Or from anywhere, pointing to the output directory
mcp-anything generate --description -o ./mcp-my-app-server

Solo se aplican las descripciones modificadas. La tubería detecta las ediciones y vuelve a generar solo las fases afectadas (implementar, documentar, empaquetar), manteniendo todo lo demás intacto.

Salida

mcp-<name>-server/
├── src/<name>/
│   ├── server.py        # FastMCP server (stdio or HTTP/SSE)
│   ├── backend.py       # Backend adapter (CLI / HTTP proxy / Python call)
│   ├── tools/           # Tool modules, one file per capability group
│   ├── prompts.py       # Server-delivered MCP prompts
│   └── resources.py     # Dynamic MCP resources
├── AGENTS.md            # Tool index for coding agents
├── Dockerfile           # Container deployment (HTTP mode)
├── mcp.json             # Ready-to-paste MCP client config
└── pyproject.toml       # pip install -e .

Por qué generamos AGENTS.md

MCP resuelve la invocación de herramientas: un agente llama a una herramienta y obtiene un resultado. No resuelve el descubrimiento de herramientas a nivel de proyecto.

Cuando un agente como Claude Code abre tu repositorio, lee AGENTS.md antes de realizar cualquier llamada MCP. Ese archivo le indica qué puede hacer el servidor, qué herramientas existen y cómo usarlas, sin necesidad de una conexión activa. Como argumenta este artículo, la próxima generación de flujos de trabajo de agentes depende de que los agentes puedan razonar sobre las capacidades disponibles antes de invocarlas. AGENTS.md es ese puente: un mapa legible por humanos e indexado por agentes de todo lo que expone el servidor generado.

Por qué preferir el transporte HTTP

stdio MCP ejecuta el servidor como un subproceso local: un proceso por sesión de agente, vinculado a tu máquina. Funciona para uso personal pero no escala.

El transporte HTTP (--transport http) te permite:

• Desplegar una vez, conectar desde cualquier lugar (CI, agentes en la nube, compañeros de equipo)

• Compartir una única instancia de servidor entre múltiples sesiones de agente

• Ejecutar en Docker o cualquier plataforma de contenedores

Para cualquier cosa más allá de la creación de prototipos locales, HTTP es el valor predeterminado correcto.

Ejemplo concreto: Servidor MCP de GitHub

El servidor MCP oficial de GitHub es un proyecto en Go construido a mano que expone unas 80 herramientas seleccionadas (issues, PRs, repos, acciones, alertas de seguridad, etc.). A un equipo le llevó meses construirlo y mantenerlo.

¿Qué sucede si apuntas mcp-anything a la especificación OpenAPI pública de GitHub en su lugar?

mcp-anything generate https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json --name github --no-llm

El servidor generado cubre cada endpoint de la API REST de GitHub: repos, issues, PRs, acciones, paquetes, avisos de seguridad, búsqueda de código, gists, orgs, equipos, notificaciones y más. Cada endpoint se convierte en una herramienta MCP con parámetros tipados extraídos de la especificación OpenAPI.

El servidor oficial está curado: 80 herramientas elegidas para lo que realmente necesitan los LLMs, con lógica personalizada e integración con GraphQL. El servidor autogenerado es integral: 1.093 herramientas que cubren toda la superficie de la API. Es la diferencia entre un traje a medida y un guardarropa instantáneo: uno encaja perfectamente, el otro cubre todo de inmediato.

Consulta examples/github-server/ para ver el código generado completo.

Reducir el alcance para igualar al servidor oficial

Pero, ¿qué pasa si solo quieres las mismas ~80 herramientas que expone el servidor oficial? Usa --scope-file:

mcp-anything generate \
  https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --name github-scoped --no-llm \
  --scope-file examples/github-server-scoped/scope.yaml \
  -o examples/github-server-scoped

El archivo de alcance (examples/github-server-scoped/scope.yaml) utiliza exclude_patterns: ["*"] para excluir todo por defecto, y luego enabled: true en las 67 herramientas específicas que se asignan a los endpoints oficiales. 11 herramientas oficiales utilizan GraphQL o APIs específicas de Copilot y no tienen equivalente REST; estas están documentadas en el archivo de alcance.

Reprodúcelo tú mismo:

# 1. Generate the full server (1,093 tools)
mcp-anything generate \
  https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --name github --no-llm

# 2. Generate the scoped server (67 tools, matching official)
mcp-anything generate \
  https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --name github-scoped --no-llm \
  --scope-file examples/github-server-scoped/scope.yaml

# 3. Or use review mode to curate interactively
mcp-anything generate \
  https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --name github-custom --no-llm --review
# Edit mcp-github-custom-server/scope.yaml, then:
mcp-anything generate \
  https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --name github-custom --resume

Consulta examples/github-server-scoped/ para ver la salida con alcance.

Hoja de ruta

Consulta ROADMAP.md para ver la hoja de ruta completa. Consulta CONTRIBUTING.md para saber cómo contribuir al proyecto.

Historial de estrellas

Deja de escribir servidores MCP a mano.