PricingLoginStart free
AI Engineering Academy · Lektion

LLM-Latenz messen: TTFT und TPOT

Definieren Sie Time to First Token und Time per Output Token als die beiden wichtigsten Latenzmetriken, instrumentieren Sie Ihre Anwendung zur Messung beider Werte und legen Sie SLA-Ziele pro Endpunkt fest.

Lektion 1 von 413 Schritte

LLM-Latenz messen: TTFT und TPOT ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum die LLM-Latenz aus zwei Komponenten besteht

Die Messung der LLM-Latenz als einzelne Zahl ist irreführend. Tatsächlich gibt es zwei verschiedene Phasen: die Zeit bis zum Eintreffen des ersten Tokens (wahrgenommene Reaktionsfähigkeit) und die Zeit, die zum Erzeugen der folgenden Tokens benötigt wird (Ausgabegeschwindigkeit). Ein Modell kann einen guten TTFT, aber einen langsamen TPOT haben. Dadurch wirken lange Antworten träge, obwohl die erste Antwort sofort erschienen ist.

TTFT: Zeit bis zum ersten Token

Time to First Token (TTFT) bezeichnet die Dauer vom Senden der API-Anfrage bis zum Empfang des allerersten Tokens der Antwort. Darin enthalten sind Netzwerklatenz, Wartezeit in der Inferenzwarteschlange des Servers und die Prefill-Zeit (die Verarbeitung der Eingabetokens). TTFT bestimmt maßgeblich die wahrgenommene Reaktionsfähigkeit – Benutzer bemerken, wenn länger als 1–2 Sekunden nichts erscheint, unabhängig davon, wie schnell danach Tokens gestreamt werden.

import time
from openai import OpenAI

client = OpenAI()

def measure_ttft(prompt: str) -> float:
    start = time.perf_counter()
    first_token_time = None
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            first_token_time = time.perf_counter()
            break  # stop after first token
    return first_token_time - start

TPOT: Zeit pro Ausgabe-Token

Time Per Output Token (TPOT) ist die durchschnittliche Zeit zwischen aufeinanderfolgenden Tokens, sobald die Generierung begonnen hat. Der Wert wird berechnet, indem die gesamte Generierungszeit durch die Gesamtzahl der Ausgabetokens geteilt wird. TPOT bestimmt die Lesegeschwindigkeit: Menschen lesen ungefähr 250 Wörter pro Minute. Daher wirkt ein TPOT von mehr als 100 ms pro Token (10 Tokens pro Sekunde) bei langen Antworten merklich langsam.

import time
from openai import OpenAI

client = OpenAI()

def measure_tpot(prompt: str) -> dict:
    start = time.perf_counter()
    first_token_time = None
    token_count = 0
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        delta = chunk.choices[0].delta.content or ''
        if delta:
            if first_token_time is None:
                first_token_time = time.perf_counter()
            token_count += 1
    end = time.perf_counter()
    ttft = first_token_time - start
    generation_time = end - first_token_time
    tpot = generation_time / max(token_count, 1)
    return {'ttft_ms': ttft * 1000, 'tpot_ms': tpot * 1000, 'tokens': token_count}

Gesamtlatenz vs. TTFT vs. TPOT

Das Verhältnis zwischen diesen Metriken lautet: total_latency = TTFT + (output_tokens × TPOT). Bei einer Antwort mit 500 Tokens und einem TPOT von 50 ms dauert die Generierung 25 Sekunden. Bei Streaming-Anwendungen sollten Sie zuerst TTFT optimieren – eine langsame Übertragung tolerieren Benutzer eher als einen leeren Bildschirm. Bei der Stapelverarbeitung ohne Streaming ist die Gesamtlatenz entscheidend. Optimieren Sie daher TPOT, indem Sie Modelle mit schnellerer Inferenz wählen.

# Latency breakdown for a 200-token response
ttft_ms = 450       # half a second to first token
tpot_ms = 25        # 25ms per token = 40 tokens/sec
output_tokens = 200

total_latency = ttft_ms + (tpot_ms * output_tokens)
print(f'TTFT:  {ttft_ms}ms')
print(f'Generation: {tpot_ms * output_tokens}ms')
print(f'Total: {total_latency}ms ({total_latency/1000:.1f}s)')
# Output:
# TTFT:  450ms
# Generation: 5000ms
# Total: 5450ms (5.5s)

Faktoren, die TTFT beeinflussen

TTFT wird maßgeblich durch die Prefill-Kosten bestimmt, die mit der Anzahl der Eingabe-Tokens steigen. Ein System-Prompt mit 10.000 Tokens hat unter ansonsten gleichen Bedingungen eine zehnmal höhere TTFT als ein Prompt mit 1.000 Tokens. Weitere Faktoren sind die Serverauslastung (Wartezeit in der Warteschlange), die Round-Trip-Zeit zum API-Endpunkt und die Frage, ob Prompt-Caching den effektiven Prefill-Aufwand reduziert. Halten Sie den System-Prompt möglichst kurz, um TTFT zu reduzieren.

# TTFT scales approximately linearly with input tokens
# Measured typical values for gpt-4o (2026):
# 500 input tokens:   ~400ms TTFT
# 2000 input tokens:  ~600ms TTFT
# 10000 input tokens: ~1500ms TTFT
# 32000 input tokens: ~4000ms TTFT

# Use prompt caching to avoid paying for repeated long prefixes:
# Cached tokens: ~200ms saved per 1000 cached tokens

Faktoren, die TPOT beeinflussen

TPOT wird hauptsächlich durch die Modellgröße und die Hardware bestimmt. Kleinere Modelle (GPT-4o-mini) dekodieren deutlich schneller als große Modelle (GPT-4o). Bei selbst gehosteten Modellen sind Batchgröße und GPU-Speicherbandbreite die wichtigsten Faktoren. Bei von OpenAI gehosteten Modellen hängt TPOT von der Serverauslastung ab, liegt aber typischerweise bei 15–40 ms pro Token. Bei gehosteten APIs können Sie TPOT nicht direkt steuern – die Modellauswahl ist Ihr wichtigster Stellhebel.

# Typical TPOT benchmarks (approximate, 2026):
# gpt-4o-mini:   15-20ms per token (50-65 tokens/sec)
# gpt-4o:        25-40ms per token (25-40 tokens/sec)
# claude-3.5-haiku: 20-25ms per token
# claude-3.5-sonnet: 30-50ms per token
# local llama-3.1-8B on A100: 8-12ms per token
# local llama-3.1-70B on 4xA100: 25-35ms per token

SLA-Ziele pro Endpunkt festlegen

Nicht alle Endpunkte benötigen dasselbe Latenzziel. Ein Chat-Endpunkt hat ein strenges TTFT-SLA (Benutzer erwarten <500 ms), während ein Endpunkt für die Zusammenfassung im Stapelbetrieb eine Latenz von mehreren Sekunden tolerieren kann. Definieren Sie explizite SLA-Ziele pro Endpunkt und instrumentieren Sie jeden Endpunkt separat. Häufige Ziele: interaktiver Chat = p95-TTFT <600 ms, Dokumentextraktion = p95-Gesamtlatenz <10 s, Stapelverarbeitung = kein Echtzeit-SLA.

SLA_TARGETS = {
    'chat':       {'ttft_p95_ms': 600,  'total_p95_ms': 8000},
    'extraction': {'ttft_p95_ms': 1500, 'total_p95_ms': 10000},
    'summary':    {'ttft_p95_ms': 2000, 'total_p95_ms': 30000},
    'batch':      {'ttft_p95_ms': None, 'total_p95_ms': None},
}

Latenzmetriken protokollieren

Protokollieren Sie TTFT und TPOT für jede Anfrage in der Produktion mithilfe strukturierter Protokollierung. Erfassen Sie den Modellnamen, den Endpunkt, die Anzahl der Prompt-Tokens, die Anzahl der Ausgabe-Tokens und ob ein Cache-Treffer vorlag. So erhalten Sie die Daten, um Perzentilverteilungen (p50, p95, p99) zu berechnen, Regressionen nach Modellaktualisierungen zu erkennen und Latenzspitzen mit der Warteschlangentiefe oder Vorfällen beim Anbieter in Beziehung zu setzen.

import structlog

log = structlog.get_logger()

def log_latency(endpoint: str, model: str, metrics: dict):
    log.info(
        'llm_latency',
        endpoint=endpoint,
        model=model,
        ttft_ms=round(metrics['ttft_ms'], 1),
        tpot_ms=round(metrics['tpot_ms'], 1),
        output_tokens=metrics['tokens'],
        total_ms=round(metrics['ttft_ms'] + metrics['tpot_ms'] * metrics['tokens'], 1)
    )

Perzentile aus Stichproben berechnen

Rohdurchschnitte sind bei der Latenz irreführend – einige wenige langsame Ausreißer erhöhen den Mittelwert, ohne die meisten Benutzer zu beeinflussen. Berichten Sie immer die Perzentile p50, p95 und p99. P95 ist die am häufigsten verwendete SLA-Metrik: Sie bedeutet, dass 95 % der Anfragen innerhalb dieser Zeit abgeschlossen wurden. Verwenden Sie NumPy oder das Modul statistics, um Perzentile aus Ihren protokollierten Latenzstichproben zu berechnen.

import numpy as np

def compute_percentiles(samples: list, label: str = 'latency_ms'):
    arr = np.array(samples)
    stats = {
        'count': len(arr),
        'p50': np.percentile(arr, 50),
        'p95': np.percentile(arr, 95),
        'p99': np.percentile(arr, 99),
        'mean': np.mean(arr),
        'max': np.max(arr)
    }
    print(f'{label}:')
    for k, v in stats.items():
        print(f'  {k}: {v:.1f}')
    return stats

Latenz mit max_tokens reduzieren

Das Festlegen eines passenden Limits für max_tokens reduziert die maximale Gesamtlatenz, indem es übermäßig lange Antworten verhindert. Wenn Ihr Anwendungsfall höchstens 200 Token lange Antworten benötigt, setzen Sie max_tokens=250. Dadurch werden auch die Kosten begrenzt. Kombinieren Sie dies mit Streaming, damit Benutzer sofort Ausgaben sehen, während die vollständige Antwort noch generiert wird. Lassen Sie max_tokens bei Endpunkten in der Produktion niemals unbegrenzt.

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': question}],
    max_tokens=300,  # cap at 300 tokens
    stream=True
)

# With max_tokens=300 and TPOT=30ms:
# worst-case total generation = 9000ms
# Without limit: could run to 4096+ tokens = 123s+

Prioritäten bei der Latenzoptimierung

Wenn die Latenz zu hoch ist, bearbeiten Sie die Engpässe in der richtigen Reihenfolge. Aktivieren Sie zuerst Streaming, damit Benutzer sofort Ausgaben sehen, auch wenn die Gesamtlatenz hoch ist. Verkürzen Sie zweitens den System-Prompt, um TTFT zu reduzieren. Fügen Sie drittens Prompt-Präfix-Caching hinzu, um die Prefill-Kosten über wiederholte Anfragen hinweg zu amortisieren. Wechseln Sie viertens zu einem kleineren Modell, sofern die Qualität dies zulässt. Ziehen Sie schließlich selbst gehostete Inferenz in Betracht, um maximale Kontrolle über TTFT und TPOT zu erhalten.

# Latency optimization checklist (in priority order):
# 1. Enable streaming (perceived latency: immediate)
# 2. Shorten system prompt by 50% (TTFT: -20%)
# 3. Enable prompt prefix caching (TTFT: -40% on cache hits)
# 4. Downgrade to gpt-4o-mini for simple queries (TPOT: -40%)
# 5. Self-host llama-3.1-8B for high-volume simple queries
#    (TPOT: 8ms vs 25ms; TTFT: 100ms vs 450ms)

Kurzer Check

Testen Sie Ihr Verständnis von TTFT und TPOT als Latenzmetriken für LLMs.

Beantworte es in der interaktiven Lektion

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: TTFT (Time to First Token) misst die wahrgenommene Reaktionsfähigkeit und steigt mit der Anzahl der Eingabe-Tokens, TPOT (Time Per Output Token) bestimmt die Generierungsgeschwindigkeit und wird hauptsächlich durch die Modellgröße beeinflusst, und SLA-Ziele pro Endpunkt mit Perzentilmetriken sind die richtige Methode zur Überwachung der Latenz in der Produktion. Als Nächstes implementieren wir Load-Balancing über mehrere API-Schlüssel.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „LLM-Latenz messen: TTFT und TPOT“ kostenlos?

Ja — der vollständige Text von „LLM-Latenz messen: TTFT und TPOT“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „LLM-Latenz messen: TTFT und TPOT“?

Definieren Sie Time to First Token und Time per Output Token als die beiden wichtigsten Latenzmetriken, instrumentieren Sie Ihre Anwendung zur Messung beider Werte und legen Sie SLA-Ziele pro Endpunk… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „LLM-Latenz messen: TTFT und TPOT“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. LLM-Latenz messen: TTFT und TPOT
  2. Lastverteilung und Strategien mit mehreren Schlüsseln
  3. Fallback-Anbieter und Circuit Breaker
  4. Timeout-Budgets und sanfte Verschlechterung
← Zurück zu AI Engineering Academy