# GateLLM — selbst gehostetes Enterprise-LLM-Gateway

> Etwa ein Siebtel der Kosten bei gleicher Arbeitslast. Ein vertrauenswürdiges, compliance-konformes, selbst gehostetes LLM-Gateway (KI-Gateway), das Topmodelle mit offenen SOTA-Modellen orchestriert — Planung auf Frontier-Modellen, Ausführung auf Open-SOTA.

Kanonisch: https://www.gatellm.io/de/

## Frontier-Modelle planen. Open-SOTA-Modelle führen aus. Etwa ein Siebtel der Kosten.
Topmodelle übernehmen die Planung, Open-SOTA-Modelle erledigen die Routinearbeit (die übrigen 90 %). Composition senkt die Rechnung auf ~1/7 — die Zahlen werden im Rechner live berechnet, nicht hier behauptet.
```
from openai import OpenAI

# One line change: point your SDK at your own gateway
client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gateway-api-key",
)

# Existing code unchanged — the gateway routes each request
# to the right model tier (planning vs execution) per your console policy
resp = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Plan the architecture"}],
)
```
Modelle mischen: Claude Opus plant, DeepSeek / Qwen führen aus — ~1/7 der Kosten, bis zu 90 % günstiger

Das Gateway entscheidet, welches Modell wirklich läuft: Was im Client auch konfiguriert ist, das Zielmodell ist das von Admins festgelegte — Ingress-Allowlist + Wildcard-Mapping „*“

Ein Protokoll genügt: Sprich OpenAI oder Anthropic und erreiche Modelle hinter allen vier Chat-Protokollfamilien (OpenAI / Anthropic / Gemini / DashScope) — ein Modellwechsel berührt den Code nicht

Daten bleiben vor Ort: vollständig selbst gehostet, Prompts erreichen uns nie; Zugangsdaten und PII werden auf dem Anfragepfad erkannt — protokollieren / maskieren / blockieren je Bereich

## Drei Dinge, die das Gateway kann und ein einzelnes Modell nicht
Modelle mischen, um Kosten zu senken, durchsetzen, welches Modell tatsächlich läuft, und Client-Code auf einem Protokoll halten.
### Modelle mischen statt überall das teuerste laufen zu lassen
Frontier-Modelle (Claude Opus) planen und denken, offene SOTA-Modelle (DeepSeek / Qwen / GLM) übernehmen die Routineausführung. Im Standard-Mix liegt die Rechnung bei ~1/7, bei ~97 % erhaltener Leistungsfähigkeit für Routineaufgaben — live im Rechner berechnet, hier nicht behauptet.
- Plan-Modus pro Anfrage erkannt — keine Client-Änderung
- Stufen nach Key-Gruppe oder Identität zugewiesen
- Kostenzuordnung und Budgetobergrenzen pro Modus
### Das Gateway entscheidet, welches Modell tatsächlich läuft
Welches Modell ein Entwickler auch konfiguriert, die Anfrage wird bei Ankunft normalisiert. Namen außerhalb der Allowlist erhalten 403; ein Wildcard-Mapping „*“ schreibt alles übrige auf das freigegebene Modell um. Mappings und Regeln werden hot-reloaded — kein Rollout pro Entwickler.
- Key-Gruppen-Allowlist sperrt Modellnamen am Ingress
- Wildcard-Mapping legt das Zielmodell fest
- Jede Anfrage protokolliert das tatsächliche Zielmodell (SW-Tag für Skript-Wechsel, MM für Identitäts-Mappings)
### Client einmal schreiben, Backend frei tauschen
Ihre App spricht ein Protokoll — OpenAI oder Anthropic. Das Gateway übersetzt zwischen den vier Chat-Protokollfamilien (OpenAI / Anthropic / Gemini / DashScope) und normalisiert Streaming, Tool-Aufrufe und andere Fähigkeitsunterschiede, sodass ein neuer Anbieter oder ein neues Modell den Geschäftscode nie berührt.
- Any-to-any zwischen den vier Chat-Protokollfamilien
- Nur-Anthropic-Clients (Claude Code, claude-code-action) können Modelle anderer Anbieter ausführen
- 15 weitere Upstream-Protokollformen über die vier Familien hinaus, dokumentiert in der Interop-Matrix

Integriert mit über 100 LLM-Anbietern · 30+ SDKs und Frameworks

## Überzeugen Sie sich selbst
Wir veröffentlichen die Dokumente, statt Sie zu bitten, uns einfach zu glauben. Jede Aussage auf dieser Seite hat einen nachlesbaren Beleg, bevor Sie mit uns sprechen.

### [Sicherheit und Compliance](https://www.gatellm.io/de/security.md)
Architektur, Schlüsselverwaltung und Isolationsmodell.

### [Sicherheitsfragebogen](https://www.gatellm.io/trust.md)
CAIQ-/SIG-/VSA-Antworten, ausgefüllt.

### [Liste der Unterauftragsverarbeiter](https://www.gatellm.io/subprocessors.md)
Jeder Dritte, der Ihre Daten berühren kann.

### [Incident Response und Support](https://www.gatellm.io/sla.md)
Reaktionsziele und Support-Zusagen.

## Eine Schnittstelle, alle Modelle frei kombinierbar
Von einfachem Modell-Routing bis zur Multi-Modell-Orchestrierung bietet GateLLM umfassende Funktionen für Unternehmen.
### Multi-Modell-Routing
Eine Schnittstelle für alle Modelle. Intelligentes Fallback, Lastverteilung, automatische Wiederholung.
- Einheitliche API für über 100 LLM-Anbieter
- Intelligentes Fallback-Routing
- Lastverteilung und Ratenbegrenzung
- Upstream-Key-Pooling: ein Aufrufer bleibt an einem Schlüssel, Failover auf den nächsten
- Ollama / vLLM / llama.cpp als openai-kompatible Upstreams, eine Governance-Ebene
### Composition
Gestaffeltes Routing nach Plan-Modus, Identität oder Anfrageform: Planung auf Topmodellen, Ausführung auf Open-SOTA. Das Gateway schreibt den Modellnamen um — Client-Code bleibt unverändert.
- Plan-Modus-Erkennung: Planung auf Topmodell, Ausführung auf Open-SOTA — ohne Client-Änderung
- Identitätsbezogene Modellzuordnung: gleicher Modellname → unterschiedliche Upstreams je Key-Gruppe
- switch-route-Regeln: Anfragen mit Bildern oder Sonderfällen an das richtige Modell leiten
- Downgrade im Agenten: Plan gesperrt / automatisches Downgrade außerhalb des Plan-Modus
### Multi-Modell-Code-Review
Führen Sie 2–3 Modelle parallel auf demselben PR aus. Das Gateway liefert Protokoll-Interoperabilität und einheitliche Abrechnung; Fan-out, Zusammenführung und Confidence-Bewertung liegen in der Open-Source-Orchestrierungs-Action.
- Gateway-Protokoll-Interop: Nicht-Anthropic-Modelle nehmen an Anthropic-only-Review-Warteschlangen teil
- Ein Zugriffsschlüssel misst und steuert den gesamten Fan-out
- Fan-out, [Consensus N/M]-Bewertung und Zusammenführung liegen in gatellm-io/gatellm-code-review (Orchestrierungsseite)
### MCP-Tool-Governance
Bündeln Sie externe MCP-Tool-Server hinter einem /mcp-Endpunkt: Tool-ACLs, Kontextbudgets und Aufruf-Auditierung. Welche Tools ein Agent nutzen darf, liegt in derselben Berechtigungsebene wie die Modelle, die er aufrufen darf.
- Mehrere MCP-Server hinter einem /mcp-Endpunkt
- Tool-Allow/Deny je Key-Gruppe plus Label-Filter
- Integrierte BM25-Suche, wenn die Tool-Liste wächst
- REST-Brücke: jede REST-API per vereinfachter Spezifikation als MCP-Tool einbinden, ohne Code
- MCP-Aufrufe / Verstöße / Sitzungen vollständig auditiert
### Websuche-Injektion
Geben Sie jedem Modell einheitlich Websuche: Das Gateway ruft Ergebnisse ab und injiziert sie, synthetisiert native Suchblöcke je Client-Protokoll — auch offene Modelle erhalten Suchgrundlage.
- Native Suchblöcke je Protokoll (Anthropic / OpenAI / Responses)
- Dreifach-Umschalter pro Modell, sanfte Degradation bei Fehlern
- Abgefangene Suche von der nutzungsbasierten Abrechnung ausgenommen
### Kostenkontrolle
Budgetverwaltung, Ratenbegrenzung, Kostenzuordnung pro Team, modusbewusste Modellrichtlinie. Keine Aufschläge auf Token-Gebühren, BYOK mit Ihren eigenen Schlüsseln.
- Kostenzuordnung nach Projekt/Funktion
- Sanfte Budgetwarnungen
- BYOK: Anbieter zu Standardtarifen bezahlen
- Modusbewusste Modellrichtlinie (Plan/Ausführung, durchsetzbar)
### Governance und Integrationen
Von der Client-Zugriffskontrolle bis zur CI/CD-Integration — erweitern Sie die Gateway-Funktionen in Ihre Entwicklungs- und Kollaborationsabläufe.
- Client-Zugriffskontrolle (User-Agent-Richtlinie)
- GitHub-Actions-Code-Review über Ihr eigenes Gateway
- Batch-Konfiguration: vorbereiten → vollständigen Konfliktsatz anzeigen → atomare Übernahme in einer Transaktion
### Office- / M365-Add-in
Nutzen Sie Ihr eigenes Modell-Gateway direkt in Excel, Word, PowerPoint und Outlook — selbst gehostetes Add-in, Daten verlassen das Netzwerk nie, keine Pivot-Abhängigkeit.
- Excel-Finanzmodellierung / Word-Vertragsprüfung / Outlook-Posteingang
- Entra-SSO + Purview-Label-Gating
- 33 gebündelte Domänen-Skills, kostenpflichtiges Add-on
### Transform-Skripte
Eine sandboxed JavaScript-Engine (QuickJS) schreibt Anfrage- und Antwort-JSON am Gateway um. Im Konsolen-Editor bearbeiten, wirkt sofort — kein Redeploy, kein Glue-Code.
- Slots vor / nach der Anfrage + ein Antwort-Slot: Client-Format vor der Übersetzung oder Upstream-Format nach der Übersetzung sehen
- context.useModel() wechselt die gesamte Route — base_url, Protokoll und Zugangsdaten gemeinsam
- Integrierte Bibliothek: json_path / str_* / regex_* / array_* / encoding + hash / UUID + Zeit
- Sandboxed (kein Netzwerk, kein Dateisystem) mit Fail-open-/Fail-closed-Modus und In-Konsolen-Skripttester

