«L’API è lenta» può voler dire tre cose diverse, e ognuna si risolve in modo diverso. Un utente in chat aspetta la prima parola. Un agente aspetta l’intera chiamata a un tool. A un job batch interessano i token all’ora. Questo articolo definisce i tre numeri, mostra come misurarli dal tuo codice e associa ogni intervento al numero che sposta davvero.
Cosa sono TTFT, token al secondo e latenza end-to-end?
La guida al benchmarking di NVIDIA dà definizioni pulite, che corrispondono a ciò che puoi osservare da un client:
| Metrica | Cosa misura | Chi la percepisce | Da cosa dipende |
|---|---|---|---|
| Time to first token (TTFT) | Richiesta inviata → primo token ricevuto | Utenti della chat | Rete, code, lunghezza del prompt (prefill), hit della cache |
| Latenza tra token (ITL) | Intervallo medio tra un token e l’altro | Chi legge una risposta in streaming | Dimensione del modello, hardware, carico del server |
| Token al secondo per utente | Token di output dopo il primo ÷ tempo di generazione (dal primo all’ultimo token); pari a 1 ÷ ITL media | Lettori, agenti | Come per l’ITL |
| Latenza end-to-end | Richiesta inviata → ultimo token ricevuto | Agenti, API, batch | TTFT + tempo di generazione |
La formula che li lega:
end-to-end ≈ TTFT + (token di output − 1) × ITL ≈ TTFT + token di output ÷ token al secondo per utente
La velocità per utente non coincide con il throughput del server, cioè il totale dei token che un server produce per tutti gli utenti; un provider può aumentare l’uno mentre l’altro cala.
Prendi la velocità tipica che BroadNet pubblica per il modello dei suoi piani, circa 100 token al secondo. Il tempo di generazione cresce con la lunghezza della risposta: un file di codice da 4.000 token richiede circa ottanta volte il tempo di una classificazione da 50 token, mentre entrambi aspettano lo stesso TTFT. Nelle risposte brevi il TTFT è quasi tutta l’attesa; in quelle lunghe contano velocità e lunghezza.
Perché i modelli di ragionamento richiedono un quarto numero?
I modelli di ragionamento come DeepSeek V4.1 Flash pensano prima di rispondere, e anche il ragionamento è fatto di token di output. Se il modello spende 800 token a ragionare a circa 100 token al secondo, l’utente aspetta che tutti gli 800 vengano generati prima di vedere la prima parola, anche se il TTFT misurato in rete sembra rapido. Quindi misura a parte il tempo al primo token di contenuto. Su BroadNet Inference, reasoning_effort: "low" accorcia il ragionamento nei passaggi semplici; la guida al ragionamento spiega il compromesso.
Come si misura la latenza dal client?
Misurala dove si trovano i tuoi utenti, con lo streaming attivo. I timer lato server non vedono la rete né eventuali 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))
Cinque regole per un benchmark corretto:
- Fissa la lunghezza del prompt e indicala. Il TTFT a 500 token di prompt e quello a 200.000 sono numeri diversi. Il contatore di token ti dice quanto è lungo un prompt di test prima di inviarlo.
- Fissa la lunghezza dell’output con
max_tokense un prompt che la riempia, così i token al secondo sono confrontabili. - Riporta p50 e p95, non la media. Gli utenti ricordano la latenza di coda.
- Distribuisci le esecuzioni nel tempo. Il carico cambia durante la giornata.
- Fai prima un riscaldamento. La prima chiamata paga DNS, TLS e apertura della connessione; riusa un solo client.
Cosa migliora davvero ciascun numero?
| Per migliorare | Fai così | Perché |
|---|---|---|
| TTFT | Accorcia il prefisso del prompt o mettilo in cache | Il tempo di prefill cresce con la lunghezza del prompt; i prefissi in cache saltano lavoro |
| TTFT | Tieni calde le connessioni, usa una regione vicina | Elimina setup e round trip |
| Tempo al primo token di contenuto | Abbassa lo sforzo di ragionamento, o usa un modello senza ragionamento per i passaggi semplici | Meno ragionamento nascosto prima della risposta |
| Token al secondo | Usa un modello più piccolo o più veloce per quel passaggio | La velocità di decodifica dipende da dimensione del modello e serving |
| End-to-end | Chiedi output più brevi (schemi, limiti di parole) | La lunghezza dell’output moltiplica l’ITL |
| End-to-end su molte chiamate | Esegui in parallelo le chiamate indipendenti entro il tuo limite di concorrenza | Il tempo reale scende anche se ogni chiamata resta uguale |
| Latenza percepita | Usa lo streaming verso l’utente | Legge mentre il modello scrive |
La lunghezza dell’output è la leva più sottovalutata. Chiedere «un JSON con questi quattro campi» invece di «spiega la tua risposta» può ridurre il tempo di generazione di un ordine di grandezza senza alcun lavoro sull’infrastruttura. L’output strutturato aiuta.
La leva della cache è trattata in struttura del prompt per il caching. La leva del parallelismo si scontra presto con i rate limit; vedi gestire gli errori 429.
Come cambia il compromesso con la lunghezza del prompt?
Il TTFT cresce con il prompt perché il modello deve elaborare ogni token di input prima di poter scrivere. È il costo nascosto dei prompt molto lunghi e fa parte della scelta tra contesto lungo e RAG: un prompt da 1M di token risponde a domande che la RAG non gestisce, ma parte più lentamente. Se conta la velocità interattiva, tieni corto il percorso principale e invia il contesto grande solo quando la domanda lo richiede.
Dove si colloca BroadNet Inference
BroadNet pubblica una velocità tipica di circa 100 token al secondo per il modello dei suoi piani e fa streaming nel formato SSE standard, quindi il codice qui sopra funziona senza modifiche. Non pubblica valori di TTFT né SLA di latenza, quindi misura sui tuoi prompt prima di impegnarti; un’ora Meteor da $1 basta per un benchmark da 50 esecuzioni, e il credito iniziale ne copre uno su Gemma 4 VL 26B. Se ti serve una latenza garantita sotto il secondo su larga scala, fai test accurati: una chiave a consumo consente 4 richieste in corso, il che si adatta più ad app e agenti che a un serving in tempo reale ad alto volume. I modelli e i loro prezzi sono nelle pagine modelli e prezzi.
