LiteLLM AI Gateway

LiteLLM als AI-Gateway-Proxy für 100+ LLMs auf Clore.ai-GPUs bereitstellen

LiteLLM ist ein Open-Source-AI-Gateway, das eine einheitliche OpenAI-kompatible API für über 100 Sprachmodell-Anbieter bereitstellt – einschließlich OpenAI, Anthropic, Azure, Bedrock, HuggingFace und lokal gehosteter Modelle. Setzen Sie es auf CLORE.AI ein, um alle Ihre LLM-API-Aufrufe über einen einzigen Endpunkt mit eingebauter Kostenverfolgung, Ratenbegrenzung und Fallback-Logik zu routen, zu load-balancen und zu verwalten.

Die wahre Stärke von LiteLLM zeigt sich im großen Maßstab: Teams, die gemischte lokale+Cloud-Stacks betreiben, können Modelle austauschen, ohne den Anwendungscode zu berühren. gpt-4o mit mistral-7b-local in der Konfiguration ersetzen, neu starten — fertig.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	4 GB	8 GB+
VRAM	Nicht anwendbar (nur Proxy)	Nicht anwendbar
Festplatte	10 GB	20 GB+
GPU	Nicht erforderlich	Optional (für lokale Modelle)

LiteLLM selbst ist ein CPU-basierter Proxy und benötigt keine GPU. Es macht jedoch Sinn, es auf einem CLORE.AI-GPU-Server bereitzustellen, wenn Sie lokale Modelle (über Ollama, TGI, vLLM) zusammen mit LiteLLM als einheitliches Gateway auf derselben Maschine ausführen möchten.

Schnelle Bereitstellung auf CLORE.AI

Docker-Image: ghcr.io/berriai/litellm:main-latest

Ports: 22/tcp, 4000/http

Umgebungsvariablen:

Variable	Beispiel	Beschreibung
OPENAI_API_KEY	sk-xxx...	OpenAI API-Schlüssel
ANTHROPIC_API_KEY	sk-ant-xxx...	Anthropic API-Schlüssel
AZURE_API_KEY	xxx...	Azure OpenAI-Schlüssel
LITELLM_MASTER_KEY	sk-my-master-key	Master-Authentifizierungsschlüssel für den Proxy
DATABASE_URL	postgresql://...	PostgreSQL für Kostenverfolgung
STORE_MODEL_IN_DB	True	Modellkonfiguration in der DB persistieren

Schritt-für-Schritt-Einrichtung

1. Mieten Sie einen Server auf CLORE.AI

LiteLLM funktioniert auch auf CPU-only-Servern hervorragend. Gehen Sie zu CLORE.AI Marketplace und filtern Sie nach:

• Günstigste CPU-Server für ein reines Proxy-Setup

• GPU-Server (RTX 3090+), wenn Sie auch lokale Modelle ausführen möchten

2. SSH auf Ihren Server

ssh -p <PORT> root@<SERVER_IP>

3. Erstellen Sie eine Konfigurationsdatei

LiteLLM verwendet eine YAML-Konfigurationsdatei, um Modelle zu definieren:

mkdir -p /root/litellm
cat > /root/litellm/config.yaml << 'EOF'
model_list:
  # OpenAI-Modelle
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

  - model_name: gpt-4o-mini
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"

  # Anthropic-Modelle
  - model_name: claude-3-5-sonnet
    litellm_params:
      model: anthropic/claude-3-5-sonnet-20241022
      api_key: "os.environ/ANTHROPIC_API_KEY"

  # Lokales Modell über TGI (auf demselben Server, Port 8080)
  - model_name: mistral-7b-local
    litellm_params:
      model: openai/mistralai/Mistral-7B-Instruct-v0.3
      api_base: "http://localhost:8080/v1"
      api_key: "none"

  # Load Balancer: Route zu mehreren Endpunkten
  - model_name: fast-model
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"
    model_info:
      mode: chat

litellm_settings:
  drop_params: True
  set_verbose: False
  num_retries: 3
  request_timeout: 60

general_settings:
  master_key: "sk-my-secret-master-key"  # Ändern Sie dies!
  alerting: []
EOF

4. Starten Sie LiteLLM

Basisstart:

docker run -d \
  --name litellm \
  --network host \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Mit PostgreSQL für Kostenverfolgung:

Starten Sie zuerst einen PostgreSQL-Container:

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=litellm_pass \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres:15

# Dann LiteLLM mit DB starten
docker run -d \
  --name litellm \
  -p 4000:4000 \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  -e DATABASE_URL="postgresql://postgres:litellm_pass@localhost:5432/litellm" \
  --network host \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Verwendung von Docker Compose (empfohlen):

cat > /root/litellm/docker-compose.yml << 'EOF'
version: "3.8"
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - LITELLM_MASTER_KEY=sk-my-secret-master-key
      - DATABASE_URL=postgresql://postgres:litellm_pass@db:5432/litellm
    command: --config /app/config.yaml --port 4000 --host 0.0.0.0
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: litellm_pass
      POSTGRES_DB: litellm
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
EOF

