AiHubMix Documentation Hub

LiteLLM-Übersicht

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

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:

brew install python

Prüfen:

python3 --version

Windows Laden Sie den Installer von python.org/downloads herunter. Aktivieren Sie während der Installation „Add Python to PATH”. Prüfen:

python --version

Linux (Ubuntu/Debian)

sudo apt update
sudo apt install python3 python3-pip

pip

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

pip --version
# oder
pip3 --version

Falls nicht vorhanden, manuell installieren:

# 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:

python3 -m pip install litellm

Installation überprüfen:

python3 -m pip show litellm

Optionale Abhängigkeiten

Manche Anbieter benötigen zusätzliche Pakete:

# 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:

pip install 'litellm[proxy]'

Docker (optional)

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-Dashboard und erstellen Sie einen API-Schlüssel.

Umgebungsvariable setzen

export AIHUBMIX_API_KEY="your-aihubmix-key"

Erster Aufruf

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:

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:

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:

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:

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:

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:

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:

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:

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

python3 -m pip install 'litellm[proxy]'

config.yaml erstellen

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

litellm --config config.yaml --port 4000

Erfolgreicher Start zeigt:

LiteLLM: Proxy running on http://0.0.0.0:4000

Lokalen Server aufrufen

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

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

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

litellm --config config.yaml --port 4000

Virtuellen Schlüssel erstellen

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

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

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

export AIHUBMIX_API_KEY="your-key"

Vergleich ausführen

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())

Zuletzt aktualisiert: 29. April 2026

Documentation Index

​LiteLLM-Übersicht

​Zwei Verwendungsarten

​Kernfähigkeiten

​Installation

​Voraussetzungen

​pip

​LiteLLM installieren

​Optionale Abhängigkeiten

​Proxy Server installieren

​Docker (optional)

​API-Schlüssel konfigurieren und ersten Aufruf machen

​AiHubMix-API-Schlüssel besorgen

​Umgebungsvariable setzen

​Erster Aufruf

​Grundlegende Verwendung

​1. Modellwechsel

​2. Streaming

​3. Multi-Turn-Konversation

​4. Asynchrone Aufrufe

​5. Timeout und Retry

​6. Tokenverbrauch und Kosten-Tracking

​7. Load Balancing und Failover

​8. Proxy Server deployen

​9. Virtuelle Schlüsselverwaltung

​Praxisbeispiel: Modellvergleich