## Modelle frei kombinieren: Qualität, die kein einzelnes Modell liefert
Composition ist ein natives Gateway-Muster; Multi-Modell-Code-Review ist ein Orchestrierungsmuster, das das Gateway ermöglicht — beide bauen auf der Capability-Normalisierung auf.
### Composition: gestaffeltes Routing über Modelle hinweg
Routen Sie nach Plan-Modus, Identität oder Anfrageform: Planung bleibt auf Topmodellen, Ausführung wechselt zu Open-SOTA. Das Gateway schreibt den Modellnamen um und übersetzt Protokolle — Client-Code bleibt unverändert.
- Plan-Modus-Erkennung: Planung an Topmodelle, Ausführung an Open-SOTA — ohne Client-Änderung
- Identitätsbezogene Modellzuordnung: gleicher Modellname → unterschiedliche Upstreams je Key-Gruppe / Header
- switch-route-Regeln: Anfragen mit Bildern oder Sonderfälle an das richtige Modell leiten
- Kein Glue-Code — Protokollübersetzung übernimmt das Gateway
- Durchsetzbare Richtlinie: Administratoren sperren Modellstufen je Plan-/Ausführungsmodus und unterbinden den Einsatz ausschließlich von Topmodellen
```
// before-slot transform script (JavaScript) — switch execution model by plan mode.
// Mounted on the entry model in the console; runs before routing.
function transform(body, context) {
    if (context.sourceProtocol !== "Anthropic") {
        return body;
    }
    const EXEC_MODEL = "qwen3.8-max"; // a model name configured in the gateway
    const PLAN = /plan mode is active/i;
    const EXIT = /exited plan mode/i;
    // take the last marker-bearing message: later marker wins
    const messages = body.messages || [];
    for (let i = messages.length - 1; i >= 0; i--) {
        const s = JSON.stringify(messages[i].content || "");
        const inPlan = PLAN.test(s);
        const exited = EXIT.test(s);
        if (inPlan || exited) {
            // not in plan mode → switch execution to the cost-efficient model
            if (exited || !inPlan) context.useModel(EXEC_MODEL);
            return body;
        }
    }
    context.useModel(EXEC_MODEL);
    return body;
}
```
### Multi-Modell-Code-Review (Orchestrierungsseite)
Das Gateway ermöglicht das Muster, die Orchestrierungsebene führt es aus: claude-code-action spricht nur das Anthropic-Protokoll, und die Protokoll-Interoperabilität des Gateways erlaubt Nicht-Anthropic-Modellen wie qwen3.8-max und kimi-k3, der Review-Warteschlange beizutreten. Ein einziger Gateway-Zugriffsschlüssel misst jeden Review-Modellaufruf einheitlich ein.
- [Consensus N/M]-Confidence-Annotationen, Zusammenführung und Deduplizierung erzeugt die Action
- Jedes Review-Modell wird separat abgerechnet und vom Gateway einheitlich aggregiert
- PR-Zeilen-Gate und Zusammenklappen historischer Kommentare sind in der Action enthalten

## Drei Schritte zum ersten Token.
Steigen Sie in drei Schritten von einem Einzelmodell auf Multi-Modell-Orchestrierung um, ohne Geschäftscode umzuschreiben. Jedes SDK (OpenAI / Anthropic / Gemini / DashScope) funktioniert.
### Gateway bereitstellen
Docker-Start mit einem Klick oder Kubernetes-Helm-Deployment in Ihre private Umgebung.
### Schlüssel konfigurieren
BYOK-Modus: Tragen Sie Ihre bestehenden Anbieter-API-Schlüssel ein; Daten bleiben On-Premises und werden nie persistiert.
### Endpunkt ersetzen
Richten Sie die base_url des OpenAI SDK auf GateLLM und rufen Sie alle Modelle über eine einheitliche Schnittstelle auf.
```
# Just one line change: point base_url to GateLLM
from openai import OpenAI

client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gatellm-api-key"
)

# Existing code unchanged, call any model
response = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Hello"}]
)
```
## Oder übergeben Sie es Ihrem Agenten

Installieren und konfigurieren Sie das GateLLM-Gateway. Rufen Sie zuerst die Roh-Markdown-Datei dieser Installationsanleitung per curl ab, lesen Sie sie vollständig und folgen Sie dann jedem Schritt der Reihe nach (die Schritte hängen voneinander ab — z. B. muss eine Key-Gruppe existieren, bevor ein Zugriffsschlüssel angelegt wird; überspringen Sie nichts):

curl -fsSL https://docs.gatellm.io/en/quickstart/docker-single-node.md

Der Agent braucht nur eines von Ihnen: den API-Schlüssel des Upstream-Anbieters. Den Rest erzeugt er selbst, konfiguriert alles über die Konsolen-API — ohne Browser — und ist fertig, wenn die erste Anfrage eine Completion zurückliefert.

## Oder führen Sie es selbst aus

```bash
docker run -d \
  --name gatellm \
  -p 7890:7890 \
  -e CONSOLE_PASSWORD=change-me-on-first-login \
  -e ENCRYPTION_KEY=REPLACE_WITH_YOUR_ENCRYPTION_KEY \
  -e CONSOLE_SECRET_KEY=REPLACE_WITH_YOUR_CONSOLE_SECRET_KEY \
  -e STORAGE_MODE=sqlite \
  -v gatellm-data:/var/lib/protoflux \
  ghcr.io/gatellm-io/gatellm:latest
```

