Skip to main content
Glama
deenesjakoruzh
breezykalama

MCPGen

by breezykalama
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

MCPGen

Generieren Sie sichere, richtlinienkonforme MCP-Server aus OpenAPI-Spezifikationen.

MCPGen ist ein produktionsorientiertes MVP-Python-Framework, das OpenAPI-Spezifikationen in standardmäßig sichere Tool-Server umwandelt. Es kann einen FastAPI-Demo-Server oder einen MCP-artigen stdio-Server generieren, während Schreibvorgänge blockiert bleiben, sofern sie nicht durch zukünftige Richtlinien explizit aktiviert werden.

Problem

KI-Anwendungen benötigen häufig Zugriff auf viele APIs, Datenbanken und interne Systeme. Ohne ein Framework neigen Teams dazu, dieselben Integrationen wiederholt zu erstellen, dem Modell zu viele Tools bereitzustellen und Sicherheitskontrollen wie Risikoklassifizierung, Audit-Logs und Schutzmaßnahmen für Schreibvorgänge zu überspringen.

MCP-Server stellen KI-Systemen Tools zur Verfügung, aber schnelle Prototypen können versehentlich gefährliche Operationen wie DELETE, POST, PATCH oder PUT ohne Überprüfung offenlegen.

Lösung

MCPGen liest eine OpenAPI-YAML- oder JSON-Datei und generiert:

  • strukturierte Tool-Deskriptoren

  • Listen sicherer, bereitgestellter Tools

  • Berichte über zurückgehaltene Tools

  • Eingabeschemata

  • einen richtlinienkonformen FastAPI- oder MCP-Server

  • Trockenlauf-Vorschauen

  • sichere GET-Ausführung

  • JSONL-Audit-Logs

  • semantisches Tool-Routing mit Keyword-Fallback

Das Standardverhalten ist bewusst konservativ: Nur risikoarme GET-Tools werden bereitgestellt.

Funktionen

  • OpenAPI YAML/JSON-Parsing

  • Tool-Generierung aus Endpunkten

  • Risikoklassifizierung:

    • GET = niedrig

    • POST, PUT, PATCH = mittel

    • DELETE = hoch

  • Standardmäßig sichere Filterung

  • Eingabeschema-Generierung aus Pfad-/Abfrageparametern und JSON-Anfrage-Bodys

  • Semantisches Tool-Routing mit Keyword-Fallback

  • FastAPI-Modus

  • MCP-stdio-Modus mit tools/list und tools/call

  • Trockenlauf-Anfrage-Vorschauen

  • Sichere echte Ausführung nur für risikoarme GET-Tools

  • Zentrale Richtlinien-Engine

  • JSONL-Audit-Logging

  • CLI-Befehle: generate, inspect

  • Konfiguration über mcpgen.yaml

Architektur-Ablauf

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

Schnellstart

Lokal installieren:

pip install -e .[dev]

Eine Spezifikation untersuchen:

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

Einen FastAPI-Server generieren:

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

Ausführen:

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

Öffnen:

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

Beispiel OpenAPI-Eingabe

Demo-Spezifikation:

examples/jsonplaceholder.openapi.yaml

Sie enthält:

  • GET /users

  • GET /users/{id}

  • GET /posts

  • GET /posts/{id}

  • POST /posts

  • DELETE /posts/{id}

Auszug:

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

Beispiel für ein generiertes Tool

Generiertes sicheres Tool:

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

Zurückgehaltene Tools wie create_post und delete_post verbleiben in tools.all.json und werden in safety_report.json erläutert.

FastAPI-Demo-Befehle

Vom Projektstammverzeichnis aus:

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

Liste der bereitgestellten sicheren Tools:

curl http://127.0.0.1:8001/tools

Tools nach Abfrage routen:

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

PowerShell-Äquivalent:

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

Trockenlauf eines sicheren Tools:

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

Ausführung eines sicheren GET-Tools:

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

PowerShell-Äquivalent:

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

Blockiertes POST-Verhalten anzeigen:

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

Blockiertes DELETE-Verhalten anzeigen:

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

Audit-Log anzeigen:

cat logs/audit.log

PowerShell-Äquivalent:

Get-Content logs\audit.log

MCP-Modus

Einen MCP-artigen stdio-Server generieren:

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

