LiteLLM - Einheitliches API-Gateway für große Sprachmodelle

Projektübersicht

LiteLLM ist ein Open-Source-Python-SDK und Proxy-Server (LLM-Gateway), das es ermöglicht, über 100 APIs großer Sprachmodelle im OpenAI-Format aufzurufen, darunter die wichtigsten Anbieter wie Bedrock, Azure, OpenAI, VertexAI, Cohere, Anthropic, Sagemaker, HuggingFace, Replicate, Groq usw.

GitHub-Adresse: https://github.com/BerriAI/litellm

Kernfunktionen

1. Einheitliches API-Format

• Standardisierung des Eingabeformats: Konvertierung aller Anbietereingaben in ein einheitliches Format
• Konsistente Ausgabeformate: Textantworten sind immer unter ['choices'][0]['message']['content'] verfügbar
• Unterstützung mehrerer Endpunkte: Unterstützung von Completion-, Embedding- und Image_Generation-Endpunkten

2. Hochverfügbarkeitsgarantie

• Wiederholungs-/Fallback-Logik: Unterstützung automatischer Wiederholungen und Fallbacks zwischen mehreren Bereitstellungen (z. B. Azure/OpenAI)
• Routing-Funktion: Intelligentes Routing zum besten verfügbaren Modell
• Lastverteilung: Verteilung der Anfrage-Last auf mehrere Bereitstellungen

3. Kosten- und Zugriffskontrolle

• Budgetverwaltung: Festlegung von Budgetbeschränkungen nach Projekt, API-Schlüssel, Modell
• Ratenbegrenzung: Verhinderung übermäßiger API-Aufrufe
• Nutzungsverfolgung: Detaillierte Aufrufstatistiken und Kostenanalyse

Hauptmerkmale

Python SDK-Nutzungsbeispiele

Basisaufruf

from litellm import completion
import os


os.environ["OPENAI_API_KEY"] = "your-openai-key"
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key"

messages = [{"content": "Hello, how are you?", "role": "user"}]

# OpenAI
response = completion(model="openai/gpt-4o", messages=messages)

# Anthropic
response = completion(model="anthropic/claude-3-sonnet-20240229", messages=messages)

Unterstützung asynchroner Aufrufe

from litellm import acompletion
import asyncio

async def test_get_response():
    user_message = "Hello, how are you?"
    messages = [{"content": user_message, "role": "user"}]
    response = await acompletion(model="openai/gpt-4o", messages=messages)
    return response

response = asyncio.run(test_get_response())

Streaming-Antwort

from litellm import completion

response = completion(model="openai/gpt-4o", messages=messages, stream=True)
for part in response:
    print(part.choices[0].delta.content or "")

Proxy-Server-Funktion

Schnellstart

pip install 'litellm[proxy]'
litellm --model huggingface/bigcode/starcoder
# INFO: Proxy running on http://0.0.0.0:4000

Client-Aufruf

import openai

client = openai.OpenAI(
    api_key="anything",
    base_url="http://0.0.0.0:4000"
)

response = client.chat.completions.create(
    model="gpt-3.5-turbo", 
    messages=[{
        "role": "user",
        "content": "this is a test request, write a short poem"
    }]
)

Unterstützte Anbieter

LiteLLM unterstützt über 30 wichtige LLM-Anbieter, darunter:

Mainstream-Cloud-Anbieter

• OpenAI - GPT-Serie Modelle
• Azure - Azure OpenAI Service
• AWS - Bedrock und SageMaker
• Google - Vertex AI, PaLM, Gemini
• Anthropic - Claude-Serie Modelle

Open-Source- und professionelle Plattformen

• HuggingFace - Open-Source-Modellhosting
• Replicate - Modell-API-Service
• Together AI - Open-Source-Modellinferenz
• Groq - Hochgeschwindigkeits-Inferenzchip
• Ollama - Lokaler Modellbetrieb

Plattformen mit besonderen Funktionen

• Cohere - NLP für Unternehmen
• AI21 - Jurassic-Modelle
• Perplexity - Sucherweiterte Generierung
• DeepInfra - Hochleistungs-Inferenz

Beobachtbarkeit und Protokollierung

LiteLLM bietet integrierte Unterstützung für verschiedene Überwachungs- und Protokollierungsplattformen:

import litellm
import os


os.environ["LUNARY_PUBLIC_KEY"] = "your-lunary-public-key"
os.environ["HELICONE_API_KEY"] = "your-helicone-auth-key"
os.environ["LANGFUSE_PUBLIC_KEY"] = "your-langfuse-public-key"


