> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.

# LiteLLM

## LiteLLM-Übersicht

LiteLLM ist ein quelloffenes **vereinheitlichtes KI-Gateway**, entwickelt von [BerriAI](https://github.com/BerriAI/litellm). Es bietet eine einzige standardisierte Schnittstelle, mit der nahezu jedes große LLM am Markt aufgerufen werden kann. Repository: [https://github.com/BerriAI/litellm](https://github.com/BerriAI/litellm)

<Frame>
  <img src="https://mintcdn.com/aihubmix/HWcKoL0Wliaf75A6/images/image-90.png?fit=max&auto=format&n=HWcKoL0Wliaf75A6&q=85&s=340719652443a06b570d103064a64989" alt="Image" width="2688" height="1600" data-path="images/image-90.png" />
</Frame>

Jeder LLM-Anbieter liefert sein eigenes SDK und API-Format – OpenAI, Anthropic und Google unterscheiden sich alle. Ein Modellwechsel oder die parallele Nutzung mehrerer Modelle bedeutet, separate Codebasen zu pflegen. LiteLLM löst das: **einmal schreiben, einen Parameter ändern, jedes Modell aufrufen**.

### Zwei Verwendungsarten

| Modus            | Beschreibung                                   | Geeignet für                                |
| :--------------- | :--------------------------------------------- | :------------------------------------------ |
| **Python SDK**   | `pip install litellm`, direkt im Code aufrufen | Persönliche Projekte, schnelles Prototyping |
| **Proxy Server** | Eigenständig deploybares KI-Gateway            | Team-Sharing, Enterprise-Zugriffssteuerung  |

### Kernfähigkeiten

* **Vereinheitlichtes OpenAI-Format**: unterstützt 100+ Anbieter, darunter OpenAI, Anthropic, Gemini, Bedrock, Azure und mehr
* **Virtuelle Schlüsselverwaltung**: zentrale Verwaltung von Team-API-Schlüsseln, ohne die Originale offenzulegen
* **Kosten-Tracking**: Tokenverbrauch und Ausgaben pro Benutzer oder Projekt überwachen
* **Load Balancing**: automatische Traffic-Verteilung über Modelle hinweg mit Failover-Unterstützung
* **Hochleistungsfähig**: P95-Latenz von \~8 ms bei 1.000 RPS

***

## Installation

### Voraussetzungen

Python 3.8+

**macOS**

Installation per [Homebrew](https://brew.sh/):

```bash theme={null}
brew install python
```

Prüfen:

```bash theme={null}
python3 --version
```

**Windows**

Laden Sie den Installer von [python.org/downloads](https://www.python.org/downloads/) herunter. Aktivieren Sie während der Installation **„Add Python to PATH"**.

Prüfen:

```bash theme={null}
python --version
```

**Linux (Ubuntu/Debian)**

```bash theme={null}
sudo apt update
sudo apt install python3 python3-pip
```

### pip

pip ist in der Regel in Python enthalten. Verfügbarkeit prüfen:

```bash theme={null}
pip --version
# oder
pip3 --version
```

Falls nicht vorhanden, manuell installieren:

```bash theme={null}
# Universal-Methode
python3 -m ensurepip --upgrade

# Ubuntu/Debian
sudo apt install python3-pip

# Auf neueste Version aktualisieren
pip install --upgrade pip
```

### LiteLLM installieren

Sobald Ihre Umgebung bereit ist:

```bash theme={null}
python3 -m pip install litellm
```

Installation überprüfen:

```bash theme={null}
python3 -m pip show litellm
```

### Optionale Abhängigkeiten

Manche Anbieter benötigen zusätzliche Pakete:

```bash theme={null}
# AWS Bedrock
pip install litellm[bedrock]

# Google Vertex AI
pip install litellm[vertex]

# Alle Abhängigkeiten (nicht für Production empfohlen)
pip install litellm[all]
```

### Proxy Server installieren

Für ein eigenständiges Gateway:

```bash theme={null}
pip install 'litellm[proxy]'
```

### Docker (optional)

```bash theme={null}
docker pull ghcr.io/berriai/litellm:main-latest
```

> **Empfehlung**: Nutzen Sie `pip install litellm` für die persönliche Entwicklung; wählen Sie Proxy + Docker für Team-Deployments.

***

## API-Schlüssel konfigurieren und ersten Aufruf machen

### AiHubMix-API-Schlüssel besorgen

Gehen Sie zum [aihubmix.com](https://aihubmix.com)-Dashboard und erstellen Sie einen API-Schlüssel.

### Umgebungsvariable setzen

```bash theme={null}
export AIHUBMIX_API_KEY="your-aihubmix-key"
```

### Erster Aufruf

```python theme={null}
import os
from litellm import completion

response = completion(
    model="openai/gpt-4o-mini",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Hello, introduce yourself"}]
)

print(response.choices[0].message.content)
```

***

## Grundlegende Verwendung

### 1. Modellwechsel

AiHubMix unterstützt alle wichtigen Modelle. Der Wechsel erfordert nur das Ändern des `model`-Parameters:

```python theme={null}
import os
from litellm import completion

response = completion(
    model="openai/claude-sonnet-4-6",  # change this
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Hello, introduce yourself"}]
)

print(response.choices[0].message.content)
```

***

### 2. Streaming

Fügen Sie `stream=True` hinzu, um die Ausgabe Token für Token zu erhalten:

```python theme={null}
import os
from litellm import completion

response = completion(
    model="openai/claude-sonnet-4-6",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Explain Python in 100 words"}],
    stream=True
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="", flush=True)
print()
```

***

### 3. Multi-Turn-Konversation

Übergeben Sie den Konversationsverlauf in der `messages`-Liste, damit das Modell den Kontext berücksichtigt:

```python theme={null}
import os
from litellm import completion

messages = [
    {"role": "user", "content": "My name is Alex"},
    {"role": "assistant", "content": "Hello, Alex!"},
    {"role": "user", "content": "What is my name?"}
]

response = completion(
    model="openai/claude-sonnet-4-6",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=messages
)

print(response.choices[0].message.content)
```

***

### 4. Asynchrone Aufrufe

Senden Sie mehrere Anfragen gleichzeitig, ohne auf jede einzelne zu warten:

```python theme={null}
import os
import asyncio
from litellm import acompletion

async def ask(question):
    response = await acompletion(
        model="openai/claude-sonnet-4-6",
        api_base="https://aihubmix.com/v1",
        api_key=os.environ.get("AIHUBMIX_API_KEY"),
        messages=[{"role": "user", "content": question}]
    )
    return response.choices[0].message.content

async def main():
    questions = [
        "What color is an apple?",
        "What color is the sky?",
        "What color is grass?"
    ]
    results = await asyncio.gather(*[ask(q) for q in questions])
    for q, r in zip(questions, results):
        print(f"Q: {q}")
        print(f"A: {r}")
        print()

asyncio.run(main())
```

***

### 5. Timeout und Retry

Verhindern Sie, dass Requests aufgrund von Netzwerkproblemen hängen oder fehlschlagen:

```python theme={null}
import os
from litellm import completion

response = completion(
    model="openai/claude-sonnet-4-6",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Hello"}],
    timeout=10,      # raise an error after 10 seconds
    num_retries=3    # retry up to 3 times on failure
)

print(response.choices[0].message.content)
```

> `timeout` ist in Sekunden. Setzen Sie `num_retries` auf 2–3; höhere Werte verlangsamen die Antwort.

***

### 6. Tokenverbrauch und Kosten-Tracking

Jede Antwort enthält Daten zum Tokenverbrauch:

```python theme={null}
import os
from litellm import completion

response = completion(
    model="openai/claude-sonnet-4-6",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Explain Python in 100 words"}]
)

print(response.choices[0].message.content)
print()
print("Token usage:")
print(f"  Input:  {response.usage.prompt_tokens}")
print(f"  Output: {response.usage.completion_tokens}")
print(f"  Total:  {response.usage.total_tokens}")
```

Kosten pro Aufruf nachvollziehen:

```python theme={null}
import os
from litellm import completion, completion_cost

response = completion(
    model="openai/claude-sonnet-4-6",
    api_base="https://aihubmix.com/v1",
    api_key=os.environ.get("AIHUBMIX_API_KEY"),
    messages=[{"role": "user", "content": "Explain Python in 100 words"}]
)

cost = completion_cost(completion_response=response)
print(f"Cost: ${cost:.6f}")
```

***

### 7. Load Balancing und Failover

Konfigurieren Sie mehrere Modelle, um den Traffic automatisch zu verteilen oder bei Fehler auf ein Backup-Modell umzuschalten:

```python theme={null}
import os
from litellm import Router

router = Router(
    model_list=[
        {
            "model_name": "my-model",
            "litellm_params": {
                "model": "openai/claude-sonnet-4-6",
                "api_base": "https://aihubmix.com/v1",
                "api_key": os.environ.get("AIHUBMIX_API_KEY"),
            }
        },
        {
            "model_name": "my-model",
            "litellm_params": {
                "model": "openai/gpt-4o",
                "api_base": "https://aihubmix.com/v1",
                "api_key": os.environ.get("AIHUBMIX_API_KEY"),
            }
        }
    ]
)

response = router.completion(
    model="my-model",
    messages=[{"role": "user", "content": "Hello"}]
)

print(response.choices[0].message.content)
```

> Beide Modelle teilen sich denselben `model_name`. LiteLLM nutzt Round-Robin zwischen ihnen und führt bei Fehler automatisch ein Failover durch.

***

### 8. Proxy Server deployen

Der Proxy Server ist ein eigenständiges Gateway. Teammitglieder leiten alle Requests darüber, ohne eigene API-Schlüssel zu benötigen.

**Installation**

```bash theme={null}
python3 -m pip install 'litellm[proxy]'
```

**config.yaml erstellen**

```yaml theme={null}
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY

  - model_name: claude-sonnet
    litellm_params:
      model: openai/claude-sonnet-4-6
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY

  - model_name: gemini-flash
    litellm_params:
      model: openai/gemini-2.0-flash
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY
```

**Server starten**

```bash theme={null}
litellm --config config.yaml --port 4000
```

Erfolgreicher Start zeigt:

```text theme={null}
LiteLLM: Proxy running on http://0.0.0.0:4000
```

**Lokalen Server aufrufen**

```python theme={null}
import os
from litellm import completion

response = completion(
    model="gpt-4o",
    api_base="http://localhost:4000",
    api_key="any-string",
    messages=[{"role": "user", "content": "Hello"}]
)

print(response.choices[0].message.content)
```

> Der `api_key` hier kann ein beliebiger String sein. Der eigentliche AiHubMix-Schlüssel wird vom Proxy verwaltet.

***

### 9. Virtuelle Schlüsselverwaltung

Virtuelle Schlüssel ermöglichen es Ihnen, verschiedenen Teammitgliedern oder Projekten unabhängige Schlüssel zuzuweisen, um Zugriff und Nutzung zu steuern, ohne den echten AiHubMix-Schlüssel offenzulegen.

**Voraussetzung: PostgreSQL-Instanz starten**

```bash theme={null}
docker run -d \
  --name litellm-db \
  -e POSTGRES_USER=litellm \
  -e POSTGRES_PASSWORD=litellm \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres
```

**config.yaml aktualisieren**

```yaml theme={null}
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY

  - model_name: claude-sonnet
    litellm_params:
      model: openai/claude-sonnet-4-6
      api_base: https://aihubmix.com/v1
      api_key: os.environ/AIHUBMIX_API_KEY

general_settings:
  master_key: sk-my-master-key
  database_url: postgresql://litellm:litellm@localhost:5432/litellm
```

**Server neu starten**

```bash theme={null}
litellm --config config.yaml --port 4000
```

**Virtuellen Schlüssel erstellen**

```bash theme={null}
curl -X POST http://localhost:4000/key/generate \
  -H "Authorization: Bearer sk-my-master-key" \
  -H "Content-Type: application/json" \
  -d '{
    "key_alias": "team-a",
    "max_budget": 10,
    "models": ["gpt-4o", "claude-sonnet"]
  }'
```

Das Feld `key` in der Antwort enthält den virtuellen Schlüssel, z. B. `sk-xxxxxx`.

**Virtuellen Schlüssel verwenden**

```python theme={null}
from litellm import completion

response = completion(
    model="claude-sonnet",
    api_base="http://localhost:4000",
    api_key="sk-xxxxxx",
    messages=[{"role": "user", "content": "Hello"}]
)

print(response.choices[0].message.content)
```

**Nutzung prüfen**

```bash theme={null}
curl http://localhost:4000/key/info \
  -H "Authorization: Bearer sk-my-master-key" \
  -H "Content-Type: application/json" \
  -d '{"key": "sk-xxxxxx"}'
```

> Jeder virtuelle Schlüssel unterstützt individuelle Modellbeschränkungen, Budgetlimits und Ablaufzeiten – ideal für Multi-Member-Team-Workflows.

***

## Praxisbeispiel: Modellvergleich

Stellen Sie dieselbe Frage gleichzeitig an mehrere Modelle und vergleichen Sie Ausgabequalität, Geschwindigkeit und Tokenverbrauch.

**API-Schlüssel setzen**

```bash theme={null}
export AIHUBMIX_API_KEY="your-key"
```

**Vergleich ausführen**

```python theme={null}
import os
import time
import asyncio
from litellm import acompletion

MODELS = [
    "gpt-5.5",
    "claude-opus-4-7",
    "deepseek-v4-flash",
    "coding-glm-5.1-free",
]

QUESTION = "If you could give a programmer only one piece of advice, what would it be?"

async def ask_model(model, question):
    start = time.time()
    try:
        response = await acompletion(
            model=f"openai/{model}",
            api_base="https://aihubmix.com/v1",
            api_key=os.environ.get("AIHUBMIX_API_KEY"),
            messages=[{"role": "user", "content": question}]
        )
        return {
            "model": model,
            "answer": response.choices[0].message.content.strip(),
            "tokens": response.usage.total_tokens,
            "time": round(time.time() - start, 2),
            "error": None
        }
    except Exception as e:
        return {
            "model": model,
            "answer": None,
            "tokens": 0,
            "time": round(time.time() - start, 2),
            "error": str(e)
        }

async def main():
    print(f"Question: {QUESTION}")
    print("=" * 60)
    tasks = [ask_model(m, QUESTION) for m in MODELS]
    results = await asyncio.gather(*tasks)
    for r in results:
        print(f"\nModel: {r['model']}")
        print(f"Time: {r['time']}s  |  Tokens: {r['tokens']}")
        print("-" * 40)
        if r["error"]:
            print(f"Error: {r['error']}")
        else:
            print(r["answer"])
    print("\n" + "=" * 60)
    print(f"{'Model':<30} {'Time':>8} {'Tokens':>8}")
    print("-" * 50)
    for r in sorted(results, key=lambda x: x["time"]):
        status = f"{r['time']}s" if not r["error"] else "failed"
        print(f"{r['model']:<30} {status:>8} {r['tokens']:>8}")

asyncio.run(main())
```

<Frame>
  <img src="https://mintcdn.com/aihubmix/Duxh_jCgN8ysLDLU/images/image-91.png?fit=max&auto=format&n=Duxh_jCgN8ysLDLU&q=85&s=e733318a7b9fcfc9eb2d12b9790ea60b" alt="Image" width="1500" height="500" data-path="images/image-91.png" />
</Frame>

Zuletzt aktualisiert: 29. April 2026