BroadRouter

LLM-Latenz: TTFT vs. Tokens pro Sekunde vs. End-to-End-Zeit

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht · Aktualisiert

Time to First Token (TTFT) ist die Wartezeit bis zum ersten Output-Token. Tokens pro Sekunde geben an, wie schnell die Antwort danach streamt. Die End-to-End-Latenz ist die Summe: TTFT plus Generierungszeit, also etwa Output-Tokens geteilt durch die Geschwindigkeit pro Nutzer. Prompt-Länge und Warteschlangen bestimmen die TTFT, Modellgröße und Last die Geschwindigkeit, die Antwortlänge die Gesamtzeit. Messen Sie alle drei bei p50 und p95.

„Die API ist langsam“ kann drei verschiedene Dinge bedeuten, und jedes hat eine andere Lösung. Ein Chat-Nutzer wartet auf das erste Wort. Ein Agent wartet auf den kompletten Tool-Aufruf. Ein Batch-Job interessiert sich für Tokens pro Stunde. Dieser Beitrag definiert die drei Zahlen, zeigt, wie Sie sie in Ihrem eigenen Code messen, und ordnet jeder Maßnahme die Zahl zu, die sie tatsächlich bewegt.

Was sind TTFT, Tokens pro Sekunde und End-to-End-Latenz?

Der Benchmarking-Leitfaden von NVIDIA liefert saubere Definitionen, und sie decken sich mit dem, was Sie im Client beobachten können:

Metrik Was sie misst Wer sie spürt Bestimmt durch
Time to First Token (TTFT) Anfrage gesendet → erstes Token empfangen Chat-Nutzer Netzwerk, Warteschlange, Prompt-Länge (Prefill), Cache-Treffer
Inter-Token-Latenz (ITL) Durchschnittlicher Abstand zwischen Tokens Leser einer gestreamten Antwort Modellgröße, Hardware, Serverlast
Tokens pro Sekunde pro Nutzer Output-Tokens nach dem ersten ÷ Generierungszeit (erstes bis letztes Token); entspricht 1 ÷ durchschnittliche ITL Leser, Agenten Wie bei ITL
End-to-End-Latenz Anfrage gesendet → letztes Token empfangen Agenten, APIs, Batch TTFT + Generierungszeit

Die Formel, die sie verbindet:

End-to-End ≈ TTFT + (Output-Tokens − 1) × ITL ≈ TTFT + Output-Tokens ÷ Tokens pro Sekunde pro Nutzer

Die Geschwindigkeit pro Nutzer ist nicht dasselbe wie der Durchsatz des Servers, also alle Tokens, die ein Server über alle Nutzer hinweg erzeugt; ein Anbieter kann das eine steigern, während das andere sinkt.

Nehmen Sie die typische Geschwindigkeit, die BroadNet für sein Plan-Modell veröffentlicht, etwa 100 Tokens pro Sekunde. Die Generierungszeit wächst mit der Antwortlänge: Eine Code-Datei mit 4.000 Tokens braucht etwa achtzigmal so lange wie eine Klassifizierung mit 50 Tokens, während beide dieselbe TTFT abwarten. Bei kurzen Antworten macht die TTFT den Großteil der Wartezeit aus, bei langen sind es Geschwindigkeit und Länge.

Warum brauchen Reasoning-Modelle eine vierte Zahl?

Reasoning-Modelle wie DeepSeek V4.1 Flash denken, bevor sie antworten, und auch das Denken besteht aus Output-Tokens. Verbringt das Modell 800 Tokens mit Reasoning bei etwa 100 Tokens pro Sekunde, wartet der Nutzer, bis alle 800 erzeugt sind, bevor das erste sichtbare Wort erscheint, selbst wenn die TTFT auf der Leitung schnell aussieht. Messen Sie die Zeit bis zum ersten Content-Token daher separat. Bei BroadNet Inference verkürzt reasoning_effort: "low" das Denken für einfache Schritte; der Leitfaden zu Reasoning erklärt den Kompromiss.

Wie messen Sie die Latenz im Client?

Messen Sie dort, wo Ihre Nutzer sind, mit eingeschaltetem Streaming. Serverseitige Timer übersehen das Netzwerk und jeden Proxy.

import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))

Fünf Regeln für einen fairen Benchmark:

  1. Legen Sie die Prompt-Länge fest und geben Sie sie an. Die TTFT bei 500 Prompt-Tokens und bei 200.000 sind verschiedene Zahlen. Der Token-Zähler zeigt Ihnen, wie lang ein Test-Prompt ist, bevor Sie ihn senden.
  2. Legen Sie die Output-Länge fest, mit max_tokens und einem Prompt, der sie ausfüllt, damit Tokens pro Sekunde vergleichbar sind.
  3. Geben Sie p50 und p95 an, nicht den Mittelwert. An die Ausreißer erinnern sich die Nutzer.
  4. Verteilen Sie die Läufe zeitlich. Die Last ändert sich im Tagesverlauf.
  5. Wärmen Sie zuerst auf. Der erste Aufruf bezahlt DNS, TLS und Verbindungsaufbau; verwenden Sie einen Client wieder.

Was verbessert jede Zahl tatsächlich?

Zu verbessern Maßnahme Warum
TTFT Prompt-Präfix kürzen oder cachen Die Prefill-Zeit wächst mit der Prompt-Länge; gecachte Präfixe sparen Arbeit
TTFT Verbindungen warm halten, eine nahe Region nutzen Entfernt Verbindungsaufbau und Round-Trips
Zeit bis zum ersten Content-Token Reasoning-Aufwand senken oder für einfache Schritte ein Modell ohne Reasoning nutzen Weniger verstecktes Denken vor der Antwort
Tokens pro Sekunde Für den Schritt ein kleineres oder schnelleres Modell nutzen Die Decode-Geschwindigkeit hängt von Modellgröße und Serving ab
End-to-End Kürzeren Output anfordern (Schemas, Wortlimits) Die Output-Länge multipliziert die ITL
End-to-End bei vielen Aufrufen Unabhängige Aufrufe innerhalb Ihres Parallelitätslimits parallel ausführen Die Gesamtdauer sinkt, auch wenn jeder Aufruf gleich bleibt
Gefühlte Latenz An den Nutzer streamen Er liest, während das Modell schreibt

Die Output-Länge ist der am meisten unterschätzte Hebel. Wer „JSON mit diesen vier Feldern“ statt „erkläre deine Antwort“ anfordert, kann die Generierungszeit ohne jede Infrastrukturarbeit um eine Größenordnung senken. Strukturierte Ausgabe hilft dabei.

Den Cache-Hebel behandelt Prompt-Struktur für Caching. Der Parallelitäts-Hebel stößt schnell an Rate Limits; siehe 429-Fehler behandeln.

Wie verändert die Prompt-Länge den Kompromiss?

Die TTFT wächst mit dem Prompt, weil das Modell jedes Input-Token verarbeiten muss, bevor es schreiben kann. Das sind die versteckten Kosten sehr langer Prompts und Teil der Entscheidung Long Context vs. RAG: Ein Prompt mit 1 Mio. Tokens beantwortet Fragen, die RAG nicht beantworten kann, beginnt aber langsamer. Wenn interaktive Geschwindigkeit zählt, halten Sie den Hot Path kurz und senden den großen Kontext nur, wenn die Frage ihn braucht.

Wo BroadNet Inference passt

BroadNet veröffentlicht für sein Plan-Modell eine typische Geschwindigkeit von etwa 100 Tokens pro Sekunde und streamt im Standard-SSE-Format, der Code oben funktioniert also unverändert. Es veröffentlicht weder TTFT-Werte noch Latenz-SLAs; messen Sie daher mit Ihren eigenen Prompts, bevor Sie sich festlegen. Eine Meteor-Stunde für $1 reicht für einen Benchmark mit 50 Läufen, und das Startguthaben deckt einen auf Gemma 4 VL 26B. Wenn Sie garantierte Latenz unter einer Sekunde in großem Maßstab brauchen, testen Sie sorgfältig: Ein Pay-as-you-go-Schlüssel erlaubt 4 gleichzeitige Anfragen, was eher zu Apps und Agenten passt als zu Echtzeit-Serving mit hohem Volumen. Modelle und ihre Preise stehen auf den Seiten Modelle und Preise.

Häufige Fragen

Was ist eine gute Time to First Token für eine LLM-API?

Für Chat fühlt sich bei kurzen Prompts alles unter etwa einer Sekunde reaktionsschnell an. Lange Prompts und Reasoning-Modelle brauchen konstruktionsbedingt länger. Vergleichen Sie die TTFT nur bei gleicher Prompt-Länge und gleichem Modell.

Sind Tokens pro Sekunde dasselbe wie Durchsatz?

Nicht ganz. Tokens pro Sekunde pro Nutzer geben an, wie schnell eine Antwort streamt. Durchsatz sind alle Tokens, die ein Server über alle Nutzer hinweg erzeugt. Ein Anbieter kann den Gesamtdurchsatz steigern, während die Geschwindigkeit jedes einzelnen Nutzers sinkt.

Warum ist die TTFT bei einem Reasoning-Modell so hoch?

Das Modell erzeugt vor der sichtbaren Antwort versteckte Reasoning-Tokens. Das erste Token kann schnell ankommen, aber das erste Content-Token wartet, bis das Denken fertig ist. Senken Sie reasoning_effort für einfache Aufgaben.

Verringert Streaming die Latenz?

Die End-to-End-Zeit verkürzt es nicht. Es lässt den Nutzer die Antwort lesen, während sie noch geschrieben wird; die gefühlte Latenz sinkt so auf etwa die TTFT.

Wie viele Anfragen brauche ich für einen verlässlichen Latenz-Benchmark?

Genug, um die Ausreißer zu sehen. Fünfzig bis hundert Anfragen pro Prompt-Größe ergeben ein brauchbares p95. Verteilen Sie sie über den Tag, weil sich die Last ändert.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen