LiteLLM: Ein Leitfaden mit praktischen Beispielen

Wenn du zwischen verschiedenen LLM-Anbietern wechselst, solltest du nicht deinen ganzen Code neu schreiben müssen. Aber genau das passiert, wenn man heute mit mehreren KI-Diensten arbeitet. Jeder Anbieter hat sein eigenes SDK, seine eigene Authentifizierungsmethode und sein eigenes Antwortformat. LiteLLM löst dieses Problem mit einer einheitlichen Schnittstelle.

In diesem Tutorial erkläre ich die wichtigsten Teile von LiteLLM und zeige dir, wie du mit einfachen API-Aufrufen anfangen und dich bis zu Streaming-Antworten, strukturierten Ausgaben und Kostenverfolgung hocharbeiten kannst.

Was ist LiteLLM?

LiteLLM ist eine Open-Source-Python-Bibliothek, die als universeller Übersetzer für KI-Modelle funktioniert. Anstatt verschiedene APIs für jeden Anbieter zu lernen, nutzt man eine Schnittstelle, die mit über 100 LLM-Diensten verbunden ist.

Das Rahmenwerk besteht aus zwei Hauptteilen. Mit dem Python SDK kannst du Code einmal schreiben und dann mit jedem Anbieter ausführen. Der Proxy-Server ist wie ein zentraler Zugang für Teams und Firmen, die KI-Dienste in großem Maßstab verwalten müssen.

LiteLLM bietet dir diese zusätzlichen Vorteile:

• Integrierte Kostenverfolgungs: Sieh dir die Ausgaben aller Anbieter auf einem Dashboard an, statt mehrere Abrechnungssysteme zu checken.
• Automatische Failover-: Wenn ein Anbieter ausfällt oder an seine Grenzen stößt, probiert LiteLLM automatisch deine Backup-Optionen aus.
• Selbsthosting-Option: Wenn du Datenschutz oder Compliance brauchst, lass alles auf deinen eigenen Servern laufen.

Beachte, dass OpenRouter einen ähnlichen einheitlichen Zugang zu mehreren LLMs bietet, allerdings mit unterschiedlichen Preisen und Funktionen.

Der Proxy-Server hat jetzt Ausgabenlimits pro Team, zeigt die Nutzung über alle Projekte hinweg an und hat eine zentrale Verwaltung für API-Schlüssel. Die ganze Konfiguration läuft über einfache YAML-Dateien.

LiteLLM passt super für verschiedene Arten von Nutzern:

• Einzelne Entwickler , die mehrere Modelle testen wollen, ohne überall Konten einzurichten
• Kleine Teams , die Kostenübersicht brauchen und nicht an einen Anbieter gebunden sein wollen
• Große Unternehmen die eine zentrale Verwaltung, Budgetkontrolle und detaillierte Nutzungsanalysen brauchen

Die Bibliothek hat eine MIT-Lizenz und ist komplett Open Source. Du kannst den Code anschauen, ihn nach deinen Bedürfnissen anpassen oder zum Projekt beitragen.

Jetzt, wo du weißt, was LiteLLM kann, zeig ich dir, wie du deine Umgebung einrichtest.

Was du brauchen solltest

Bevor du LiteLLM nutzen kannst, musst du ein paar Sachen einrichten. Wenn du schon mal mit KI-Modellen gearbeitet hast, hast du das meiste davon wahrscheinlich schon erledigt.

Python-Umgebung

Du brauchst Python 3.7 oder neuer. Die meisten Systeme haben das heutzutage, aber du kannst deine Version mit folgendem Befehl checken:

import sys
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

Installation des Pakets

Installier LiteLLM und python-dotenv, um die Umgebungsvariablen zu verwalten:

uv add litellm python-dotenv
# or with pip: pip install litellm python-dotenv

API-Schlüssel

Du brauchst API-Schlüssel von den Anbietern, die du nutzen willst. Für dieses Tutorial nehmen wir zwei Modelle:

• OpenAI-API-Schlüssel: Du kannst einen Schlüssel auf platform.openai.com bekommen (für GPT-5).
• Anthropic-API-Schlüssel: Du kannst dir einen Schlüssel auf console.anthropic.com holen (für Claude Sonnet 4).

Speicher diese in einer Datei namens „ .env ” in deinem Projektverzeichnis:

OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Umgebungscheck

Führ dieses Skript aus, um deine Einstellungen zu checken:

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Check Python version
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

