MCP-Anything

Ein Befehl, um jede Codebasis in einen MCP-Server zu verwandeln. Nicht nur REST-APIs. Nicht nur OpenAPI-Spezifikationen.

Erste Schritte

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

Sie erhalten einen vollständigen, per pip installierbaren MCP-Server in ./mcp-<name>-server/. Fügen Sie ihn in Sekundenschnelle zu Ihrem Agenten hinzu:

stdio (lokal, Standard): Fügen Sie mcp.json zu Ihrer Claude Code .mcp.json hinzu:

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

HTTP (remote/shared, empfohlen): Starten Sie den Server und verweisen Sie Ihren Agenten darauf:

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" }
  }
}

Ziele

Standardmäßig generiert mcp-anything einen Python / FastMCP-Server. Verwenden Sie --target=mcp-use, um stattdessen einen TypeScript / mcp-use-Server zu generieren:

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

Der TypeScript-Server verwendet das mcp-use SDK und wird mit einem integrierten Inspektor geliefert.

Was wird unterstützt

mcp-anything erkennt und umschließt Quellcode in 8 Ökosystemen — REST-Frameworks, CLI-Tools, API-Spezifikationen und protokollbasierte Dienste.

Übergeben Sie eine URL direkt für API-Spezifikationen: mcp-anything generate https://api.example.com/openapi.json

Scoping: Steuern, was offengelegt wird

Große Codebasen können Hunderte oder Tausende von Endpunkten haben. Sie möchten nicht alle als MCP-Tools verfügbar machen. Drei Mechanismen ermöglichen es Ihnen, den Umfang zu steuern:

Schnellfilter mit --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_*"

Überprüfungsmodus — kuratieren vor dem Generieren:

# 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

Wiederverwendbare Scope-Datei:

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

Muster werden anhand von Funktionsnamen, Quellcodedateipfaden und Beschreibungen unter Verwendung der Glob-Syntax abgeglichen. In der Scope-Datei können Sie für eine präzise Steuerung auch enabled: false für einzelne Funktionen festlegen.

Beschreibungs-Overrides: Tool-Beschreibungen anpassen

Automatisch generierte Beschreibungen stammen aus dem Quellcode (Docstrings, OpenAPI-Zusammenfassungen, Routenkommentare). Sie sind meist gut genug, aber manchmal möchten Sie eine klarere Formulierung für Ihren LLM-Agenten.

Nach der Generierung wird eine descriptions.yaml-Datei im Ausgabeverzeichnis mit jeder Tool- und Parameterbeschreibung erstellt. Bearbeiten Sie diese und führen Sie den Befehl erneut mit --description aus, um Ihre Änderungen anzuwenden:

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

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

Die Datei sieht so aus:

# 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

Nur geänderte Beschreibungen werden angewendet. Die Pipeline erkennt Änderungen und generiert nur die betroffenen Phasen (Implementierung, Dokumentation, Paketierung) neu, während alles andere intakt bleibt.

Ausgabe

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 .

Warum wir AGENTS.md generieren

MCP löst den Tool-Aufruf (invocation) — ein Agent ruft ein Tool auf und erhält ein Ergebnis. Es löst nicht die Tool-Entdeckung (discovery) auf Projektebene.

Wenn ein Agent wie Claude Code Ihr Repository öffnet, liest er AGENTS.md, bevor er MCP-Aufrufe tätigt. Diese Datei teilt ihm mit, was der Server tun kann, welche Tools existieren und wie man sie verwendet — ohne eine aktive Verbindung zu benötigen. Wie dieser Artikel argumentiert, hängt die nächste Generation von Agenten-Workflows davon ab, dass Agenten über verfügbare Fähigkeiten nachdenken können, bevor sie diese aufrufen. AGENTS.md ist diese Brücke: eine für Menschen lesbare, vom Agenten indizierte Karte von allem, was der generierte Server offenlegt.

Warum HTTP-Transport bevorzugt wird

stdio MCP führt den Server als lokalen Subprozess aus — ein Prozess pro Agentensitzung, gebunden an Ihren Computer. Es funktioniert für den persönlichen Gebrauch, ist aber nicht skalierbar.

HTTP-Transport (--transport http) ermöglicht Ihnen:

• Einmal bereitstellen, von überall verbinden (CI, Cloud-Agenten, Teamkollegen)

• Eine einzelne Serverinstanz über mehrere Agentensitzungen hinweg teilen

• In Docker oder einer beliebigen Container-Plattform ausführen

Für alles, was über lokales Prototyping hinausgeht, ist HTTP die richtige Standardeinstellung.

Konkretes Beispiel: GitHub MCP Server

Der offizielle GitHub MCP-Server ist ein von Hand gebautes Go-Projekt, das etwa 80 kuratierte Tools (Issues, PRs, Repos, Actions, Sicherheitswarnungen usw.) offenlegt. Ein Team brauchte Monate, um ihn zu bauen und zu warten.

Was passiert, wenn Sie mcp-anything stattdessen auf die öffentliche OpenAPI-Spezifikation von GitHub richten?

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

Der generierte Server deckt jeden GitHub REST-API-Endpunkt ab — Repos, Issues, PRs, Actions, Pakete, Sicherheitshinweise, Codesuche, Gists, Orgs, Teams, Benachrichtigungen und mehr. Jeder Endpunkt wird zu einem MCP-Tool mit typisierten Parametern, die aus der OpenAPI-Spezifikation extrahiert wurden.

Der offizielle Server ist kuriert: 80 Tools, die für das ausgewählt wurden, was LLMs tatsächlich benötigen, mit benutzerdefinierter Logik und GraphQL-Integration. Der automatisch generierte Server ist umfassend: 1.093 Tools, die die gesamte API-Oberfläche abdecken. Es ist der Unterschied zwischen einem maßgeschneiderten Anzug und einer sofortigen Garderobe — der eine passt perfekt, der andere deckt sofort alles ab.

Siehe examples/github-server/ für den vollständigen generierten Code.

Scoping auf den offiziellen Server reduzieren

Aber was, wenn Sie nur die gleichen ~80 Tools möchten, die der offizielle Server offenlegt? Verwenden Sie --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

Die Scope-Datei (examples/github-server-scoped/scope.yaml) verwendet exclude_patterns: ["*"], um standardmäßig alles auszuschließen, und dann enabled: true für die 67 spezifischen Tools, die offiziellen Endpunkten zugeordnet sind. 11 offizielle Tools verwenden GraphQL oder Copilot-spezifische APIs und haben kein REST-Äquivalent — diese sind in der Scope-Datei dokumentiert.

Reproduzieren Sie es selbst:

# 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

Siehe examples/github-server-scoped/ für die gescopte Ausgabe.

Roadmap

Siehe ROADMAP.md für die vollständige Roadmap. Siehe CONTRIBUTING.md, um zu erfahren, wie Sie zum Projekt beitragen können.

Star History

Hören Sie auf, MCP-Server von Hand zu schreiben.