Ausführen:

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

Beispiel tools/list JSON-RPC-Eingabe:

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

Beispiel tools/call Trockenlauf-Eingabe:

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

Der MCP-Modus verwendet dieselben tools.json, Richtlinien-Engine und Audit-Logging wie der FastAPI-Modus. Im aktuellen MVP ist tools/call standardmäßig ein Trockenlauf. Mit execution_mode: safe-execute können nur risikoarme GET-Tools ausgeführt werden.

Semantisches Tool-Routing

MCPGen schreibt während der Generierung tools.embeddings.json und verwendet es, wenn:

routing_mode: semantic

Wenn Embeddings nicht verfügbar sind oder das semantische Ranking fehlschlägt, greift MCPGen automatisch auf Keyword-Routing zurück. Sie können das Keyword-Routing erzwingen mit:

routing_mode: keyword

Der Tool-Text kombiniert den Tool-Namen, die Beschreibung und optionale Tags. Beispiel:

create_invoice create invoice for customer billing payments

Standardmäßig verwendet MCPGen ein deterministisches lokales Embedding-Fallback, damit Demos und Tests ohne Modell-Downloads funktionieren. Um sentence-transformers zu verwenden, setzen Sie:

export MCPGEN_EMBEDDING_BACKEND=sentence-transformers

PowerShell:

$env:MCPGEN_EMBEDDING_BACKEND = "sentence-transformers"

Vergleichen Sie Routing-Modi, indem Sie routing_mode in mcpgen.yaml ändern und den Server neu generieren. Der semantische Modus rankt nach Vektorähnlichkeit; der Keyword-Modus rankt nach normalisierter Token-Überschneidung und enthält übereinstimmende Begriffe.

Sicherheitsmodell

MCPGen ist standardmäßig sicher:

  • Nur risikoarme GET-Tools werden in tools.json bereitgestellt.

  • Tools mit mittlerem Risiko für Schreibvorgänge werden zurückgehalten, sofern sie nicht durch zukünftige Konfiguration explizit aktiviert werden.

  • Hochriskante DELETE-Tools werden immer blockiert.

  • Die echte Ausführung ist auf risikoarme GET-Tools beschränkt.

  • Schreibausführung ist nicht implementiert.

  • Authentifizierung ist nicht implementiert.

Richtlinienentscheidungen geben zurück:

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

Audit-Logging

Audit-Logs sind JSONL-Datensätze, die geschrieben werden nach:

logs/audit.log

Konfiguration:

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

Jedes Ereignis enthält:

  • Zeitstempel

  • Tool-Name

  • Methode

  • Pfad

  • Risikostufe

  • Modus

  • Status

  • Erlaubt

  • Grund

  • Quelle

  • Aktion

Aktionen umfassen:

  • policy_evaluation

  • dry_run

  • execution_started

  • execution_success

  • execution_error

  • execution_blocked

Konfiguration

Standardkonfiguration:

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

Für die JSONPlaceholder-Demo setzen Sie:

api_base_url: https://jsonplaceholder.typicode.com

Aktuelle Einschränkungen

  • Dies ist ein produktionsorientiertes MVP, kein produktionsreifes Framework.

  • Keine Authentifizierung oder Geheimnisverwaltung über die Vorbereitung von Umgebungsvariablen hinaus.

  • Keine Schreibausführung.

  • Keine Benutzeroberfläche für Bestätigungs-Workflows.

  • Keine Vektordatenbank oder Optimierung des Embedding-Caches.

  • Kein Rate Limiting.

  • Kein datenbankgestützter Audit-Sink.

  • Der MCP-Modus verwendet ein minimales stdio-Gerüst, falls das offizielle Python-MCP-SDK nicht verfügbar ist.

Roadmap

  • Offizielle MCP-SDK-Integration

  • Authentifizierungs- und Geheimnisverwaltung

  • Bestätigungs-Workflow für aktivierte Tools mit mittlerem Risiko

  • Rate Limiting

  • Anfrage-/Antwort-Validierung

  • Bessere Unterstützung für OpenAPI-Schemata

  • Anschließbare Audit-Sinks

  • Bessere semantische Routing-Modelle und Optimierung des Embedding-Caches

  • Bereitstellungsvorlagen

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