# Check LiteLLM
try:
   import litellm
   print("✓ LiteLLM installed")
except ImportError:
   print("✗ LiteLLM not installed")

# Check API keys
openai_key = os.getenv("OPENAI_API_KEY")
anthropic_key = os.getenv("ANTHROPIC_API_KEY")

if openai_key:
   print(f"✓ OpenAI API key found")
else:
   print("✗ OpenAI API key not found")

if anthropic_key:
   print(f"✓ Anthropic API key found")
else:
   print("✗ Anthropic API key not found")

Python version: 3.11
✓ LiteLLM installed
✓ OpenAI API key found
✓ Anthropic API key found

Wenn du nur grüne Häkchen siehst, kannst du loslegen. Wenn irgendwelche Prüfungen fehlschlagen, check mal, ob du die Pakete installiert und deine API-Schlüssel zur .env-Datei hinzugefügt hast.

Deinen ersten API-Aufruf mit LiteLLM machen

LiteLLM nutzt die gleiche Schnittstelle, die du vielleicht schon von OpenAI kennst, aber es funktioniert mit jedem Anbieter.

Grundeinrichtung

Fang mit diesen Importen an:

import litellm
from dotenv import load_dotenv

# Load your API keys
load_dotenv()

Eine einfache Anfrage an GPT-5 läuft so ab: Du legst deine Nachrichten fest, rufst litellm.completion() auf und kriegst die Antwort.

messages = [
   {"role": "user", "content": "Write a simple Python function that adds two numbers"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

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

def add(a, b):
   """Return the sum of a and b."""
   return a + b

Du hast gerade GPT-5 über LiteLLM aufgerufen. Das Antwortobjekt folgt dem Format von OpenAI. Wenn du also schon mal deren API benutzt hast, wird dir das bekannt vorkommen. Du solltest vielleicht nachsehen, welches Modell tatsächlich geantwortet hat, und die Token-Verwendung überprüfen:

print(f"Model used: {response.model}")
print(f"Response ID: {response.id}")
print(f"Total tokens: {response.usage.total_tokens}")

Model used: gpt-5-2025-08-07
Response ID: chatcmpl-CIbZWUDE1amW2vHtHDmieTX6hnZUq
Total tokens: 557

Anbieter wechseln

Die wahre Stärke von LiteLLM zeigt sich beim Anbieterwechsel. Willst du lieber Claude Sonnet 4 ausprobieren? Ändere einen Parameter:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages
)

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

Here's a simple Python function that adds two numbers:

def add_numbers(a, b):
   """
   Adds two numbers and returns the result.
  
   Args:
       a: First number
       b: Second number
  
   Returns:
       The sum of a and b
   """
   return a + b

# Example usage:
result = add_numbers(5, 3)
print(result)  # Output: 8

This function:
- Takes two parameters a and b
- Returns their sum using the + operator
- Works with integers, floats, and even negative numbers
- Includes a docstring to explain what the function does

Gleiche Code-Struktur, anderer Anbieter. Claude gibt eine viel ausführlichere Antwort mit Unterlagen und Beispielen, während GPT-5 knapper war.

Grundlegende Fehlerbehandlung

Füge eine Fehlerbehandlung für den Fall hinzu, dass etwas schiefgeht:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages
   )
   print(response.choices[0].message.content)
except Exception as e:
   print(f"API call failed: {e}")

Dieses Muster fängt häufige Probleme wie ungültige API-Schlüssel, Netzwerkprobleme oder die Nichtverfügbarkeit von Modellen ab.

Was kommt als Nächstes?

Jetzt kennst du das grundlegende Schema für die Verwendung von LiteLLM mit jedem Anbieter. Die Dokumentation „Erste Schritte“ hat mehr Infos zu den unterstützten Modellen und Parametern, und die Referenz zur Vervollständigungsfunktion zeigt alle verfügbaren Optionen.

Für die Entwicklung von Produktionsanwendungen solltest du auch die Best Practices für das API-Design befolgen, um zuverlässige, leistungsstarke Systeme zu erstellen.

Anbieterwechsel und Fallbacks

Das Fallback-System von LiteLLM kümmert sich automatisch um Ausfälle von Anbietern, sodass deine Nutzer keine Fehlermeldungen sehen. Wenn du echte Anwendungen entwickelst, brauchst du Notfallpläne, die ohne zusätzlichen Code deinerseits funktionieren.

Grundlegende Fallback-Einrichtung

Um einen Fallback einzurichten, füge deinem Completion-Aufruf eine Liste „ fallbacks “ hinzu:

messages = [
   {"role": "user", "content": "Explain what a Python decorator is in one sentence"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514"]
)

print(f"Response: {response.choices[0].message.content}")
print(f"Model used: {response.model}")

Response: A Python decorator is a callable that wraps another function or class to augment its behavior and returns it, applied with the @ syntax so you can add reusable functionality without changing the original code.
Model used: gpt-5-2025-08-07

Wenn GPT-5 nicht klappt, probiert LiteLLM automatisch Claude Sonnet 4 aus. Die Leute kriegen auf jeden Fall eine Antwort.

Fallback-Ketten erstellen

Du kannst mehrere Anbieter miteinander verbinden, um die Zuverlässigkeit zu verbessern. Mit denselben Nachrichten wie vorher:

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514", "gpt-3.5-turbo"]
)

print(f"Model used: {response.model}")

Model used: gpt-5-2025-08-07

LiteLLM probiert die Modelle der Reihe nach aus. Wenn der Primärserver nicht klappt, probiert er den ersten Ausweichserver. Wenn das nicht klappt, probiert es das zweite. Mehrere Schutzschichten.

Wiederholungsversuche hinzufügen

Kombiniere Fallbacks mit Wiederholungsversuchen für noch mehr Zuverlässigkeit:

response = litellm.completion(
   model="gpt-5",
   messages=messages,  # Same messages as before
   num_retries=2
)

Versucht dasselbe Modell zweimal, bevor auf Fallbacks zurückgegriffen wird. Gut bei vorübergehenden Netzwerkproblemen oder plötzlichen Spitzen bei der Datenrate.

Fallbacks kümmern sich automatisch um die meisten Fehler, aber du solltest trotzdem Fälle abfangen, in denen alle Modelle versagen:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages,  # Same messages as before
       fallbacks=["anthropic/claude-sonnet-4-20250514"],
       num_retries=2
   )
   return response.choices[0].message.content
except Exception as e:
   # All models failed - handle gracefully
   return "Sorry, I'm having trouble right now. Please try again."

Selbst wenn die Anbieter super funktionieren, haben die Nutzer immer noch ein anderes Problem: nervige Wartezeiten. Jemand klickt in deiner App auf „Senden“ und sieht mehrere Sekunden lang nichts. Die fragen sich, ob was kaputt gegangen ist.

Streaming für Echtzeit-Antworten

Die meisten Antworten von KI-APIs kommen als ein kompletter Block, so wie beim Herunterladen einer Datei. Die Nutzer warten ohne Rückmeldung, bis die ganze Antwort fertig ist. Streaming ändert das, indem es den Text Wort für Wort anzeigt, während er erstellt wird.

Warum Streaming die Nutzererfahrung verändert

Anstatt auf die komplette Antwort zu warten, wird der Text angezeigt, sobald die KI ihn generiert. Schau dir den Unterschied an:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "What is Python in one sentence?"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   stream=True
)

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

Python is a high-level, interpreted, dynamically typed, general-purpose programming language known for its readability and vast ecosystem, used across web development, data science, automation, scripting, and more.

Der Text wird nach und nach angezeigt, statt auf einmal (wenn du den obigen Snippet auf deinem Rechner ausführst). Die Nutzer sehen sofort den Fortschritt, was viel reaktionsschneller wirkt, als auf einen Ladekreis zu starren.

Wie Streaming wirklich funktioniert

Das klappt auf Chunk-Ebene. Statt einer großen Antwort kriegst du viele kleine Teile, die man Deltas nennt. Manchmal sind Chunks leer, also solltest du sie aus Sicherheitsgründen richtig behandeln:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=[{"role": "user", "content": "Define JavaScript in exactly two sentences"}],
   stream=True
)

for chunk in response:
   if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
       print(f"'{chunk.choices[0].delta.content}'", end=" ")

'JavaScript is a high' '-level, interpreted programming language primarily used for creating' ' interactive and dynamic content on web pages, running' ' in web browsers to manip' 'ulate HTML elements, handle user events' ', and communicate with servers.' ' Originally designed for client-side web development, JavaScript has evolve' 'd into a versatile language that can also' ' be used for server-side development, mobile applications' ', and desktop software through various runtime' ' environments like Node.js.'

Streaming wiederverwendbar machen