cd /root/litellm && docker compose up -d

5. Überprüfen Sie den Server

# Prüfe Gesundheitszustand
curl http://localhost:4000/health

# Liste verfügbare Modelle auf
curl http://localhost:4000/v1/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

6. Zugriff über CLORE.AI HTTP-Proxy

Ihre CLORE.AI http_pub-URL für Port 4000:

https://<order-id>-4000.clore.ai/v1

Verwenden Sie dies als Ihr api_base in jedem OpenAI-kompatiblen Client.

---

Beispielanwendungen

Beispiel 1: Direkter API-Aufruf über Proxy

curl http://localhost:4000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "user", "content": "What is the capital of Germany?"}
    ]
  }'

Beispiel 2: OpenAI Python SDK mit LiteLLM-Proxy

from openai import OpenAI

# Ändern Sie nur base_url und api_key — alles andere ist identisch
client = OpenAI(
    base_url="http://localhost:4000/v1",
    api_key="sk-my-secret-master-key",
)

# Verwenden Sie jedes Modell aus Ihrer Konfiguration
response = client.chat.completions.create(
    model="gpt-4o-mini",  # oder "claude-3-5-sonnet", "mistral-7b-local"
    messages=[{"role": "user", "content": "Summarize the benefits of GPU computing."}],
)
print(response.choices[0].message.content)

# Wechseln Sie Modelle ohne Codeänderungen
response2 = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "Same question, different model."}],
)
print(response2.choices[0].message.content)

Beispiel 3: LiteLLM Python SDK (Direkt)

import litellm

# Direkt ohne Proxy verwenden
response = litellm.completion(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    api_key="your-openai-key",
)

# Oder über Ihren Proxy routen
response = litellm.completion(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    api_base="http://localhost:4000",
    api_key="sk-my-secret-master-key",
)

Beispiel 4: Fallback-Konfiguration

Konfigurieren Sie automatische Fallbacks zwischen Modellen:

# In config.yaml
model_list:
  - model_name: smart-fallback
    litellm_params:
      model: gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

router_settings:
  routing_strategy: least-busy
  model_group_alias:
    "gpt-4-fallback":
      - "gpt-4o"
      - "claude-3-5-sonnet"
      - "mistral-7b-local"
  num_retries: 3
  fallbacks:
    - gpt-4o:
        - claude-3-5-sonnet
        - mistral-7b-local

Beispiel 5: Kosten-Tracking-Dashboard

Nachdem Sie PostgreSQL aktiviert haben, greifen Sie auf Ausgabenanalysen zu:

# Ausgabe nach Benutzer abrufen
curl http://localhost:4000/global/spend/users \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Ausgabe nach Modell abrufen
curl http://localhost:4000/global/spend/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Ausgabebericht erzeugen
curl "http://localhost:4000/global/spend?start_date=2024-01-01&end_date=2024-12-31" \
  -H "Authorization: Bearer sk-my-secret-master-key"

---

Konfiguration

Virtuelle Schlüssel (pro Benutzer API-Schlüssel)

Erstellen Sie separate Schlüssel mit Ratenbegrenzungen und Budgets:

# Erstellen Sie einen Schlüssel mit Budget
curl http://localhost:4000/key/generate \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "models": ["gpt-4o-mini", "claude-3-5-sonnet"],
    "duration": "30d",
    "max_budget": 10.0,
    "metadata": {"user_id": "user_123"}
  }'

Lastverteilung

model_list:
  # Round-Robin zwischen mehreren OpenAI-API-Schlüsseln
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-1
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-2

router_settings:
  routing_strategy: least-busy  # oder: simple-shuffle, latency-based-routing

Caching

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379
    ttl: 3600  # 1 Stunde

Ratenbegrenzung

general_settings:
  default_team_settings:
    tpm_limit: 100000   # Tokens pro Minute
    rpm_limit: 1000     # Anfragen pro Minute

---

Leistungs-Tipps

1. Caching für wiederholte Prompts aktivieren

Für RAG- oder Chatbot-Anwendungen mit häufigen Fragen senkt Redis-Caching die Kosten um 30–70% und reduziert die P50-Latenz bei Cache-Treffern auf <5 ms:

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379

2. Verwenden Sie asynchrone Anfragen

import asyncio
import litellm

async def batch_complete(prompts):
    tasks = [
        litellm.acompletion(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
        )
        for p in prompts
    ]
    return await asyncio.gather(*tasks)

results = asyncio.run(batch_complete(["Hello", "World", "Test"]))

3. Lokale Modell-Routing

Routen Sie günstige/einfache Anfragen an lokale Modelle auf Clore.ai-GPUs, komplexe an GPT-4:

model_list:
  - model_name: smart-router
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

