LLM-Latenz vs. Durchsatz: Wie API-Käufer Geschwindigkeit messen sollten

Bei der Evaluierung von Modell-APIs ist das Verständnis der Kompromisse zwischen LLM-Latenz und Durchsatz entscheidend, um sowohl die Benutzererfahrung als auch die Infrastrukturkosten zu optimieren. Die Latenz misst die Zeit, die ein Modell benötigt, um auf eine Anfrage zu antworten, während der Durchsatz das Volumen der vom System über ein bestimmtes Zeitfenster verarbeiteten oder generierten Tokens misst. Für Entwickler und Ersteller von KI-Produkten erfordert die Optimierung einer Kennzahl oft Kompromisse bei der anderen.

Die Wahl der falschen Geschwindigkeitsmetrik kann zu trägen Benutzeroberflächen oder unnötig hohen API-Rechnungen führen. Diese Analyse bietet einen Rahmen für die Messung dieser Metriken, die Auswahl der richtigen APIs für Ihre spezifischen Workloads und die Implementierung von Optimierungsstrategien.

Wichtige Erkenntnisse

• Time to First Token (TTFT) ist die entscheidende Latenzmetrik für interaktive Anwendungen wie Chat-Schnittstellen und beeinflusst direkt die wahrgenommene Benutzergeschwindigkeit.
• Tokens Per Second (TPS) pro Stream ist die primäre Durchsatzmetrik für Hintergrundverarbeitungsaufgaben, wie z. B. Dokumentenzusammenfassungen oder die Extraktion großer Datenmengen.
• Modellarchitektur und -größe bestimmen die Basisleistung, wobei kleinere Modelle wie DeepSeek V4 Flash oder Gemini 3.5 Flash schnellere Geschwindigkeiten bieten als Flaggschiff-Modelle wie Claude Fable 5 oder GPT-5.5.
• Multi-Provider-Routing ermöglicht es Entwicklern, Latenz oder Durchsatz dynamisch basierend auf der Echtzeit-Leistung der Anbieter zu optimieren.

---

Definition der Kernmetriken: Latenz vs. Durchsatz

Um fundierte Entscheidungen beim Kauf oder Routing von APIs zu treffen, müssen Entwickler „Geschwindigkeit“ in verschiedene, messbare Komponenten unterteilen.

Zeitstrahl einer LLM-API-Anfrage:
[Benutzer sendet Anfrage] 
       │
       ▼ (Netzwerk-Transit + Prompt-Verarbeitung)
[Time to First Token (TTFT)] <--- Kritisch für interaktive UX
       │
       ▼ (Autoregressive Generierung: Tokens pro Sekunde)
[Inter-Token Latency (ITL)]  <--- Bestimmt den Lesekomfort
       │
       ▼ (Generierung abgeschlossen)
[Gesamtlatenz]              <--- Kritisch für blockierende Nicht-Streaming-Aufrufe

1. Time to First Token (TTFT)

TTFT ist die Dauer zwischen dem Senden einer API-Anfrage und dem Empfang des allerersten Tokens der Antwort. Diese Metrik umfasst die Round-Trip-Zeit des Netzwerks, die Prompt-Serialisierung und die Zeit, die das Modell benötigt, um die Eingabe-Tokens zu verarbeiten (Prefill-Phase). Für interaktive Anwendungen ist TTFT die wichtigste Metrik, da sie bestimmt, wie schnell ein Benutzer sieht, dass eine Antwort zu streamen beginnt.

2. Inter-Token Latency (ITL)

ITL ist die durchschnittliche Zeit, die zwischen der Generierung aufeinanderfolgender Tokens während der Streaming-Phase vergeht. Wenn die ITL zu hoch ist, wird der Text langsamer gestreamt, als ein Mensch lesen kann, was zu einer frustrierenden Benutzererfahrung führt. Eine stabile, niedrige ITL sorgt für eine flüssige Textdarstellung.

3. Tokens Per Second (TPS)

TPS repräsentiert den Generierungsdurchsatz des Modells. Er wird als die Gesamtzahl der Ausgabe-Tokens geteilt durch die gesamte Generierungszeit (ohne die Prefill-Phase) berechnet. Bei der Bewertung des Durchsatzes müssen Entwickler zwischen Folgendem unterscheiden:

• Single-User TPS: Die Generierungsgeschwindigkeit eines einzelnen aktiven Streams.
• Systemdurchsatz: Die Gesamtzahl der Tokens, die der API-Anbieter gleichzeitig über alle aktiven Benutzer hinweg verarbeiten kann.

4. Gesamtlatenz

Die Gesamtlatenz ist die vollständige Dauer der API-Anfrage von Anfang bis Ende. Für Nicht-Streaming-Anfragen, wie z. B. strukturierte JSON-Extraktion oder Hintergrundklassifizierung, ist die Gesamtlatenz die primäre zu überwachende Metrik.

---

Die architektonischen Kompromisse: Warum die Geschwindigkeit variiert

Der Kompromiss zwischen LLM-Latenz und Durchsatz wurzelt in der Physik von Transformer-Architekturen und der Speicherbandbreite der Hardware. Während der Prefill-Phase (die die TTFT bestimmt), ist die Berechnung hochgradig parallelisierbar, da der gesamte Eingabe-Prompt auf einmal verarbeitet wird. Diese Phase ist typischerweise rechengebunden (compute-bound).

Während der Generierungsphase (die die TPS bestimmt) generiert das Modell Tokens einzeln nacheinander. Jedes neue Token erfordert das Laden aller Modellgewichte vom High Bandwidth Memory (HBM) in den GPU-SRAM. Dieser autoregressive Prozess ist durch die Speicherbandbreite begrenzt (memory-bandwidth bound).

Aufgrund dieser Einschränkungen müssen Entwickler ihre Modellwahl an ihren primären Leistungsanforderungen ausrichten:

• Flaggschiff-Modelle: Modelle wie Claude Fable 5, Claude Opus 4.8 und GPT-5.5 priorisieren die Tiefe des logischen Schlussfolgerns gegenüber der reinen Geschwindigkeit. Sie verfügen über eine enorme Anzahl an Parametern, was zu einer höheren TTFT und niedrigeren TPS führt.
• Schnelle, kostengünstige Modelle: Modelle wie DeepSeek V4 Flash, Gemini 3.5 Flash und Laguna XS 2.1 sind auf Geschwindigkeit optimiert. Sie nutzen eine geringere Parameteranzahl, spekulative Dekodierung oder destillierte Architekturen, um eine außergewöhnlich niedrige TTFT und hohe TPS zu liefern.

Entwickler können das TokenLab LLM API Leaderboard for Developers konsultieren, um Echtzeit-Geschwindigkeitsmetriken über diese Modellstufen hinweg zu vergleichen.

---

Entscheidungsrahmen: Wann Latenz und wann Durchsatz priorisieren?

Die Priorität zwischen Latenz und Durchsatz hängt vollständig vom Anwendungsfall ab.

Anwendungsfall	Primäre Metrik	Sekundäre Metrik	Empfohlene Modellklasse
Interaktive Chatbots	Time to First Token (TTFT)	Inter-Token Latency (ITL)	Fast Frontier (z. B. Gemini 3.5 Flash)
Coding-Assistenten	TTFT & Single-stream TPS	Gesamtlatenz	Specialized Coding (z. B. Claude Sonnet 5, Kimi K2.7 Code)
Bulk-Datenextraktion	Systemdurchsatz	Kosten pro Aufgabe	Low-Cost Open-Weight (z. B. DeepSeek V4 Flash, GLM-5.2)
Autonome Agenten	Gesamtlatenz (Nicht-Streaming)	TTFT	High-Reasoning Open-Weight (z. B. DeepSeek V4 Pro)
Bild-/Videogenerierung	Gesamtlatenz	Kosten pro Bild	Specialized Media APIs (z. B. Nano Banana 2, Seedance)

Interaktive Anwendungen (Latenz-fokussiert)

Bei konversationellen UIs, Kundensupport-Bots und Live-Suchassistenten sinkt die Benutzerbindung, wenn das System nicht reagiert. Entwickler sollten die Minimierung der TTFT priorisieren. Selbst wenn die gesamte Generierung mehrere Sekunden dauert, hält eine TTFT unter 300 Millisekunden die Benutzer bei der Stange.

Batch-Verarbeitung und Pipelines (Durchsatz-fokussiert)

Für Offline-Aufgaben wie die Verarbeitung Tausender PDF-Rechnungen, das Erstellen täglicher Berichte oder die Durchführung von Batch-Evaluierungen ist die TTFT irrelevant. Das Ziel ist es, das Gesamtvolumen der pro Minute verarbeiteten Tokens zu den niedrigstmöglichen Kosten zu maximieren. Entwickler sollten sich auf den Systemdurchsatz und die Kosteneffizienz konzentrieren. Eine eingehende Analyse der Kostenoptimierung bei der Batch-Verarbeitung finden Sie im TokenLab AI Model Routing Benchmark Cost Per Task.

---

Messung der API-Leistung: Ein praktisches Code-Beispiel

Um TTFT, ITL und TPS genau zu messen, müssen Entwickler Streaming-APIs verwenden und Zeitstempel an bestimmten Punkten im Lebenszyklus der Anfrage aufzeichnen. Unten finden Sie ein ausführbares Python-Skript, das den OpenAI-kompatiblen Client verwendet, um diese Metriken für ein bestimmtes Modell zu messen.

import time
import os
from openai import OpenAI

# Client initialisieren (konfiguriert für OpenRouter oder jeden kompatiblen Anbieter)
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY", "your_api_key_here")
)

def measure_api_performance(model_name: str, prompt: str):
    print(f"Evaluiere Geschwindigkeitsmetriken für: {model_name}")
    
    start_time = time.time()
    response = client.chat.completions.create(
        model=model_name,
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )
    
    ttft = None
    token_timestamps = []
    total_tokens = 0
    
    for chunk in response:
        chunk_time = time.time()
        # Prüfen, ob Textinhalt im Chunk vorhanden ist
        if chunk.choices and chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            # Token-Anzahl schätzen (1 Token ≈ 4 Zeichen für grobe Messung)
            estimated_tokens = max(1, len(content) // 4)
            total_tokens += estimated_tokens
            
            if ttft is None:
                ttft = chunk_time - start_time
                print(f"-> Time to First Token (TTFT): {ttft:.3f} Sekunden")
            
            token_timestamps.append(chunk_time)
            
    end_time = time.time()
    total_duration = end_time - start_time
    generation_time = total_duration - ttft if ttft else total_duration
    
    # Inter-Token Latency (ITL) und Tokens Per Second (TPS) berechnen
    if len(token_timestamps) > 1:
        intervals = [token_timestamps[i] - token_timestamps[i-1] for i in range(1, len(token_timestamps))]
        avg_itl = sum(intervals) / len(intervals)
        tps = total_tokens / generation_time if generation_time > 0 else 0
    else:
        avg_itl = 0
        tps = 0
        
    print(f"-> Gesamtlatenz: {total_duration:.3f} Sekunden")
    print(f"-> Durchschnittliche Inter-Token Latenz (ITL): {avg_itl:.3f} Sekunden")
    print(f"-> Geschätzter Durchsatz (TPS): {tps:.2f} Tokens/Sek.")
    print("-" * 50)

# Beispielanwendung mit einem schnellen, kostengünstigen Modell
if __name__ == "__main__":
    test_prompt = "Schreibe einen 200-Wörter-Aufsatz über die Geschichte der Informatik."
    # Verwendung eines aktuellen Low-Cost-Routing-Modellbeispiels
    measure_api_performance("google/gemini-3.5-flash", test_prompt)

---

Optimierungsstrategien für API-Käufer

Wenn Ihre Messungen ergeben, dass Ihre gewählte API zu langsam oder zu teuer ist, können verschiedene Optimierungsstrategien die Leistung verbessern.

1. Prompt-Optimierung und Reduzierung der Prefill-Phase

Da die Prefill-Phase mit der Größe des Eingabe-Prompts skaliert, verringert eine Reduzierung der Prompt-Länge direkt die TTFT.

• Entfernen Sie redundante Anweisungen.
• Verwenden Sie System-Prompt-Caching, falls vom Anbieter unterstützt. Dies ermöglicht es dem API-Host, den kompilierten Zustand eines langen System-Prompts zwischenzuspeichern, wodurch die Prefill-Berechnung bei nachfolgenden Anfragen umgangen wird.

2. Dynamisches Provider-Routing

Gemäß der Dokumentation zur Anbieterauswahl von OpenRouter kann die Leistung eines Modells erheblich variieren, je nachdem, welcher zugrunde liegende Host (Anbieter) die Anfrage bedient. Einige Anbieter optimieren auf niedrige Latenz, während andere niedrigere Kosten auf Kosten der Geschwindigkeit bieten.

Durch die Nutzung von Routing-Schichten können Entwickler:

• Mehrere Anbieter abfragen, um die niedrigste aktuelle Latenz zu finden.
• Fallback-Pfade einrichten, sodass Anfragen automatisch an eine schnellere Alternative weitergeleitet werden, wenn ein primärer Anbieter einen Latenz-Spike aufweist.
• Anbieter basierend auf spezifischen Leistungsschwellen filtern.

3. Modell-Tiering

Verwenden Sie keine Flaggschiff-Modelle wie Claude Fable 5 oder GPT-5.5 für Aufgaben, die von kleineren Modellen erledigt werden können. Implementieren Sie einen Router, der einfache Anfragen (z. B. Klassifizierung, Formatierung) an DeepSeek V4 Flash oder GLM-5.2 sendet und teure Modelle nur für komplexe logische Schritte reserviert.

---

Einschränkungen von Geschwindigkeits-Benchmarks

Bei der Bewertung von Geschwindigkeitsmetriken sollten Entwickler die folgenden Einschränkungen beachten:

• Netzwerkvarianz: Die API-Latenz hängt stark von der physischen Entfernung zwischen Ihren Anwendungsservern und der Hosting-Region des API-Anbieters ab. Führen Sie Benchmarks immer von Servern aus, die sich in derselben Region wie Ihre Produktionsumgebung befinden.
• Anbieter-Überlastung: Durchsatz und Latenz schwanken im Laufe des Tages je nach globalen Verkehrsmustern. Ein einzelner Benchmark-Lauf repräsentiert nicht die konsistente Produktionsleistung.
• Diskrepanzen bei der Token-Schätzung: Verschiedene Modelle verwenden unterschiedliche Tokenizer. Ein Modell mit höheren TPS ist möglicherweise nicht wirklich schneller, wenn sein Tokenizer Wörter in kleinere, zahlreichere Tokens zerlegt als ein konkurrierendes Modell.

---

Häufig gestellte Fragen

Bedeutet ein höherer Durchsatz (TPS) immer eine schnellere Benutzererfahrung?

Nein. Wenn eine API einen hohen Durchsatz, aber eine schlechte TTFT hat, erlebt der Benutzer eine lange, nicht reagierende Pause, bevor der Text plötzlich auf dem Bildschirm erscheint. Für interaktive Anwendungen ist eine niedrige TTFT kritischer als eine hohe TPS.

Wie beeinflusst Prompt-Caching die Latenz?

Prompt-Caching reduziert die TTFT bei langen Prompts erheblich. Durch das Zwischenspeichern der verarbeiteten Tokens von Systemanweisungen oder Kontextdokumenten überspringt der Anbieter die rechenintensive Prefill-Phase bei nachfolgenden Anfragen, was zu schnelleren Antwortzeiten führt.

Sollte ich für die beste Geschwindigkeit Open-Weight- oder Closed-Source-Modelle wählen?

Das hängt von der Hosting-Infrastruktur ab. Open-Weight-Modelle wie Qwen3.7 Plus, GLM-5.2 oder DeepSeek V4 Pro können auf dedizierter privater Hardware bereitgestellt werden, was es Ihnen ermöglicht, den Durchsatz zu garantieren. Verwaltete Closed-Source-APIs nutzen jedoch oft eine massive, optimierte Infrastruktur, die auf privaten Instanzen nur schwer kosteneffizient zu replizieren ist. Sie können aktuelle Leistungsrankings in den TokenLab Model Rankings vergleichen.

---

Nächste Schritte

Um die Geschwindigkeit und Kosteneffizienz Ihrer Anwendung zu optimieren, beginnen Sie damit, Ihre aktuellen Produktions-Workloads zu messen, indem Sie die oben genannten Streaming-Metriken verwenden.

Bereit, die neuesten Modelle für Ihre Produktions-Pipeline zu evaluieren und zu vergleichen? Starten Sie mit den umfassenden Modell-Rankings von TokenLab, um das optimale Gleichgewicht zwischen Latenz, Durchsatz und Kosten für Ihre Anwendung zu finden.