Für echte Anwendungen solltest du die komplette Antwort erfassen und gleichzeitig die Streaming-Ausgabe anzeigen. Hier ist eine Funktion, die das macht:

def stream_and_capture(model, messages):
   """Stream response while capturing the complete text"""
   response = litellm.completion(
       model=model,
       messages=messages,
       stream=True
   )
  
   full_response = ""
   for chunk in response:
       if chunk.choices[0].delta.content:
           content = chunk.choices[0].delta.content
           print(content, end="", flush=True)
           full_response += content
  
   print()  # New line after response
   return full_response

# Test it
messages = [{"role": "user", "content": "Define APIs in 2 sentences max"}]
result = stream_and_capture("gpt-5", messages)

APIs (Application Programming Interfaces) are standardized contracts, often exposed as endpoints, that specify how software components or services can communicate, including the allowed operations, inputs, and outputs. They let developers access functionality or data without knowing the underlying implementation, enabling modular, interoperable systems.

Der Parameter „ end="" ” verhindert Zeilenumbrüche zwischen den Blöcken. „ flush=True ” sorgt dafür, dass die Daten sofort angezeigt werden, statt sie zu puffern.

Streaming mit Fallbacks

Du kannst Streaming auch mit dem Fallback-System kombinieren, um die Zuverlässigkeit zu verbessern:

response = litellm.completion(
   model="gpt-5",
   messages=[{"role": "user", "content": "Define machine learning in one sentence"}],
   fallbacks=["anthropic/claude-sonnet-4-20250514"],
   stream=True
)

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

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data to make predictions or decisions without being explicitly programmed.

Sofortiges Feedback und automatischer Anbieterwechsel, wenn das Hauptmodell nicht funktioniert.

Streaming gibt den Nutzern sofortiges Feedback, aber beim Erstellen echter Anwendungen gibt's noch ein anderes Problem. Sobald dieser Text da ist, muss dein Code damit klarkommen. Du kannst Daten extrahieren, Infos in Datenbanken speichern oder Werte an andere Funktionen weitergeben. Aber das Parsen von Textantworten ist kompliziert und geht schnell schief, wenn sich das Format ändert.

Strukturierte Ausgaben nutzen

Hier ist, was wirklich passiert: Du entwickelst eine App, die Kundenfeedback analysiert. Deine KI gibt einen Text wie „Die Stimmung ist positiv mit einer Zuversicht von 0,85 und den wichtigsten Stichwörtern: reaktionsschnell, hilfreich, schnell.“ zurück. Du schreibst reguläre Ausdrücke, um den Konfidenzwert und die Schlüsselwörter zu extrahieren. Beim Testen läuft alles wie es soll.

Dann ändert die KI ihr Antwortformat ein bisschen zu „Stimmung: positiv (Zuversicht: 0,85). Stichworte sind reaktionsschnell, hilfsbereit und schnell. Dein regulärer Ausdruck funktioniert nicht. Deine Datenpipeline funktioniert nicht mehr. Die Berichte zur Kundenstimmung zeigen leere Werte statt Punktzahlen. Dein Dashboard stürzt ab. Du verbringst Stunden damit, Parsing-Code zu reparieren, der gestern noch funktioniert hat.

Strukturierte Ausgaben umgehen dieses Problem, indem sie Daten von Anfang an in vorhersehbaren Formaten zurückgeben.

JSON statt Text bekommen

LiteLLM kann JSON statt reinem Text zurücksenden. Du sagst ihm über deine Eingabeaufforderung, welche Struktur du haben willst, und es kommt richtig formatiert zurück:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Describe Python as a programming language. Return as JSON with fields: language, difficulty, description"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

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

{
 "language": "Python",
 "difficulty": "Beginner-friendly (easy to learn, moderate to master)",
 "description": "Python is a high-level, interpreted, dynamically typed, general-purpose programming language focused on readability and developer productivity. It supports multiple paradigms (object-oriented, functional, procedural), uses indentation for block structure, and includes a large standard library with an extensive third-party ecosystem (PyPI). Common uses include web development, data science, machine learning, automation/scripting, scientific computing, and DevOps. While not the fastest for CPU-bound tasks, it integrates well with C/C++ and accelerators, and runs cross-platform."
}

Dieser strukturierte Ansatz vermeidet die üblichen Probleme beim Parsen. Anstatt Text zu durchsuchen, bekommst du gültiges JSON mit genau den Feldern zurück, die du angefordert hast. Keine Probleme beim Parsen, keine Überraschungen beim Format.