Ersetzen Sie die drei Platzhalterwerte vor dem Ausführen — die Anleitung erklärt, was jeder ist und warum es unsicher ist, ihn unverändert zu lassen.

## Bringen Sie das SDK mit, das Sie schon haben. Eine Zeile ändern.
Dieselben vier Protokolle auf beiden Seiten. Von jedem zu jedem konvertieren ohne Glue-Code, über Chat, Bild, Sprache, Video, Echtzeit-Sprache, Embedding und Rerank.
### Jede Modalität
- Chat
- Bild
- Sprache
- Video
- Echtzeit-Sprache
- Embedding
- Rerank

- Nativer Eingang: OpenAI / Anthropic / Gemini / DashScope SDKs verbinden direkt, keine Änderung außer base_url
- Nativer Ausgang: Routen zu jedem Anbieter in dessen nativem Protokoll, nicht in einem einheitlichen OpenAI-Umschlag, der neu übersetzt wird
- Any-to-any-Konvertierung: Eingang A → Ausgang B nahtlos (z. B. Anthropic-SDK-Aufruf → an ein DashScope-natives Modell geroutet, in DashScope-Protokoll konvertiert)
- Alle Modalitäten + Embedding/Rerank: Chat / Bild / Sprache / Video / Echtzeit-Sprache sowie Embedding- und Rerank-Protokolle vereinheitlicht
- Stärker als „OpenAI-kompatibel“: synthorai und andere bieten drei Eingangsprotokolle, vereinheitlicht auf eine OpenAI-Oberfläche; GateLLM bietet vier Eingänge + vier Ausgänge, von jedem zu jedem
- Breitere Ausgangsprotokoll-Oberfläche: über die vier großen Protokollfamilien hinaus insgesamt 15 Upstream-Protokollformen (inkl. AWS Bedrock Converse / Invoke, Realtime, Passthrough) — Enterprise-Modelle auf Bedrock und selbst gehostete Modelle schließen an ein Gateway an
- Echtzeit-Sprachsitzungen (/v1/realtime, openai_realtime + dashscope_realtime) werden pro Turn in dieselbe Statistik-/Abrechnungs-/Log-Pipeline wie HTTP eingemessen

## Funktioniert mit dem SDK, das Sie bereits haben
Richten Sie jedes SDK oder Framework mit einer Zeile auf das Gateway. OpenAI, Anthropic, Gemini und DashScope verbinden nativ; LangChain, LlamaIndex, CrewAI, Vercel AI SDK und 30+ weitere über denselben base_url-Wechsel.
### base_url auf das Gateway richten
Standard ist https://your-gateway.gatellm.io — ob /v1 enthalten ist, hängt vom SDK ab (jedes Beispiel nennt den genauen Wert).
### Gateway-Zugriffsschlüssel einsetzen
Kein Upstream-sk-…-Schlüssel — derselbe Zugriffsschlüssel wird in den Header eingetragen, den Ihr SDK erwartet.
### Den Gateway-Modellnamen verwenden
Was Sie in der Konsole konfiguriert haben — nicht der offizielle Name des Anbieters.
```
# base_url convention differs by SDK — match the one you're using
from openai import OpenAI
OpenAI(base_url="https://your-gateway.gatellm.io/v1")        # OpenAI SDK: /v1

import anthropic
anthropic.Anthropic(base_url="https://your-gateway.gatellm.io")  # Anthropic SDK: root (appends /v1/messages)

# Vercel AI SDK createAnthropic: baseURL ".../v1" (appends /messages) — the reverse
# LangChain ChatOpenAI: base_url="https://your-gateway.gatellm.io/v1"
```
### `Authorization: Bearer <key>`
- SDK / Framework: OpenAI · DashScope · generisch
- Bearer-Präfix ist groß-/kleinschreibungsunabhängig

### `x-api-key: <key>`
- SDK / Framework: Anthropic SDK
- Authorization wird ebenfalls akzeptiert

### `x-goog-api-key: <key>`
- SDK / Framework: Gemini SDK
- Authorization wird ebenfalls akzeptiert

### Offizielle Anbieter-SDKs
OpenAI / Anthropic / Google SDKs verbinden nativ — nur base_url ändert sich

### DashScope nativ
Text, Bild, asynchrones Video, Embedding und Rerank über einen Endpunkt

### Vereinheitlichte SDKs und Gateways
Vercel AI SDK, LiteLLM, Portkey, Semantic Kernel, Spring AI

### Orchestrierungs-Frameworks
LangChain, LlamaIndex, CrewAI, AutoGen, DSPy, Haystack

### Agent-SDKs
OpenAI Agents, Claude Agent, Pydantic AI, ADK, Mastra

### Echtzeit und Audio
Echtzeit-WebSocket-Sprache + openai_audio ASR / TTS

### Lokal / selbst gehostet
Ollama, vLLM, llama.cpp als Upstreams — jedes Client-SDK bleibt erhalten

### Der Modellname muss zur Gateway-Konfiguration passen
Nicht der offizielle Name des Anbieters, nicht die Upstream-Modell-ID — sondern der Name, den Sie in der Konsole vergeben haben. Falscher Name → 404 model_not_found.

### Ob base_url /v1 enthält, hängt vom SDK ab
Das OpenAI SDK erwartet /v1; das Anthropic SDK erwartet die Wurzel (es hängt /v1/messages an); createAnthropic im Vercel AI SDK erwartet /v1 (es hängt /messages an). Ein Fehler hier fügt ein Pfadsegment hinzu oder entfernt es.

### Felder werden protokollübergreifend übersetzt und eingeschränkt
Aus max_tokens kann max_output_tokens mit einer Untergrenze werden (z. B. ≥16), wenn der Upstream ein Modell mit Responses-Protokoll ist — zu klein → 400.

### Thinking-Blöcke werden vom Gateway umschlossen
Thinking-Inhalte und Signaturen von Claude / Gemini werden durchgereicht oder entfernt — nehmen Sie das Element mit type == "text" aus dem Content-Array, gehen Sie nicht davon aus, dass content[0] Text ist.

### Das OpenAI Agents SDK verwendet standardmäßig /v1/responses
Es ruft die Responses API auf, nicht Chat Completions. Ist der Upstream openai (Chat), wechseln Sie explizit mit OpenAIChatCompletionsModel; ist er openai_response, funktioniert ein String-Modellname unverändert.

### LlamaIndex prüft den Modellnamen gegen eine Allowlist
Die OpenAI-Klasse akzeptiert nur bekannte Familien und lehnt benutzerdefinierte Gateway-Namen ab — verwenden Sie OpenAILike (Python) oder deklarieren Sie die Modellinformationen explizit.

### CrewAI wird intern von LiteLLM gesteuert
base_url ist kein Framework-Parameter, sondern die Umgebungsvariable OPENAI_API_BASE, und das Modell benötigt das Präfix openai/.

### AutoGen benötigt explizite model_info
Unbekannte Modellnamen führen in der Standardliste zu Fehlern — deklarieren Sie model_info explizit, um die Prüfung zu umgehen.

### Das Google GenAI SDK zeigt auf die Wurzel
base_url erfolgt über http_options.base_url (ohne /v1), und der Schlüssel wird im Header x-goog-api-key übergeben.

## Richten Sie jeden KI-Coding-Agenten auf das Gateway
```
# Every agent is one base_url + one access key away
export ANTHROPIC_BASE_URL="https://your-gateway.gatellm.io"   # Anthropic agents: root (no /v1)
export ANTHROPIC_API_KEY="<gateway access key>"

export OPENAI_API_BASE="https://your-gateway.gatellm.io/v1"   # OpenAI-compatible agents: /v1
export OPENAI_API_KEY="<gateway access key>"

# Codex CLI (~/.codex/config.toml) speaks the Responses protocol
# [model_providers.gatellm]
# base_url = "https://your-gateway.gatellm.io/v1"
# wire_api = "responses"
```
### Terminal-Agenten
Claude Code, Codex CLI, Gemini CLI, OpenClaw, opencode, Crush, Droid, Goose, Aider, Qwen Code, OpenHands, Kimi Code, Plandex, SWE-agent, Grok Build, Mistral Vibe, MiMo Code, ForgeCode, Codebuff

