JitAPI

Richte Claude auf eine beliebige API aus. JitAPI findet automatisch heraus, welche Endpunkte in welcher Reihenfolge aufgerufen werden müssen.

JitAPI ist ein MCP-Server, der es Claude ermöglicht, mit jeder API über deren OpenAPI-Spezifikation zu interagieren. Anstatt Hunderte von Endpunkten in den Kontext zu laden, verwendet JitAPI semantische Suche und einen Abhängigkeitsgraphen, um nur das anzuzeigen, was benötigt wird – dann plant und führt Claude die Aufrufe aus.

https://github.com/user-attachments/assets/53f72f89-a41a-4a9c-a688-ec876ea05fbd

Das Problem

Stripe hat über 300 Endpunkte. GitHub hat über 800. Das Laden der vollständigen Spezifikation in Claudes Kontext verschwendet Token und führt zu Halluzinationen. Das Schreiben eines benutzerdefinierten MCP-Servers für jede verwendete API ist nicht skalierbar.

JitAPI löst dies: Registriere eine beliebige OpenAPI-Spezifikation einmal und frage dann in natürlicher Sprache nach dem, was du benötigst. Es findet die richtigen Endpunkte, löst Abhängigkeiten zwischen ihnen auf und lässt Claude die Aufrufe ausführen.

Schnellstart

pip install jitapi

Füge dies zu deiner Claude Code-Konfiguration (.mcp.json) hinzu:

{
  "mcpServers": {
    "jitapi": {
      "command": "uvx",
      "args": ["jitapi"]
    }
  }
}

Das war's. Keine API-Schlüssel erforderlich – JitAPI verwendet standardmäßig lokale Embeddings.

Dann in Claude:

You: Register the GitHub API from https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json

Claude: ✓ Registered GitHub v3 REST API — 1,107 endpoints indexed

You: List my repos

Claude: [searches for "list repositories for authenticated user" → finds GET /user/repos → executes]
Here are your repositories: ...

Multi-API-Orchestrierung

Das Killer-Feature: Registriere mehrere APIs und stelle Fragen, die sich über diese erstrecken. JitAPI durchsucht alle registrierten APIs und Claude verkettet die Aufrufe.

You: Register the TMDB API and OpenWeatherMap API
Claude: ✓ Registered both APIs

You: Find the top popular movie on TMDB, then get the weather where it was filmed

Claude: [searches TMDB → GET /movie/popular → GET /movie/{id} for production locations
         → searches OpenWeather → GET /data/2.5/weather with the city]

The #1 popular movie is "Inception", filmed in Los Angeles.
Current weather in LA: 72°F, partly cloudy.

Funktionsweise

Register API                          Ask a question
     │                                      │
     ▼                                      ▼
Parse OpenAPI spec               Embed query → vector search
     │                                      │
     ▼                                      ▼
Build dependency graph           Find relevant endpoints
     │                                      │
     ▼                                      ▼
Embed all endpoints              Expand with dependencies
     │                                      │
     ▼                                      ▼
Store in vector DB               Return schemas → Claude executes

1. Registrieren — Analysiere eine OpenAPI-Spezifikation, erstelle einen Abhängigkeitsgraphen (welche Endpunkte benötigen Daten von welchen anderen Endpunkten) und erstelle durchsuchbare Embeddings für alle Endpunkte

2. Suchen — Wenn du eine Frage stellst, bettet JitAPI deine Abfrage ein und findet die relevantesten Endpunkte über Kosinus-Ähnlichkeit

3. Erweitern — Der Abhängigkeitsgraph fügt alle erforderlichen Endpunkte hinzu (z. B. "du musst zuerst GET /users aufrufen, um die user_id für POST /orders zu erhalten")

4. Ausführen — Claude erhält die Endpunkt-Schemata und führt die API-Aufrufe aus, wobei Daten zwischen den Schritten weitergegeben werden

MCP-Tools

Einrichtung

Claude Code

Erstelle .mcp.json in deinem Projektverzeichnis (oder ~/.claude.json für globalen Zugriff):

{
  "mcpServers": {
    "jitapi": {
      "command": "uvx",
      "args": ["jitapi"]
    }
  }
}

Claude Desktop

Füge dies zu deiner Claude Desktop-Konfiguration hinzu:

{
  "mcpServers": {
    "jitapi": {
      "command": "uvx",
      "args": ["jitapi"]
    }
  }
}

Embedding-Anbieter

JitAPI funktioniert sofort mit lokalen Embeddings (fastembed) – keine API-Schlüssel erforderlich. Für eine bessere Suchqualität bei großen APIs kannst du einen Cloud-Embedding-Anbieter hinzufügen:

Setze den API-Schlüssel im env-Block deiner MCP-Konfiguration:

{
  "mcpServers": {
    "jitapi": {
      "command": "uvx",
      "args": ["jitapi"],
      "env": {
        "VOYAGE_API_KEY": "your-key-here"
      }
    }
  }
}

Der Anbieter wird automatisch aus den verfügbaren Umgebungsvariablen erkannt. Priorität: Voyage AI > OpenAI > Cohere > lokal.

Authentifizierung

Konfiguriere die API-Authentifizierung nach der Registrierung. Der empfohlene Ansatz verwendet Umgebungsvariablen, damit Geheimnisse niemals auf die Festplatte geschrieben werden:

{
  "mcpServers": {
    "jitapi": {
      "command": "uvx",
      "args": ["jitapi"],
      "env": {
        "GITHUB_TOKEN": "ghp_...",
        "OPENWEATHER_API_KEY": "your-key-here"
      }
    }
  }
}

Dann weise Claude an, die Umgebungsvariable zu verwenden:

You: Set bearer auth for GitHub using env var GITHUB_TOKEN
Claude: [calls set_api_auth with auth_type="bearer", env_var="GITHUB_TOKEN"]
✓ Auth configured for github (from env var $GITHUB_TOKEN)

Mit env_var liest JitAPI das Geheimnis zum Zeitpunkt der Anfrage aus der Umgebung – nur der Name der Umgebungsvariable wird gespeichert, niemals die Anmeldeinformation selbst.

Du kannst Anmeldeinformationen auch direkt übergeben (sie werden in ~/.jitapi/auth.json mit 0600-Berechtigungen gespeichert):

You: Set API key auth for OpenWeather with param name "appid"
Claude: [calls set_api_auth with auth_type="api_key_query", credential="...", param_name="appid"]
✓ Auth configured for openweather

Unterstützte Auth-Typen: bearer, api_key_header, api_key_query, basic.

Sicherheitshinweis: Bei Verwendung von env_var werden Anmeldeinformationen zur Laufzeit aufgelöst und berühren niemals das Dateisystem. Wenn credential direkt übergeben wird, werden Geheimnisse als Klartext-JSON unter ~/.jitapi/auth.json gespeichert (Dateiberechtigungen 0600, Verzeichnis 0700). Für den Produktionseinsatz ist der env_var-Ansatz zu bevorzugen.

Umgebungsvariablen

Entwicklung

git clone https://github.com/nk3750/jitapi.git
cd jitapi
pip install -e ".[dev]"
pytest
ruff check src/

Lizenz

MIT