Eine typische Einrichtung: Führen Sie Mistral 7B oder Llama 3 8B lokal auf einer Clore.ai RTX 3090 ($0.10–0.15/Stunde) aus, bearbeiten Sie dort 80% des Traffics und eskalieren Sie komplexe Aufgaben an GPT-4o. Kosteneinsparungen von 3–5× gegenüber rein cloudbasierten Setups sind üblich.

4. Timeouts und Wiederholungen festlegen

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Clore.ai GPU-Empfehlungen

LiteLLM selbst benötigt keine GPU — es ist ein Proxy. Die GPU-Auswahl ist nur dann relevant, wenn Sie lokale Inferenz daneben betreiben.

Lokales Modell	GPU	Warum
Mistral 7B / Llama 3 8B (bf16)	RTX 3090 24 GB	Passt bequem, ~200 tok/s Durchsatz
Mixtral 8×7B oder Llama 3 70B (AWQ)	RTX 4090 24 GB	Schnellere Speicherbandbreite als 3090; passt 70B AWQ 4-bit
Llama 3 70B (bf16) oder Multi-Model-Serving	A100 80 GB	Führen Sie mehrere 7–13B-Modelle gleichzeitig aus; HBM2e für niedrige Latenz

Empfohlener Stack für einen Solo-Entwickler: RTX 3090 + Mistral 7B + LiteLLM-Gateway. Gesamtkosten auf Clore.ai: ~0,12 $/Stunde. Bewältigt leicht ~50 Anfragen/Min, mit GPT-4o-Fallback für komplexe Aufgaben.

Team- / Produktions-Stack: A100 80GB, Llama 3 70B + LiteLLM + PostgreSQL. Bedient 20+ gleichzeitige Nutzer, vollständige Kostenverfolgung, für die meisten Anfragen keine Cloud-LLM-Kosten.

---

Fehlerbehebung

Problem: „Modell nicht gefunden“

Stellen Sie sicher, dass der Modellname in Ihrer Anfrage genau mit dem in config.yaml:

curl http://localhost:4000/v1/models -H "Authorization: Bearer sk-my-secret-master-key"

Problem: „Authentifizierung fehlgeschlagen“

Überprüfen Sie Ihre LITELLM_MASTER_KEY Umgebungsvariable und verwenden Sie sie als Bearer-Token.

Problem: Konfigurationsänderungen werden nicht übernommen

Starten Sie den Container nach Konfigurationsänderungen neu:

docker restart litellm

Problem: Hohe Latenz bei der ersten Anfrage

LiteLLM lädt Modellkonfigurationen beim Start. Die ersten Anfragen können langsamer sein, da Verbindungen aufgebaut werden.

Problem: Datenbankverbindungsfehler

# Prüfen Sie, ob PostgreSQL läuft
docker logs postgres

# Überprüfen Sie das Format der Verbindungszeichenfolge
DATABASE_URL="postgresql://user:password@host:5432/dbname"

Problem: 429 Ratenbegrenzungsfehler von Anbietern

Konfigurieren Sie Fallbacks:

litellm_settings:
  num_retries: 5
  fallbacks:
    - gpt-4o: [claude-3-5-sonnet]

---

Clore.ai GPU-Empfehlungen

LiteLLM ist ein API-Gateway/Proxy — es führt selbst keine Inferenz durch. Die GPU-Auswahl hängt davon ab, ob Sie zu Cloud-APIs oder lokalen Modellen routen.

Einrichtung	GPU	Clore.ai-Preis	Anwendungsfall
Nur Cloud-API-Proxy	Nur CPU	~$0.02/Stunde	Routen Sie zu OpenAI, Anthropic, Gemini — keine GPU erforderlich
Lokales vLLM-Backend	RTX 3090 (24GB)	~$0.12/Stunde	Selbst gehostete 7B–13B-Modelle mit LiteLLM als Frontend
Lokales vLLM-Backend	RTX 4090 (24GB)	~$0.70/Stunde	Höherer Durchsatz für lokale 7B–34B-Modelle
Lokales vLLM-Backend	A100 40GB	~$1.20/Stunde	70B-Modelle, produktiver lokaler Betrieb

Am häufigsten verwendete Konfiguration: Führen Sie LiteLLM als einheitlichen Proxy vor Ihren Clore.ai-gehosteten vLLM/Ollama-Instanzen aus. Das gibt Ihnen Anbieter-Fallbacks, Ratenbegrenzung, Kostenverfolgung und OpenAI-kompatibles Routing — während alle Inferenz lokal und kostengünstig bleibt.

Beispielkosten: Führen Sie den LiteLLM-Proxy auf einer CPU-only-Instanz (0,02 $/Stunde) aus und richten Sie ihn auf einen vLLM-Server auf einer RTX 3090 (0,12 $/Stunde). Gesamtkosten ~0,14 $/Stunde für eine produktionsbereite, selbst gehostete LLM-API mit Fallbacks, Protokollierung und Ratenbegrenzung.

---

Links

• GitHub

• Dokumentation

• Docker Hub / GHCR

• Unterstützte Anbieter

• CLORE.AI Marketplace