### IDEs und Erweiterungen
Cline, Roo Code, Kilo Code, Continue, Zed, Cursor, Windsurf, GitHub Copilot (BYOK)

### Verwaltete Plattformen
Warp (nur BYOK-Schlüssel), Amazon Q Developer CLI, Devin — Endpunkt fest oder nicht überschreibbar

### Der Harness pinnt seine eigene Modell-ID
Claude Code sendet seinen konfigurierten Standard (z. B. claude-opus-5 oder claude-sonnet-5) — nicht Ihren Gateway-Namen. Benennen Sie das Gateway-Modell entweder genau so, wie der Harness es anfragt, oder setzen Sie seine Modell-Umgebungsvariable (z. B. ANTHROPIC_MODEL) auf Ihren Gateway-Namen. Bei Abweichung → 404 model_not_found bei der ersten Nachricht.

### Anthropic-Protokoll-Harnesses erwarten die Wurzel, nicht /v1
Die Basis-URL für Anthropic-artige Clients zeigt auf die Gateway-Wurzel (ohne /v1) — der Client hängt /v1/messages selbst an. Mit /v1 verdoppelt sich hier das Pfadsegment.

### Benutzerdefinierte Codex-Provider benötigen wire_api="responses"
Die Codex CLI verlangt wire_api = "responses" für einen benutzerdefinierten [model_providers.*]-Block. Das Gateway implementiert /v1/responses nativ — richten Sie base_url darauf und setzen Sie env_key auf einen Gateway-Zugriffsschlüssel.

### LiteLLM-basierte Harnesses wollen ein openai/-Modellpräfix
Aider, OpenHands und SWE-agent nutzen LiteLLM: Setzen Sie OPENAI_API_BASE auf das Gateway und geben Sie dem Modell ein openai/-Präfix (z. B. openai/gateway-model-name), damit LiteLLM es als OpenAI-kompatiblen Endpunkt routet.

### Standard ist Abo-OAuth, nicht Ihr Schlüssel
Codex, Gemini CLI und Qwen Code verwenden standardmäßig den OAuth-/Abo-Login des Anbieters. Um über das Gateway zu routen, müssen Sie auf API-Schlüssel-Authentifizierung umstellen (Schlüssel + Basis-URL explizit setzen) — sonst umgeht der Agent das Gateway vollständig.

### IDEs leiten Tool-/Vision-Unterstützung aus der Modell-ID ab
Cline / Roo / Kilo und andere entscheiden anhand des Modellnamens über Tool-Calling und Vision. Ein benutzerdefinierter Gateway-Name kann Function Calling deaktivieren — wenn Tool-Aufrufe fehlschlagen, prüfen Sie die Capability-Erkennungsregeln des Clients oder benennen Sie das Modell passend zu einer bekannten Familie.

### Lange Inferenz fügt :keep-alive und _gateway_warning hinzu
Während langer Upstream-Inferenz gibt das Gateway SSE-Kommentarzeilen :keep-alive aus (harmlos — überspringen Sie Zeilen, die mit : beginnen), und bei einem Abbruch mitten im Stream fügt es ein Feld _gateway_warning ein, statt einen Fehler zu erzeugen, damit Harnesses wie Claude Code nicht die ganze Unterhaltung abbrechen.

### Claude Code Auto-Modus: entscheiden Sie, wer das Sicherheitsurteil abgibt
Im Auto-Modus wartet Claude Code vor einer potenziell gefährlichen Aktion auf ein serverseitiges Urteil (ein safeguards-Feld in der Anfrage). Ist der Upstream das offizielle Anthropic, entsteht das Urteil innerhalb derselben Anfrage und das Gateway reicht es unverändert durch. Ist der Upstream ein Drittanbieter, der das Feld ignoriert, antwortet stattdessen das Gateway — und der ausgelieferte Standard (allow_all) gibt jede Aktion frei, was permissiver ist, als den Aufruf gar nicht zu beeinflussen. Geben Sie eine Route an ihren Upstream zurück, indem Sie "anthropic_server_safeguards": "upstream" in die extra_config dieses Upstreams schreiben; die Konsoleneinstellung ist nur für Administratoren.

## Capability-Normalisierung: anbieterübergreifende Mischung erst möglich machen
Anbieterübergreifendes Modell-Mixing beruht auf der Capability-Normalisierungsschicht, die sieben Kopplungspunkte vereinheitlicht, sodass ein Modellwechsel nie das Umschreiben von Glue-Code bedeutet.
### Normalisierung von Tool-Aufrufen
OpenAI / Anthropic / Gemini / chinesische Modelle haben alle unterschiedliche Tool-Calling-Schemata. Wir vereinheitlichen sie im Fundament, schreiben Code einmal und rufen alle Modelle auf.
### Kompatibilität strukturierter Ausgaben
Jeder Anbieter nutzt andere Protokolle (striktes JSON-Schema, json_mode, tool_use). Wir vereinheitlichen zu einer konsistenten Schnittstelle.
### Vereinheitlichung des Prompt-Cachings
Anthropic cache_control, automatisches Caching von OpenAI, Gemini-Kontext — jeder hat andere Mechanismen. Wir bieten eine einheitliche Caching-Strategie.
### Anpassung von Reasoning-Token
Die Ausgabeformate von o1 / Claude Thinking / DeepSeek R1 unterscheiden sich. Wir passen uns dem Reasoning-Token-Protokoll jedes Anbieters an.
### Unterstützung multimodaler Formate
Vision-/Audio-/Datei-Upload-Protokolle unterscheiden sich je Anbieter. Wir vereinheitlichen multimodale Eingabeformate.
### Abstraktion des Abrechnungsmodells
Die Preisstruktur jedes Anbieters unterscheidet sich. Wir abstrahieren zu einer einheitlichen Kostenerfassungsschnittstelle.
### Normalisierung der Fehlersemantik
Fehlercodes und -inhalte jedes Anbieters unterscheiden sich. Wir normalisieren zu einem einheitlichen Fehlerinhalt, wobei z-request-id jede Anfrage durchgängig korreliert.
### Datenfluss: bleibt On-Premises, wird nie persistiert
Im BYOK-Modus werden API-Schlüssel nur im Speicher des Gateways gehalten, nie persistiert oder übertragen. Anfragen laufen über das Gateway direkt zu den offiziellen APIs der Anbieter; Daten verlassen Ihr privates Netzwerk nie.
Ausgerichtet an SOC-2-Kontrollen

Ausgerichtet an ISO-27001-Kontrollen

DSGVO

## Warum ~1/7 der Kosten?
Nehmen Sie ein Unternehmen mit 1 Mrd. Token pro Tag: gleiche Arbeitslast — vergleichen Sie die Rechnung für „durchgängig Topmodelle“ mit „Topmodelle planen, offene Modelle führen aus“.
## Drei Quellen der Ersparnis:
- BYOK ohne Token-Aufschlag — Sie zahlen Anbieter zu Standardtarifen, GateLLM nimmt keinen Zwischenanteil (Aggregatoren erheben typischerweise Plattform- und Zahlungsgebühren zusätzlich zum Listenpreis);
- Composition — offene SOTA-Modelle (GLM / Qwen / DeepSeek) tragen den Großteil der Ausführung (Klassifizierung, Extraktion, Übersetzung), Topmodelle (wie Claude Opus) nur für Planung und schwieriges Reasoning;
- Prompt-Caching — hochfrequente Aufrufe treffen den Cache, der Stückpreis sinkt um 50 %–90 %.
Die Zahlen sind illustrative Modelle auf Basis öffentlicher Preise; tatsächliche Ersparnisse hängen von Geschäftsszenario und Mix-Verhältnis ab. Die Pro-Lizenzgebühr von $400/Monat (2 GB, Einzelinstanz) ist im GateLLM-Tarif enthalten.

## Nutzung, die Sie sehen; Kosten, die Sie verrechnen; Budgets, die Sie halten
Token Ops verfolgt, wer was nutzt; Token FinOps macht aus Token abrechenbares, gedeckeltes Geld. Eine Steuerungsebene macht KI-Ausgaben so beherrschbar wie Cloud-Ausgaben.
### Transparenz von Nutzung und Kosten
Schlüsseln Sie jeden Aufruf nach Modell, Zugriffsschlüssel und Key-Gruppe auf, mit getrennt gemessenen Eingabe-/Ausgabe-/Cache-Treffer-Token in 1-Minuten-Auflösung.
- Gruppiert nach Modell / Schlüssel / Key-Gruppe
- Eingabe, Ausgabe und Cache-Treffer getrennt gemessen
- 24 h / 7 T / 30 T / benutzerdefinierte Zeitreihen
### Client-Zulassung und Audit-Trail
Nur freigegebene Clients erreichen das Gateway — erlauben, drosseln oder ablehnen per User-Agent. Jeder Aufruf hinterlässt einen prüfbaren Datensatz für Endpunkt-Governance und Compliance-Nachweise.
- Client-Zugriffskontrolle (User-Agent-Richtlinie)
- Aufrufdatensätze mit Log-Aufbewahrung (Pro und höher)
- Audit-/DLP-Integration (Enterprise)
### Management-API (programmatische Steuerung)
Verwalten Sie das Gateway per API: API-Schlüssel erstellen / widerrufen, Kontingente und Budgets setzen, Nutzung und Kosten abfragen, Audit-Logs exportieren — binden Sie es in Ihre internen Ops- und Abrechnungssysteme ein.
- Programmatisches Erstellen / Widerrufen von API-Schlüsseln
- Kontingente und Budgets per API
- API für Nutzungs- und Kostenabfragen
- Export von Audit-Logs
### Eigene Preisliste und Preis-Snapshots
Tragen Sie den ausgehandelten Privatpreis manuell ein, und er wird maßgeblich — Systemaktualisierungen überschreiben ihn nie. Jeder Preis hat ein Gültigkeitsfenster: Planen Sie Preissenkungen im Voraus, und Änderungen schreiben historische Kosten nie um.
- Gepinnter Privatpreis überdeckt den automatischen, wird nie überschrieben
- Snapshots wirken zeitfensterbasiert
- Historie nachtragen / Preissenkungen vorplanen
- Abrechnungsmodi Token · pro Aufruf · pro Sekunde
### Tag-basierte Zuordnung und Verrechnung
Versehen Sie Schlüssel und Key-Gruppen mit Tags und aggregieren Sie Nutzung und Kosten nach Tag, um Token-Ausgaben dem richtigen Kostenstellen zuzuordnen. Der Excel-Export teilt das Ledger nach Modell × Schlüssel für interne Showback- oder Chargeback-Zwecke.
- Freie Tags auf Schlüsseln / Key-Gruppen
- Nutzung und Kosten nach Tag aggregieren
- Excel-Export mit 6 Tabellenblättern (inkl. Schlüssel × Modell)
- Bereit für internes Showback / Chargeback
### Kostenkontingente und Limits
Setzen Sie Tages- und Monatsausgabenobergrenzen pro Schlüssel — unabhängig nach UTC-Kalendertag und -monat beurteilt, blockiert, sobald eine der beiden erreicht ist. Kontingente erben Schlüssel → Gruppe → global und nehmen den weitesten Wert über Gruppen hinweg.
- Tages-/Monatsgrenzen, unabhängig beurteilt
- Vererbung Schlüssel → Gruppe → global
- 429 quota_exceeded, Retry-After bei Tagesgrenze

## GateLLM vs. LiteLLM
Ein quellenbelegter Vergleich. GateLLM bringt einige Mechanismen mit, die LiteLLM nicht hat; beide teilen eine gesicherte Basis; einiges unterscheidet sich grundsätzlich. Entscheiden Sie anhand der beiden oberen Ebenen, nicht anhand von Marketingrauschen.
### Nur GateLLM kann das
Mechanismen, die LiteLLM nicht hat — die einzeilige Erklärung „wie es funktioniert“ steht unter jeder Funktion.
| Funktion | GateLLM | LiteLLM |
| --- | --- | --- |
| Bedingter Modellwechsel | ✓ | ✗ |
| Protokoll- und SDK-übergreifendes Mischen | ✓ | ✗ |
| Konfigurationsübernahme in einer Transaktion | ✓ | ✗ |
| Harte Kostenkontingent-Sperre | ✓ | ✗ |
| Absturzsichere Abrechnung | ✓ | ✗ |
| Upstream-Key-Pooling und feste Bindung | ✓ | ✗ |
| Drei Abrechnungsmodi + mehrere Währungen | ✓ | ✗ |
| Upstream-SSO-Anmeldung mit Zugangsdaten | ✓ | ✗ |
| Registry für Capability-Metadaten | ✓ | ✗ |
| LTS-Release-Zweig | ✓ | ✗ |

- **Bedingter Modellwechsel**: Deklarative switch-route-Regeln + integrierte Plan-Modus-Erkennung + context.useModel()-Skripte — ohne Client-Änderung. LiteLLM benötigt eigene Python-Callbacks.
- **Protokoll- und SDK-übergreifendes Mischen**: Native Any-to-any-Einstiegspunkte — GPT aus dem Anthropic SDK, DeepSeek aus dem Gemini SDK aufrufen. LiteLLM ist OpenAI-zentriert; Rückwege laufen über Shims.
- **Konfigurationsübernahme in einer Transaktion**: Vorbereiten → vollständigen Konfliktsatz anzeigen → atomare Übernahme; bei jedem Konflikt wird der gesamte Batch zurückgerollt.
- **Harte Kostenkontingent-Sperre**: Tages-/Monatszyklen liefern 429 quota_exceeded, sobald die Ausgaben die Grenze erreichen. LiteLLM sendet nur Budgetwarnungen.
- **Absturzsichere Abrechnung**: Vorabzug → Abrechnung → Rückerstattung mit einem In-Flight-Ledger — korrekt auch bei Prozessabstürzen.
- **Upstream-Key-Pooling und feste Bindung**: Gewichtetes FNV-1a-Hashing bindet jeden Aufrufer an einen Schlüssel, Failover auf den nächsten unversuchten Schlüssel; weight=0 als Standby.
- **Drei Abrechnungsmodi + mehrere Währungen**: Token / pro Aufruf / pro Dauer, USD/CNY/EUR/JPY/GBP, benutzerdefinierte Dimensionen. LiteLLM erfasst nur tokenbasiert.
- **Upstream-SSO-Anmeldung mit Zugangsdaten**: Bindet Anbieter ohne statische Schlüssel ein (z. B. Kiro). LiteLLM akzeptiert nur statische API-Schlüssel.
- **Registry für Capability-Metadaten**: Steuert automatische Injektion und Degradation; Capability-Drift neuer Modelle erfordert keine Codeänderung.
- **LTS-Release-Zweig**: N-1 + LTS-Zweig (siehe /lifecycle). LiteLLM unterstützt nur die letzten 4 Minor-Versionen.

### Beides können beide gut
Eine gesicherte Basis — jedes Gateway deckt diese Ebene ab. Die Entscheidung fällt in den Ebenen darüber und darunter.
| Funktion | GateLLM | LiteLLM |
| --- | --- | --- |
| API-Routing · Fallback · Lastverteilung | ✓ | ✓ |
| BYOK, kein Token-Aufschlag | ✓ | ✓ |
| Vollständig selbst gehostet, Daten bleiben On-Premises | ✓ | ✓ |
| Anbieterübergreifende Normalisierung von Tool-Aufrufen | ✓ | ✓ |
| Normalisierung strukturierter Ausgaben (JSON-Schema) | ✓ | ✓ |
| Anpassung von Reasoning-/Thinking-Token | ✓ | ✓ |
| Modellübergreifendes Prompt-Caching | ✓ | ✓ |
| Websuche-Injektion | ✓ | ✓ |
| MCP-Gateway (Tool-Aggregation) | ✓ | ✓ |
| Visuelle Konsole zur Konfiguration | ✓ | ✓ |
| Audit-Logs und Nutzungs-/Kostenmessung | ✓ | ✓ |

### Grundsätzlich anders
Nicht besser oder schlechter — andere Mechanismen und Paketierung, die Sie direkt abwägen sollten.
| Funktion | GateLLM | LiteLLM |
| --- | --- | --- |
| Laufzeit | Ein einzelnes Rust-Binary · keine GC-Pausen | Python-Prozess + Abhängigkeitsstapel |
| Protokollübersetzungs-Oberfläche | 15 Protokollformen; die vier Chat-Protokollfamilien (OpenAI / Anthropic / Gemini / DashScope) übersetzen von jedem zu jedem, der Rest gemäß Interop-Matrix | OpenAI-zentrierter Umschlag + kompatible Endpunkte |
| Native Protokoll-Einstiegspunkte | /v1/messages + count_tokens, Gemini generateContent, /v1beta/cachedContents CRUD, /v1/realtime, /mcp — ein Gateway bedient jedes SDK nativ | OpenAI-kompatibler Endpunkt (plus kompatible Varianten) |
| Tiefe des Prompt-Cachings | Injiziert Cache-Breakpoints automatisch bei OpenAI-Protokoll-Aufrufen + protokollübergreifendes Mapping + Google-cachedContent-Deduplizierung | Reicht cache_control durch, normalisiert die Nutzung |
| Standard-Datenschutz bei Logs | Anfrage-Logs standardmäßig aus · gespeicherte Log-Inhalte an jeder Ausgangsfläche redigiert, Rohfreigabe nur für Administratoren und auditiert · 7 Tage Standard-Aufbewahrung | Anfrage-/Antwort-Logging aktiv; Redaktion über Guardrails |
| Konfigurationsmodus | Vollständig in der Konsole — kein YAML, Änderungen wirken sofort | config.yaml-zentriert |
| Enterprise-SSO- und SCIM-Paketierung | OIDC + SAML 2.0 + SCIM im Pauschalpreis pro Instanz enthalten, keine Gebühren pro Sitzplatz | OSS begrenzt SSO auf 5 Benutzer; SCIM erfordert die nutzungsbasierte Enterprise-Stufe |
| Lizenzierung | Pauschal pro Instanz / Speicher, keine Sitzplätze, kein Token-Aufschlag | Kostenloses OSS; Enterprise ist nutzungsbasiert |
| Support-SLA | Priorisierter Support in der Pauschallizenz enthalten | Standardstufe ohne Reaktionszeit-Zusage; 24/7-SLA ist ein kostenpflichtiges Add-on (Sev0 1 h / Sev1 6 h) |
| Endpunkt-Oberfläche | Kern-Endpunkte für Chat / Realtime / MCP | Zusätzlich /batches, /files, /fine_tuning, /vector_stores, /videos, /containers |
| Drittanbieter-Ökosystem | Integrierte Logs / Prometheus / OTel — Standardprotokoll-Ausgang, keine Bindung an einen Anbieter; Secret- und PII-Erkennung im Gateway, keine Drittanbieter-Engine nötig | AWS KMS / Vault / CyberArk Secret Manager; Presidio-PII-Guardrails; Langfuse / Langsmith / Arize Observability |

Verifiziert anhand der offiziellen Dokumentation der jeweiligen Produkte mit Stand 2026-09-04 (docs.litellm.ai / docs.gatellm.io). Einige LiteLLM-Funktionen erfordern eine Enterprise-Lizenz; Details können sich ändern — prüfen Sie die Quellen vor der Beschaffung.

## Secrets und PII werden beim Eingang erkannt — Sie entscheiden, was als Nächstes passiert.
Eine deterministische Regel-Engine prüft jede Modellanfrage auf Zugangsdatenformate und PII und protokolliert den Fund, ohne das Secret selbst zu protokollieren. Die integrierten Regeln werden deaktiviert und im Beobachtungsmodus ausgeliefert; Sie aktivieren sie und wählen je Geltungsbereich Log, Maskieren oder Blockieren. Kein Modell sitzt im Erkennungspfad.
### Deterministische Erkennung, kein Modell im Pfad
Konstruktionsbedingt deterministisch: zuerst Literal-Proben, dann Regex-Regeln, die Kontextwörter erfordern, dann Prüfsummen-Validatoren — Luhn für Kartennummern, Mod-97 für IBAN, die Prüfsumme nationaler Ausweise, PEM- und OpenSSH-Privatschlüsselblöcke, IPv4.
- Zugangsdatenformate: API-Schlüssel von Modellanbietern, Cloud-Zugriffsschlüssel, GitHub- und GitLab-Token, JWTs, PEM- und OpenSSH-Privatschlüssel, Slack-Token
- PII-Klassen: Mobilfunknummern aus Festlandchina, nationale Personalausweisnummern, Bankkartennummern, IBANs, E-Mail-Adressen, IPv4-Adressen
- Mehrstufige Unterhaltungen scannen nur das Neue — eine Cursor-Hash-Kette verhindert, dass eine lange Sitzung bereits geprüften Text erneut scannt
### Maskierung, die Ihr Client durchschauen kann; Blockieren, das nichts preisgibt
Unter Maskieren erhält das Upstream-Modell nummerierte Platzhalter und Ihr Client bekommt die echten Werte zurück — inklusive Wiederherstellung pro SSE-Frame beim Streaming. Unter Blockieren enthält die Ablehnung die Regelkategorie und eine Anfrage-ID, niemals den gefundenen Text.
- Der Upstream sieht Platzhalter; die Partei, der die Daten gehören, bekommt ihre eigenen Werte zurück
- Lange Einfügungen sind nicht ausgenommen — übergroße Strings werden auf die Festplatte ausgelagert und in festen Fenstergrößen zurückgescannt, sodass der Speicher unabhängig von der Nutzlastgröße flach bleibt
- Die Allowlist gleicht nach Wert ab, nie nach Pfad: Das Freigeben eines Testschlüssels befreit nicht stillschweigend ein ganzes Feld
### Log-Inhalte: wie empfangen gespeichert, an jedem Ausgang redigiert
Die Persistenz von Anfrage-Logs ist im ausgelieferten Image aus. Schalten Sie sie ein, werden Inhalte wie empfangen gespeichert und anschließend an jeder Ausgangsfläche redigiert — die Konsolen-API redigiert standardmäßig, SSE- und Terminal-Ausgabe werden immer redigiert, und ein Redaktionsfehler schließt die Antwort, statt sie durchsickern zu lassen.
- Das Offenlegen von Rohinhalten ist ein ausdrücklicher Akt: eine Administratorrolle plus ein explizites Reveal-Flag, auditiert und gezählt
- Die Redaktion umfasst sensible Body-Schlüssel, sensible Query- und URL-Parameter, Header mit statischen und benutzerdefinierten Auth-Schemata sowie Bearer-Token-Werte mit teilweiser Offenlegung
- Ein Fund behält einen maskierten Ausschnitt mit begrenztem Kontext, niemals den gefundenen Text; Funde teilen das Aufbewahrungsfenster der Logs, standardmäßig 7 Tage
Standardmäßig aus, mit Absicht
Das integrierte Regelpaket wird deaktiviert ausgeliefert, und jede integrierte Regelaktion ist Log. Das ist der sichere Rollout und keine Lücke: Sehen Sie, was in Ihrem echten Datenverkehr passiert wäre, stimmen Sie die Allowlist anhand Ihrer eigenen Fehlalarme ab und aktivieren Sie dann Maskieren oder Blockieren, wo es zählt. Die Richtlinie gilt global, pro Zugriffsschlüsselgruppe oder pro Zugriffsschlüssel, und Regeln werden per Hot-Reload übernommen.
#### Log
Beobachten. Funde landen mit maskierten Ausschnitten in der Konsole; die Anfrage selbst bleibt unberührt.
#### Maskieren
Umkehrbar durchsetzen. Der Upstream sieht Platzhalter; Ihr Client erhält weiterhin den echten Wert.
#### Blockieren
Ablehnen. Die Anfrage wird mit Regelkategorie und Anfrage-ID zurückgewiesen — niemals mit dem gefundenen Text.
### Was es ist und was es nicht ist
#### Was es ist
- Läuft im eigenen Gateway-Prozess, auf dem Modellanfragepfad, mit Geltungsbereich global / pro Zugriffsschlüsselgruppe / pro Zugriffsschlüssel
- Eine eigene Konsolenseite: eine Fundansicht für Administrator- und Monitorrollen, eine Regelansicht für Administratoren, ein Ein-/Ausschalter mit Speicherbudget-Vorprüfung, Hot-Reload und Audit-Einträge
- Ein Dry-Run-Vorschau-Endpunkt, sodass eine Regel anhand einer Stichprobe getestet werden kann, bevor sie aktiviert wird
- Jeder Fund lässt sich auf Regelname, Kategorie, Schweregrad, ergriffene Aktion, Trefferzahl, Modell und Namen des Zugriffsschlüssels zurückführen

#### Was es nicht ist
- Keine Erkennung von Antwortinhalten — der Antwortpfad stellt nur Platzhalter wieder her
- Kein ML, keine Jailbreak- oder Prompt-Injection-Erkennung und keine Moderations-API: Die Regeln sind deterministisch
- Kein Offline-Re-Audit — Inhalte, die zur Anfragezeit nicht gescannt wurden, werden später nicht gescannt
- Keine DLP-Suite: keine Abdeckung von Endpunkten, E-Mail oder anderen Ausgangskanälen
- Keine Detektoren für Reisepass, SSN, Namen oder Adressen, und bekannte Restlücken sind dokumentiert — base64-kodierte Medien werden übersprungen, und ein über zwei Stream-Frames geteilter Platzhalter geht unverändert durch

## Was Sie tatsächlich bekommen.
Die drei Dinge, die die Beschaffung interessiert, vor dem Preis geklärt: ein DPA, das Ihre Rechtsabteilung unterzeichnen kann, eine Rechnung, die nicht davonläuft, und Prompts, die uns nie erreichen.
### Ein DPA, das Ihre Rechtsabteilung unterzeichnen kann
DSGVO- und CCPA-ready, mit einem DPA, das Ihre Rechtsabteilung tatsächlich unterzeichnen kann. Selbst gehostet — Daten verlassen nie Ihren Perimeterschutz — mit Enterprise-SSO (OIDC / SAML 2.0) und SCIM-2.0-Provisioning inklusive.
- DSGVO
- CCPA
- DPA
- SSO
- SCIM
- Audit-Trail
### Eine Rechnung, die nicht davonläuft
BYOK: Anbieter zu Standardtarifen bezahlen — kein Token-Aufschlag, keine Gebühren pro Sitzplatz. Harte Kontingentgrenzen pro Schlüssel und Projekt verhindern, dass ein außer Kontrolle geratenes Skript Ihr Budget überholt.
- Kein Token-Aufschlag
- 0 Gebühren pro Sitzplatz
- Prompt-Cache
- Harte Kontingentgrenzen
- 30-Tage-Rückerstattung
### Ihre Prompts erreichen uns nie
Vollständig selbst gehostet — Ihre Prompts und Completions gelangen überhaupt nie in unsere Systeme. BYOK-Schlüssel liegen nur im Speicher des Gateways; Anfragen gehen direkt an die Anbieter-APIs und verlassen Ihr Netzwerk nie.
- Daten bleiben On-Premises
- Schlüssel nie persistiert
- TLS 1.3
- Client-Zulassung
- Selbst gewählte Modelle

## Vollständig selbst gehostet · Einzelinstanz 2 GB · Nie Aufschlag auf Token-Gebühren
BYOK (eigene Schlüssel) — Sie zahlen Anbieter zu Standardtarifen. Wir lizenzieren eine einzelne 2-GB-Instanz, nie nach Sitzplätzen oder Token-Aufschlag. Größerer Speicher oder mehrere Instanzen laufen über Enterprise.
Der Kern ist in Rust gebaut. Auf der Ebene der Gateway-Weiterleitung trägt jedes GB Speicher etwa 100 Mio. Token pro Minute (TPM) und ~500 Anfragen pro Minute (RPM) und bedient damit komfortabel ~100 typische Benutzer. Das sind Referenzwerte: Der tatsächliche Durchsatz wird von den Ratenlimits Ihrer Anbieter und der Komplexität der Anfragen begrenzt und ist keine SLA-Zusage.
In jedem Tarif enthalten: BYOK ohne Token-Aufschlag · Routing zu 100+ Anbietern · Client-Zugriffskontrolle · Prompt-Caching · Kostenkontingente
### Free
$0
Vollständig selbst gehostet · Einzellizenz
512-MB-Einzelinstanz, keine Log-Aufbewahrung — geeignet für Evaluierung und PoCs, nicht für Produktionsdatenverkehr.
- Routing zu 100+ LLMs · Fallback · Lastverteilung
- Anbieterübergreifendes Modell-Mixing · Downgrade im Agenten (Plan gesperrt / automatisches Downgrade außerhalb des Plan-Modus)
- Client-Zugriffskontrolle (User-Agent-Richtlinie)
- Prompt-Caching
- BYOK (eigene Schlüssel, kein Aufschlag)
- 512-MB-Speicherlimit · SQLite · Einzelinstanz
- GitHub-Actions-Code-Review über Ihr eigenes Gateway
- Keine Log-Aufbewahrung
### Pro
$400
Festes 2-GB-Limit, kein Add-on. Für mehrere Knoten, Compliance (Audit/DLP) oder die Management-API wählen Sie Enterprise.
- Alle Free-Funktionen
- 2 GB Speicher · Einzelinstanz (festes Limit, kein Add-on)
- Log-Aufbewahrung
- Enterprise-SSO (OIDC: Azure AD / Okta / generisch, plus SAML 2.0 + SCIM)
- PostgreSQL · 2 GB Speicher
- E-Mail-/Ticket-Support
100 % Rückerstattung innerhalb von 30 Tagen bei Unzufriedenheit
### Enterprise
ab $400/GB
Nach Speicherkapazität · Jährliche Abrechnung · 30-Tage-Rückerstattung
- Alle Pro-Funktionen
- Kapazitätsbasierte Abrechnung (Knoten × Speicher, pauschal $400/GB/Monat)
- Multi-Node-/Cluster-Deployment
- GitHub-Actions-Code-Review über Ihr eigenes Gateway
- Microsoft-365-Add-in (Excel/Word/PPT/Outlook, kostenpflichtiges Add-on)
- Erweiterte Log-Aufbewahrung
- Priorisierte Support-Reaktion
- Compliance (Audit / DLP)
- Management-API (programmatischer API-Schlüssel · Kontingent · Nutzungsabfrage · Audit-Export)
Brauchen Sie mehr Kapazität oder ein individuelles Setup?
## Funktionsvergleich

| Funktion | Free | Pro | Enterprise |
| --- | --- | --- | --- |
| Multi-Modell-Routing · Fallback · Lastverteilung | ✓ | ✓ | ✓ |
| Anbieterübergreifendes Modell-Mixing (Planung/Ausführung nach Anbieter) | ✓ | ✓ | ✓ |
| Downgrade im Agenten (Plan gesperrt / automatisches Downgrade außerhalb des Plan-Modus) | ✓ | ✓ | ✓ |
| Prompt-Caching | ✓ | ✓ | ✓ |
| BYOK (eigene Schlüssel, kein Aufschlag) | ✓ | ✓ | ✓ |
| Speicherstufe | 512 MB | 2 GB (fest) | Individuell |
| Speicher / Datenbank | SQLite (Einzelinstanz) | PostgreSQL · 2 GB | PostgreSQL + Redis-Cluster |
| Deployment-Skala | 1 Instanz | 1 Instanz · 2 GB | Multi-Node / Cluster |
| Durchsatz pro GB (Referenz) | — | 2 GB ≈ 200 Mio. TPM / 1.000 RPM | ≈ 100 Mio. TPM / 500 RPM pro GB |
| Log-Aufbewahrung | Keine | Aufbewahrt | Erweiterte Aufbewahrung |
| SSO (OIDC / SAML 2.0) | — | ✓ | ✓ |
| SCIM-2.0-Auto-Provisioning | — | ✓ | ✓ |
| Compliance (Audit / DLP) | — | — | ✓ |
| Management-API (programmatischer Schlüssel · Kontingent · Nutzung · Audit) | — | — | ✓ |
| Eigene Preisliste / Preis-Snapshots (inkl. privater Preisgestaltung) | ✓ | ✓ | ✓ |
| Kostenkontingente (täglich / monatlich, dreistufige Vererbung) | ✓ | ✓ | ✓ |
| Support-Reaktion | Community | E-Mail / Ticket | Priorisierte Reaktion |
| Modusbewusste Modellrichtlinie (Plan/Ausführung, durchsetzbar) | ✓ | ✓ | ✓ |
| Client-Zugriffskontrolle (User-Agent-Richtlinie) | ✓ | ✓ | ✓ |
| GitHub-Actions-Code-Review (über Ihr Gateway) | ✓ | ✓ | ✓ |
| Microsoft-365-Add-in (Excel/Word/PPT/Outlook, selbst gehostet) | — | Add-on | Add-on |
| Purview-Sensitivitätslabel-Gating (addin.access / file.upload) | — | — | ✓ |

## FAQ
### Wie viel Latenz fügt ein KI-Gateway hinzu?

Ein SaaS-Gateway fügt einen zusätzlichen Sprung aus Ihrem Netzwerk hinaus hinzu. GateLLM wird selbst gehostet in Ihrer VPC betrieben; der zusätzliche Sprung zur Anbieter-API ist lokale Interprozess-Kommunikation — submillisekunden Overhead mit vernachlässigbarem Einfluss auf die Streaming-Zeit bis zum ersten Token.
### Was passiert, wenn ein Anbieter ausfällt oder ein Ratenlimit erreicht?

Der direkte Weg zu einem Anbieter ist ein Single Point of Failure. GateLLM unterstützt anbieterübergreifendes Fallback — wenn der primäre Anbieter 5xx zurückgibt oder in einen Timeout läuft, wechselt der Datenverkehr ohne Codeänderung zu einem Backup-Anbieter. Zudem poolt es mehrere Schlüssel pro Upstream: Ein deterministischer Hash bindet jeden Aufrufer fest an einen Schlüssel, und wenn ein Schlüssel ausfällt, wiederholt das Gateway den Versuch mit dem nächsten unversuchten Schlüssel.
### Brauche ich wirklich ein Gateway?

Ehrliche Messlatte: ein Anbieter, ein Team, keine Compliance-Vorgabe, überschaubare Monatsausgaben — rufen Sie APIs direkt auf; Sie brauchen kein Gateway. Ein Gateway beginnt sich zu rechnen, wenn Sie Multi-Anbieter-Failover, Kostenzuordnung pro Team, Compliance / Datenresidenz oder Echtzeittransparenz bei außer Kontrolle geratenen Ausgaben brauchen.
### Wie verdient GateLLM im BYOK-Modus Geld?

Wir lizenzieren eine einzelne Instanz mit 2 GB Speicher (Pro $400/Monat, jährlich 20 % Rabatt auf $3.840/Jahr), kein Token-Aufschlag, keine Gebühren pro Sitzplatz. Sie zahlen Anbieter zu Standardtarifen, GateLLM nimmt keinen Zwischenanteil.
### Verlassen meine API-Schlüssel und Daten mein Netzwerk?

Nein. Im BYOK-Modus werden API-Schlüssel nur im Speicher des Gateways gehalten, nie persistiert oder übertragen. Anfragen laufen über das Gateway direkt an die offiziellen APIs der Anbieter — Daten verlassen Ihr privates Netzwerk nie.
### Woher weiß ich, dass das Gateway das echte Modell bedient und kein billigeres Substitut?

Bei einem SaaS-Aggregator können Sie nur seinem Wort vertrauen. GateLLM ist BYOK und selbst gehostet: Sie nutzen Ihre eigenen Schlüssel, und Anfragen gehen von Ihrem Gateway direkt an den API-Endpunkt des Anbieters — die Modellidentität wird von der Anbieter-API selbst garantiert, ohne austauschbaren Sprung dazwischen.

## Starten Sie mit dem Bau Ihrer Multi-Modell-KI-Apps
Vollständig selbst gehostet · Einzelinstanz 2 GB · Nie Aufschlag auf Token-Gebühren.

## Verwandt
- [Preise](https://www.gatellm.io/de/pricing.md)
- [Kostenrechner](https://www.gatellm.io/de/calculator.md)
- [Über uns](https://www.gatellm.io/de/about.md)
- [Demo buchen](https://www.gatellm.io/de/demo.md)
- [FAQ](https://www.gatellm.io/de/faq.md)
- [AI-Gateways vergleichen](https://www.gatellm.io/de/compare.md)
- [LiteLLM vergleichen](https://www.gatellm.io/de/compare/litellm.md)
- [OpenRouter vergleichen](https://www.gatellm.io/de/compare/openrouter.md)
- [Alibaba Cloud AI Gateway vergleichen](https://www.gatellm.io/de/compare/alibaba-cloud.md)
- [Azure API Management vergleichen](https://www.gatellm.io/de/compare/azure-apim.md)
- [Apigee vergleichen](https://www.gatellm.io/de/compare/apigee.md)
- [Cloudflare AI Gateway vergleichen](https://www.gatellm.io/de/compare/cloudflare.md)
- [Kong AI Gateway vergleichen](https://www.gatellm.io/de/compare/kong.md)
- [Portkey vergleichen](https://www.gatellm.io/de/compare/portkey.md)
- [LiteLLM vs Kong AI Gateway](https://www.gatellm.io/de/compare/litellm-vs-kong.md)
- [LiteLLM vs OpenRouter](https://www.gatellm.io/de/compare/litellm-vs-openrouter.md)
- [LiteLLM vs Portkey](https://www.gatellm.io/de/compare/litellm-vs-portkey.md)
- [Anwendungsfälle](https://www.gatellm.io/de/use-cases.md)
- [LLM-Kosten senken](https://www.gatellm.io/de/use-cases/reduce-cost.md)
- [Hochverfügbarkeit](https://www.gatellm.io/de/use-cases/high-availability.md)
- [Multi-Tenant-Isolation](https://www.gatellm.io/de/use-cases/multi-tenant.md)
- [Compliance & Audit](https://www.gatellm.io/de/use-cases/compliance-audit.md)
- [Fehlerbehebung nach Symptom](https://www.gatellm.io/de/use-cases/troubleshooting.md)
- [Gemischter Multi-Vendor-Modellstack](https://www.gatellm.io/de/use-cases/mixed-model-stack.md)
- [KI im Office selbst hosten](https://www.gatellm.io/de/use-cases/self-hosted-office-ai.md)
- [Token-Nutzung: Transparenz & Zuordnung](https://www.gatellm.io/de/use-cases/token-ops.md)
- [Token-FinOps: KI-Kosten zuordnen & steuern](https://www.gatellm.io/de/use-cases/token-finops.md)
- [MCP-Tool-Governance](https://www.gatellm.io/de/use-cases/mcp-tool-governance.md)
- [Websuche für jedes Modell](https://www.gatellm.io/de/use-cases/web-search-grounding.md)
- [Multi-Key-Rotation & Standby](https://www.gatellm.io/de/use-cases/multi-key-pooling.md)
- [Zugangskontrolle für verbundene Clients](https://www.gatellm.io/de/use-cases/client-admission-control.md)
- [Modellrichtlinie durchsetzen](https://www.gatellm.io/de/use-cases/enforce-model-policy.md)
- [Keine Modellwahl im Client](https://www.gatellm.io/de/use-cases/automatic-model-tiering.md)
- [Ein Protokoll, jedes Modell](https://www.gatellm.io/de/use-cases/one-protocol-any-model.md)
- [Office / Microsoft 365 Add-in](https://www.gatellm.io/de/office-addin.md)
- [Glossar](https://www.gatellm.io/de/glossary.md)
- [Modellkatalog](https://www.gatellm.io/de/models.md)
- [SDK- & Framework-Integrationen](https://www.gatellm.io/de/integrations.md)
- [KI-Coding-Agents & Harnesses](https://www.gatellm.io/de/coding-agents.md)
- [Sicherheit & Compliance](https://www.gatellm.io/de/security.md)