Arbeiten mit den JSON-Daten

Rohe JSON-Zeichenfolgen sind erst dann nützlich, wenn du sie in Python-Objekte umwandelst, mit denen deine Anwendung arbeiten kann. Du musst diese Zeichenfolge in Python-Objekte umwandeln, die du tatsächlich verwenden kannst:

import json

messages = [{"role": "user", "content": "Describe JavaScript in 2 sentences. Return as JSON with fields: name, paradigm, use_cases (array of exactly 3 items)"}]

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse the JSON response
data = json.loads(response.choices[0].message.content)
print(f"Language: {data['name']}")
print(f"Paradigm: {data['paradigm']}")
print(f"Use cases: {', '.join(data['use_cases'])}")

Language: JavaScript
Paradigm: multi-paradigm (object-oriented, functional, event-driven)
Use cases: web development and browser scripting, server-side development with Node.js, mobile app development with frameworks like React Native

Jetzt, wo du strukturierte Daten hast, kannst du sie direkt an andere Funktionen weitergeben, in Datenbanken speichern oder in deiner Benutzeroberfläche anzeigen, ohne den Text bearbeiten zu müssen. Bei der Datenanalyse können Tools wie Pandas AI direkt mit diesen strukturierten Ergebnissen arbeiten, um Erkenntnisse zu gewinnen.

Typensicherheit mit Pydantic hinzufügen

JSON-Parsing findet Syntaxfehler, aber falsche Datentypen oder fehlende Felder sind andere Probleme. Pydantic -Modelle lösen das, indem sie deine Datenstruktur überprüfen und Probleme erkennen, bevor sie deine Anwendung kaputt machen:

from pydantic import BaseModel
import json

class ProgrammingLanguage(BaseModel):
   name: str
   paradigm: str
   use_cases: list[str]

messages = [{"role": "user", "content": "Describe CSS briefly. Return as JSON with fields: name, paradigm, use_cases (array of 3 items)"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse and validate with Pydantic
data = json.loads(response.choices[0].message.content)
language = ProgrammingLanguage(**data)

print(f"Validated data: {language.name} - {language.paradigm}")
print(f"Use cases: {language.use_cases}")

Validated data: CSS (Cascading Style Sheets) - Declarative, rule-based stylesheet language for describing the presentation of structured documents.
Use cases: ['Styling layout, colors, and typography of web pages', 'Responsive design across devices and viewports', 'Animations, transitions, and visual effects']

Pydantic checkt automatisch, ob „ name ” und „ paradigm ” Strings sind und ob „ use_cases ” eine Liste von Strings ist. Wenn die KI falsche Typen zurückgibt oder ein Pflichtfeld vergisst, bekommst du sofort eine klare Fehlermeldung und vermeidest später mysteriöse Bugs.

Umgang mit JSON-Fehlern

Das Parsen von JSON kann schiefgehen, wenn die KI fehlerhaften JSON- oder Nicht-JSON-Text zurücksendet. Füge eine grundlegende Fehlerbehandlung hinzu:

import json

messages = [{"role": "user", "content": "Summarize machine learning in 1 sentence. Return as JSON with topic and summary fields"}]

try:
   response = litellm.completion(
       model="anthropic/claude-sonnet-4-20250514",
       messages=messages,
       response_format={"type": "json_object"}
   )
  
   data = json.loads(response.choices[0].message.content)
   print(f"Topic: {data['topic']}")
   print(f"Summary: {data['summary']}")
  
except json.JSONDecodeError:
   print("Invalid JSON returned")
except Exception as e:
   print(f"Request failed: {e}")

Topic: machine learning
Summary: Machine learning is a subset of artificial intelligence that allows computers to learn and make predictions or decisions from data without being explicitly programmed for each specific task.

Strukturierte Ausgaben machen Schluss mit dem chaotischen Parsen von Text und sorgen stattdessen für übersichtliche Datenstrukturen. Du kannst den JSON-Modus mit Fallbacks kombinieren, genau wie bei normalen Vervollständigungen.

Strukturierte Ausgaben liefern dir saubere, vorhersehbare Daten, die deine Parsing-Logik nicht durcheinanderbringen. Aber es gibt noch ein anderes Problem, das auftaucht, wenn man vom Prototyp zur Produktion übergeht: die Kosten. Jeder API-Aufruf kostet Geld, und diese Kosten können dich überraschen.

Kostenverfolgung

Das passiert: Dein Prototyp läuft super bei Tests mit 50 API-Aufrufen pro Tag. Du gibst ungefähr 2 Dollar pro Woche aus. Alles sieht gut aus. Du startest die Produktion und bekommst 500 Nutzer. Jetzt machst du täglich 5.000 API-Aufrufe. Deine monatliche Rechnung springt von 8 Dollar auf 800 Dollar.

Ohne Kostenverfolgung hattest du keine Warnung. Man kann nicht sagen, welche Funktionen am meisten kosten, welche Modelle teurer sind oder wie man das Wachstum budgetieren soll. Du merkst den Anstieg der Rechnung erst Wochen später, wenn du die Kreditkartenabrechnung bekommst.

LiteLLM behält den Überblick über deine Ausgaben bei allen Anbietern.

Verwendung von Token verstehen

Jede KI-Antwort hat detaillierte Infos zur Nutzung, die genau zeigen, wofür du bezahlst:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Explain what a REST API is in two sentences"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(f"Response: {response.choices[0].message.content}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

Response: A REST API is a web service that follows the Representational State Transfer architectural style, exposing resources identified by URLs and manipulated with HTTP methods like GET, POST, PUT, and DELETE. It uses stateless client-server communication, cacheability, and uniform representations (often JSON) to support scalable, decoupled interactions.
Prompt tokens: 15
Completion tokens: 201
Total tokens: 216

Eingabetoken sind deine Eingabeaufforderung, Ausgabetoken sind die Antwort der KI. Verschiedene Anbieter verlangen unterschiedliche Preise für jede Art.

Automatische Kostenberechnung

Die bloße Anzahl der Token sagt dir nichts über den Dollarbetrag aus. LiteLLM rechnet die tatsächlichen Kosten für dich aus:

# Get the cost for a completed response
cost = litellm.completion_cost(completion_response=response)
print(f"Total cost: ${cost:.4f}")
Total cost: $0.0020

Die Preisdatenbank von LiteLLM rechnet Token anhand deines Modells in Dollar um.

Manuelle Kostenberechnungen

Manchmal willst du die Kosten abschätzen, bevor du anrufst, oder die Kosten für einen Text berechnen, den du schon hast:

# Calculate cost without making an API call
prompt_text = "Explain machine learning"
completion_text = "Machine learning is a method of data analysis that automates analytical model building."

estimated_cost = litellm.completion_cost(
   model="anthropic/claude-sonnet-4-20250514",
   prompt=prompt_text,
   completion=completion_text
)

print(f"Estimated cost: ${estimated_cost:.4f}")

Estimated cost: $0.0002

Das ist praktisch, wenn du dein Budget planen und verschiedene Modelle vergleichen willst.

Mehrere API-Aufrufe verfolgen

Für Apps, die viele API-Aufrufe machen, kannst du die Gesamtkosten im Auge behalten:

total_cost = 0.0

conversation = [
   "What is Python?",
   "How do you install Python packages?",
   "What are virtual environments?"
]

for i, question in enumerate(conversation):
   response = litellm.completion(
       model="gpt-5",
       messages=[{"role": "user", "content": question}]
   )
  
   call_cost = litellm.completion_cost(completion_response=response)
   total_cost += call_cost
  
   print(f"Call {i+1}: ${call_cost:.4f}")

print(f"Total cost: ${total_cost:.4f}")

Call 1: $0.0057
Call 2: $0.0134
Call 3: $0.0102
Total cost: $0.0292

Mit der Kostenverfolgung kannst du besser entscheiden, welche Modelle du nutzen solltest, und überraschende Rechnungen vermeiden. Schau dir genau an, was jeder API-Aufruf kostet, und vergleiche die Anbieter.

Fazit

Jetzt hast du die Tools, um KI-Anwendungen zu entwickeln, ohne an einen bestimmten Anbieter gebunden zu sein. Du hast die grundlegenden API-Aufrufe, automatische Fallbacks, Streaming-Antworten, strukturierte Ausgaben und die Kostenverfolgung kennengelernt.

So kannst du für jede Aufgabe die besten Modelle auswählen. Wechsel einfach den Anbieter, richte automatische Fallbacks ein und behalte die Kosten im Blick. Wenn es bessere Modelle gibt, kannst du sie nutzen, ohne den Code neu schreiben zu müssen.