BroadRouter

Latenza degli LLM: TTFT, token al secondo e tempo end-to-end

A cura del team di BroadNet Inference · 4 min di lettura · Pubblicato · Aggiornato

Il time to first token (TTFT) è l’attesa prima del primo token di output. I token al secondo dicono quanto velocemente arriva poi la risposta in streaming. La latenza end-to-end è il totale: TTFT più il tempo di generazione (≈ token di output ÷ velocità). Lunghezza del prompt e code determinano il TTFT, dimensione del modello e carico la velocità, lunghezza della risposta il totale. Misurali tutti e tre a p50 e p95.

«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:

  1. 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.
  2. Fissa la lunghezza dell’output con max_tokens e un prompt che la riempia, così i token al secondo sono confrontabili.
  3. Riporta p50 e p95, non la media. Gli utenti ricordano la latenza di coda.
  4. Distribuisci le esecuzioni nel tempo. Il carico cambia durante la giornata.
  5. 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.

Domande frequenti

Qual è un buon time to first token per un’API LLM?

Per la chat, meno di circa un secondo sui prompt brevi dà una sensazione di reattività. I prompt lunghi e i modelli di ragionamento richiedono per natura più tempo. Confronta il TTFT solo a parità di lunghezza del prompt e di modello.

I token al secondo sono la stessa cosa del throughput?

Non proprio. I token al secondo per utente dicono quanto velocemente arriva una singola risposta. Il throughput è il totale dei token che un server produce per tutti gli utenti. Un provider può aumentare il throughput totale mentre la velocità di ciascun utente cala.

Perché il TTFT è così alto su un modello di ragionamento?

Il modello genera token di ragionamento nascosti prima della risposta visibile. Il primo token può arrivare presto, ma il primo token di contenuto aspetta la fine del ragionamento. Abbassa reasoning_effort per i compiti semplici.

Lo streaming riduce la latenza?

Non accorcia il tempo end-to-end. Permette all’utente di leggere la risposta mentre viene ancora scritta, quindi la latenza percepita scende più o meno al TTFT.

Quante richieste servono per un benchmark di latenza affidabile?

Abbastanza per vedere la coda della distribuzione. Da cinquanta a cento richieste per dimensione del prompt danno un p95 utilizzabile. Distribuiscile nell’arco della giornata, perché il carico cambia.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity