Misurare e analizzare la latenza
In questa pagina
Perché la latenza è la tua metrica numero uno
Quando distribuisci un’applicazione basata su LLM in produzione, la latenza percepita dagli utenti determina direttamente l’adozione. Una risposta che impiega 8 secondi ad apparire allontana il 70% degli utenti: chiudono la scheda, riprovano la richiesta o concludono che lo strumento non funziona. Nessun miglioramento della qualità può compensare questa perdita, perché avviene prima ancora che l’utente legga la risposta.
La sfida in produzione è che dire «è lento» non è una diagnosi. La stessa durata di otto secondi potrebbe derivare da un prompt di sistema troppo grande, da un’impostazione di ragionamento eccessivamente ambiziosa, da un server applicativo posizionato male o da un post-processing che attende l’intera risposta prima di visualizzare qualsiasi cosa. Ogni causa richiede una correzione diversa e intervenire su quella sbagliata non cambia nulla. Questa lezione ti insegna a misurare, scomporre e diagnosticare la latenza end-to-end per trasformare un reclamo in un numero su cui agire.
Componenti della latenza
La latenza totale di una chiamata API si suddivide in quattro segmenti che devi separare. La latenza di rete è il tempo di transito tra il tuo server e le API di OpenAI; è invisibile nei log della tua applicazione ma può superare i 100 millisecondi se il tuo server è lontano dall’endpoint. Il Time to First Token (TTFT) misura il ritardo prima della generazione del primo token: è il segmento che gli utenti percepiscono come «attesa», poiché lo schermo rimane vuoto fino al suo completamento. Il Time Per Output Token (TPOT) descrive invece la velocità di generazione per ogni token successivo; moltiplicato per la lunghezza della risposta, fornisce la durata dello scorrimento del testo. Infine, la latenza applicativa copre tutto ciò che il tuo server fa prima e dopo la chiamata: recupero documenti, assemblaggio del prompt, validazione dell’output JSON e scrittura nel database.
Questa scomposizione non è accademica. Un team che scopre che il suo TTFT è nella norma ma la sua latenza applicativa aggiunge due secondi non cambierà modello: esaminerà invece la sua query SQL per il recupero del contesto.
Misurazione con Python
Ecco come strumentare una chiamata alle API Responses per catturare ogni segmento:
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}")
Il punto chiave di questo codice è l’uso di stream=True. Senza lo streaming, non puoi isolare il TTFT: l’API restituisce il risultato solo dopo la risposta completa, quindi misureresti solo un totale. Il timer parte prima della chiamata, si ferma al primo delta di testo e la durata rimanente divisa per il numero di token restanti fornisce il TPOT. Esegui lo stesso prompt su due modelli o con due impostazioni di ragionamento diverse e, nel giro di pochi minuti, avrai il confronto quantitativo che sostituisce le ipotesi del tuo team.
Diagnosi dei colli di bottiglia
Un TTFT elevato, superiore a due secondi, indica tre possibili cause. La più comune è un prompt di sistema eccessivamente lungo che non viene memorizzato nella cache: il modello deve elaborare diverse migliaia di token prima di iniziare a scrivere, a ogni chiamata. La seconda è un’impostazione di ragionamento elevata—high, xhigh o max su GPT-5.6—che induce deliberatamente il modello a «pensare» prima di produrre qualsiasi output visibile; non è un bug, è un comportamento atteso, ma dovrebbe essere una scelta consapevole, non un’impostazione ereditata da un prototipo. Infine, potrebbe esserci un picco di carico lato OpenAI, su cui non hai controllo: ecco perché hai bisogno di misurazioni continue piuttosto che di un controllo una tantum, per distinguerlo dalle altre due cause.
Un TPOT elevato, superiore a 50 ms per token, si legge in modo diverso. Un valore max_output_tokens molto alto spinge il modello a produrre sequenze lunghe e la durata totale aumenta meccanicamente anche se ogni token arriva a velocità normale. Anche l’uso di chiamate di funzione complesse con molti strumenti dichiarati appesantisce la generazione. Concretamente, un team che ha lasciato quindici strumenti nel proprio schema quando la metà non è più utilizzata pagherà quel sovraccarico a ogni chiamata.
Strumenti di monitoraggio
Misurare una volta non basta: devi tracciare la distribuzione nel tempo, perché la coda della distribuzione genera ticket di supporto. Per il monitoraggio continuo in produzione, integra queste metriche nel tuo stack di osservabilità:
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)}"
)
La finestra scorrevole di mille misurazioni previene una crescita illimitata della memoria mantenendo al contempo un campione rappresentativo del traffico recente. È fondamentale che questa classe esponga due percentili, non una media: un p50 di 700 ms con un p99 di 6 secondi descrive un servizio che la maggior parte degli utenti trova veloce e una minoranza inutilizzabile. Una media avrebbe mascherato entrambe le realtà. Collega report() al tuo strumento di metriche e imposta una soglia di allerta sul p99 prima di toccare il resto del sistema.
Punti chiave
- La latenza si scompone in TTFT + generazione (TPOT × token) + rete
- Misura sempre con lo streaming per ottenere il TTFT reale
- Traccia i percentili p50 e p99, non solo la media
- La scelta del modello e le impostazioni di ragionamento impattano direttamente la latenza: GPT-5.6 Terra con ragionamento basso risponde più velocemente di GPT-5.6 Sol con ragionamento alto