Latentie meten en analyseren
Op deze pagina
Waarom latentie uw belangrijkste metriek is
Wanneer u een door LLM aangedreven applicatie naar productie brengt, bepaalt de latentie die uw gebruikers ervaren direct de adoptie. Een antwoord dat 8 seconden nodig heeft om te verschijnen, jaagt 70% van de gebruikers weg: ze sluiten het tabblad, proberen het verzoek opnieuw of concluderen dat de tool niet werkt. Geen enkele kwaliteitsverbetering kan dit verlies compenseren, omdat dit gebeurt voordat de gebruiker het antwoord überhaupt leest.
De uitdaging in productie is dat “het is traag” geen diagnose is. Diezelfde duur van acht seconden kan voortkomen uit een te lange systeemprompt, een te ambitieuze redeneerinstelling, een slecht geplaatste applicatieserver of nabewerking die wacht op het volledige antwoord voordat er iets wordt weergegeven. Elke oorzaak vereist een andere oplossing, en het verhelpen van de verkeerde oorzaak verandert niets. Deze les leert u hoe u end-to-end latentie meet, ontleedt en diagnosticeert, zodat u een klacht kunt omzetten in een actiegetal.
Componenten van latentie
De totale latentie van een API-oproep valt uiteen in vier segmenten die u moet scheiden. Netwerklatentie is de reistijd tussen uw server en de OpenAI API; deze is onzichtbaar in uw applicatielogs maar kan meer dan 100 milliseconden bedragen als uw server ver van het eindpunt verwijderd is. Time to First Token (TTFT) meet de vertraging voordat het eerste token wordt gegenereerd: dit is het segment dat gebruikers ervaren als “wachten”, aangezien het scherm leeg blijft totdat dit voltooid is. Time Per Output Token (TPOT) beschrijft vervolgens de generatiesnelheid voor elk volgend token; vermenigvuldigd met de responslengte geeft dit de duur van het scrollen van de tekst. Tot slot dekt applicatiel latentie alles wat uw eigen server voor en na de oproep doet: documenten ophalen, de prompt samenstellen, output-JSON valideren en naar de database schrijven.
Deze ontleding is niet academisch. Een team dat ontdekt dat zijn TTFT prima is, maar dat zijn applicatiel latentie twee seconden toevoegt, zal niet van model wisselen: het zal zijn SQL-query voor het ophalen van context onderzoeken.
Meten met Python
Hier ziet u hoe u een oproep naar de Responses API instrumenteert om elk segment vast te leggen:
import time
import openai
client = openai.OpenAI()
def measure_latency(prompt: str, model: str = "gpt-5.6-terra") -> dict:
"""Measure decomposed latency of an API call."""
metrics = {}
start_total = time.perf_counter()
# Stream the call to measure TTFT
stream = client.responses.create(
model=model,
input=prompt,
stream=True,
)
first_token = True
output_tokens = 0
for event in stream:
if event.type == "response.output_text.delta":
if first_token:
metrics["ttft"] = time.perf_counter() - start_total
start_generation = time.perf_counter()
first_token = False
output_tokens += 1
metrics["total_duration"] = time.perf_counter() - start_total
metrics["output_tokens"] = output_tokens
if output_tokens > 1:
metrics["tpot"] = (
(metrics["total_duration"] - metrics["ttft"]) / (output_tokens - 1)
)
return metrics
result = measure_latency("Explain Bayes' theorem in 3 sentences.")
for key, value in result.items():
print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")
De belangrijkste les van deze code is het gebruik van stream=True. Zonder streaming kunt u TTFT niet isoleren: de API keert pas terug na het volledige antwoord, dus u meet alleen een totaal. De timer start voor de oproep, stopt bij de eerste tekst-delta, en de resterende duur gedeeld door het aantal resterende tokens geeft TPOT. Voer dezelfde prompt uit tegen twee modellen of twee redeneerinstellingen en binnen enkele minuten heeft u de kwantitatieve vergelijking die de gissingen van uw team vervangt.
Knelpunten diagnosticeren
Een hoge TTFT, boven de twee seconden, wijst op drie oorzaken. De meest voorkomende is een te lange systeemprompt die niet wordt gecachet: het model moet bij elke oproep enkele duizenden tokens verwerken voordat het begint met schrijven. De volgende oorzaak is een hoge redeneerinstelling—high, xhigh of max op GPT-5.6—waardoor het model bewust nadenkt voordat het zichtbare output produceert; dit is geen bug, maar verwacht gedrag, maar het moet een bewuste keuze zijn, geen instelling die is overgenomen uit een prototype. Tot slot kan er sprake zijn van een piek in de belasting aan de kant van OpenAI, die u niet kunt beheersen: juist daarom heeft u continue meting nodig in plaats van een eenmalige controle, om dit te onderscheiden van de andere twee.
Een hoge TPOT, boven de 50 ms per token, leest anders. Een zeer hoge max_output_tokens dwingt het model lange reeksen te produceren, waardoor de totale duur mechanisch toeneemt, zelfs als elk token met normale snelheid arriveert. Het gebruik van complexe function calling met veel gedeclareerde tools belast de generatie ook. Concreet: een team dat vijftien tools in zijn schema heeft gelaten terwijl de helft niet meer wordt gebruikt, betaalt die overhead bij elke oproep.
Monitoringtools
Eenmalig meten is niet genoeg: u moet de verdeling in de tijd volgen, omdat de staart van de verdeling supporttickets genereert. Integreer voor continue productie-monitoring deze metrieken in uw observability-stack:
import logging
from dataclasses import dataclass, field
@dataclass
class LatencyMetrics:
"""Aggregates latency metrics over a sliding window."""
measurements: list[dict] = field(default_factory=list)
def add(self, measurement: dict) -> None:
self.measurements.append(measurement)
if len(self.measurements) > 1000:
self.measurements = self.measurements[-1000:]
@property
def ttft_p50(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
return values[len(values) // 2]
@property
def ttft_p99(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
idx = int(len(values) * 0.99)
return values[min(idx, len(values) - 1)]
def report(self) -> str:
return (
f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
f"Samples: {len(self.measurements)}"
)
Het schuivende venster van duizend metingen voorkomt onbegrensde geheugengroei terwijl het een representatieve steekproef van recent verkeer behoudt. Cruciaal is dat deze klasse twee percentielen blootlegt, niet een gemiddelde: een p50 van 700 ms met een p99 van 6 seconden beschrijft een dienst die de meeste gebruikers snel vinden en een minderheid onbruikbaar. Een gemiddelde zou beide realiteiten hebben gemaskeerd. Koppel report() aan uw metricstool en stel een alertdrempel in op p99 voordat u de rest van het systeem aanraakt.
Belangrijkste punten
- Latentie ontleedt in TTFT + generatie (TPOT × tokens) + netwerk
- Meet altijd met streaming om de echte TTFT te krijgen
- Volg p50- en p99-percentielen, niet alleen het gemiddelde
- Modelkeuze en redeneerinstellingen hebben directe invloed op de latentie: GPT-5.6 Terra met lage redenering reageert sneller dan GPT-5.6 Sol met hoge redenering