litellm.success_callback = [
    "lunary", "mlflow", "langfuse", 
    "athina", "helicone"
]


response = completion(
    model="openai/gpt-4o", 
    messages=[{"role": "user", "content": "Hi 👋"}]
)

Unterstützte Überwachungsplattformen:

• Lunary - LLM-Anwendungsüberwachung
• MLflow - Verfolgung von Machine-Learning-Experimenten
• Langfuse - LLM-Anwendungsverfolgung
• Helicone - API-Aufrufüberwachung
• Athina - KI-Anwendungsbewertung

Enterprise-Funktionen

Schlüsselverwaltungssystem

curl 'http://0.0.0.0:4000/key/generate' \
  --header 'Authorization: Bearer sk-1234' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "models": ["gpt-3.5-turbo", "gpt-4", "claude-2"], 
    "duration": "20m",
    "metadata": {
      "user": "user@company.com", 
      "team": "core-infra"
    }
  }'

Docker-Bereitstellung

git clone https://github.com/BerriAI/litellm
cd litellm


echo 'LITELLM_MASTER_KEY="sk-1234"' > .env
echo 'LITELLM_SALT_KEY="your-salt-key"' > .env


docker-compose up

Web-Management-Oberfläche

• Zugriff auf /ui für eine visuelle Management-Oberfläche
• Festlegung von Budgets und Ratenbegrenzungen für mehrere Projekte
• Echtzeitüberwachung der API-Nutzung
• Benutzer- und Teamverwaltung

Technische Spezifikationen

Systemanforderungen

• Python-Version: Benötigt Python 3.7+
• Abhängigkeitsanforderungen:
  • openai>=1.0.0 (v1.0.0+ erforderlich)
  • pydantic>=2.0.0 (v1.40.14+ erforderlich)

Codequalitätsstandards

• Codestil: Befolgt den Google Python Style Guide
• Formatierungswerkzeuge: Verwendung von Black und isort
• Typüberprüfung: MyPy und Pyright
• Codeüberprüfung: Ruff für Lint-Prüfungen

Stabilitätsgarantie

• Stabile Version: Verwendung von Docker-Images mit dem -stable-Tag
• Lasttests: Durchführung von 12-stündigen Lasttests vor der Veröffentlichung
• Kontinuierliche Integration: Vollständiger CI/CD-Prozess

Kommerzielle Unterstützung

Enterprise-Funktionen

• Erweiterte Sicherheitsfunktionen: Single Sign-On (SSO)-Integration
• Professioneller Support: Dedizierter Discord- und Slack-Support
• Benutzerdefinierte Integration: Kundenspezifische LLM-Anbieterintegration
• SLA-Garantie: Service Level Agreement
• Funktionspriorität: Priorisierte Entwicklung von Funktionen für Unternehmensanforderungen

Community-Support

• GitHub Issues: Funktionsanfragen und Problemberichte
• Discord-Community: Echtzeit-Austausch und Support
• Dokumentationsverbesserung: Detaillierte API-Dokumentation und Tutorials

Anwendungsfälle

1. Multi-Cloud-LLM-Bereitstellung

• Vermeidung von Anbieterbindung
• Realisierung plattformübergreifender Modellaufrufe
• Reduzierung der Migrationskosten

2. Kostenoptimierung

• Intelligentes Routing zum günstigsten verfügbaren Modell
• Budgetkontrolle und Nutzungsüberwachung
• Optimierung von Batch-API-Aufrufen

3. Hochverfügbarkeitsarchitektur

• Automatisches Failover
• Lastverteilung
• Unterstützung für Multi-Region-Bereitstellungen

4. Steigerung der Entwicklungseffizienz

• Einheitliche API-Schnittstelle
• Vereinfachter Modellwechsel
• Umfangreiche SDK-Unterstützung

Installation und Schnellstart

Basisinstallation

pip install litellm

Proxy-Server-Installation

pip install 'litellm[proxy]'

Entwicklungsumgebung einrichten

git clone https://github.com/BerriAI/litellm
cd litellm


python -m venv .venv
source .venv/bin/activate


pip install -e ".[all]"


uvicorn litellm.proxy.proxy_server:app --host localhost --port 4000 --reload

Zusammenfassung

LiteLLM wird bereits von namhaften Unternehmen wie Rocket Money, Samsara, Lemonade und Adobe eingesetzt. Durch die Bereitstellung einer einheitlichen API-Schnittstelle, leistungsstarker Routing-Funktionen und Enterprise-Management-Funktionen vereinfacht es die Komplexität der Verwaltung von Multi-LLM-Umgebungen erheblich und ist die ideale Wahl für die moderne KI-Anwendungsentwicklung.