0Pricing
AI Engineering Academy · Lezione

Misurare la latenza degli LLM: TTFT e TPOT

Definisca il time to first token e il time per output token come le due metriche chiave della latenza, strumentalizzi l'applicazione per misurarle entrambe e stabilisca obiettivi SLA per endpoint.

Misurare la latenza degli LLM: TTFT e TPOT è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.

Perché la latenza degli LLM ha due componenti

Misurare la latenza di un LLM come un unico numero può essere fuorviante. Esistono infatti due fasi distinte: il tempo prima che arrivi il primo token (reattività percepita) e il tempo necessario per generare i token successivi (velocità di output). Un modello può avere un TTFT eccellente ma un TPOT lento, facendo sembrare lente le risposte lunghe anche se la risposta iniziale è apparsa istantaneamente.

TTFT: tempo al primo token

Il Time to First Token (TTFT) è la durata che intercorre dall'invio della richiesta API alla ricezione del primissimo token della risposta. Include la latenza di rete, il tempo di accodamento sul server di inferenza e il tempo di prefill (elaborazione dei token di input). Il TTFT determina in larga misura la reattività percepita: gli utenti notano quando non appare nulla per più di 1-2 secondi, indipendentemente dalla velocità con cui i token vengono trasmessi in seguito.

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: tempo per token di output

Il Time Per Output Token (TPOT) è il tempo medio tra token successivi una volta iniziata la generazione. Si calcola dividendo il tempo totale di generazione per il numero totale di token di output. Il TPOT determina la velocità di lettura: gli esseri umani leggono circa 250 parole al minuto, quindi un TPOT superiore a 100 ms per token (10 token al secondo) risulta sensibilmente lento nelle risposte lunghe.

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}

Latenza totale, TTFT e TPOT a confronto

La relazione tra queste metriche è: total_latency = TTFT + (output_tokens × TPOT). Per una risposta di 500 token con un TPOT di 50 ms, la generazione richiede 25 secondi. Per le applicazioni in streaming, ottimizzi prima il TTFT: gli utenti tollerano meglio uno streaming lento rispetto a uno schermo vuoto. Per l'elaborazione batch senza streaming, conta la latenza totale, quindi ottimizzi il TPOT scegliendo modelli con inferenza più rapida.

# 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)

Fattori che influenzano il TTFT

Il TTFT è determinato soprattutto dal costo di prefill, che cresce con il numero di token di input. Un prompt di sistema di 10.000 token avrà un TTFT 10 volte superiore a quello di un prompt di 1.000 token, a parità di condizioni. Altri fattori includono il carico del server (tempo di coda), il tempo di andata e ritorno della rete verso l'endpoint API e l'eventuale riduzione del lavoro effettivo di prefill grazie al caching dei prompt. Riduca la lunghezza del prompt di sistema per diminuire il TTFT.

# 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

Fattori che influenzano il TPOT

Il TPOT è determinato principalmente dalle dimensioni del modello e dall'hardware. I modelli più piccoli (GPT-4o-mini) eseguono il decoding molto più rapidamente dei modelli grandi (GPT-4o). Nei modelli self-hosted, i fattori principali sono la dimensione del batch e la larghezza di banda della memoria della GPU. Per i modelli ospitati da OpenAI, il TPOT varia in base al carico del server, ma normalmente è compreso tra 15 e 40 ms per token. Non può controllare direttamente il TPOT nelle API ospitate: la scelta del modello è la leva principale a sua disposizione.

# 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

Impostare obiettivi SLA per endpoint

Non tutti gli endpoint richiedono lo stesso obiettivo di latenza. Un endpoint per chat ha uno SLA TTFT stringente (gli utenti si aspettano <500 ms), mentre un endpoint per la sintesi in batch può tollerare una latenza di diversi secondi. Definite obiettivi SLA per endpoint espliciti e raccogliete separatamente i dati di ciascuno. Obiettivi comuni: chat interattiva = p95 TTFT <600 ms, estrazione di documenti = p95 totale <10 s, batch = nessuno SLA in tempo reale.

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},
}

Registrazione delle metriche di latenza

Registrate TTFT e TPOT per ogni richiesta in produzione utilizzando il logging strutturato. Includete il nome del modello, l'endpoint, il numero di token del prompt, il numero di token dell'output e l'eventuale presenza di un hit della cache. In questo modo potrete calcolare le distribuzioni percentili (p50, p95, p99), individuare regressioni dopo gli aggiornamenti del modello e correlare i picchi di latenza con la profondità della coda o con gli incidenti del provider.

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)
    )

Calcolo dei percentili dai campioni

Le medie grezze sono fuorvianti per la latenza: alcuni valori anomali molto lenti aumentano la media senza influire sulla maggior parte degli utenti. Riportate sempre i percentili p50, p95 e p99. Il p95 è la metrica SLA più comune: significa che il 95% delle richieste è stato completato entro quel tempo. Usate NumPy o il modulo statistics per calcolare i percentili dai campioni di latenza registrati.

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

Riduzione della latenza con max_tokens

Impostare un limite max_tokens appropriato riduce la latenza totale nel caso peggiore, impedendo risposte eccessivamente lunghe. Se il vostro caso d'uso richiede al massimo risposte di 200 token, impostate max_tokens=250. Questo limita anche i costi. Combinate questa impostazione con lo streaming per fare in modo che gli utenti vedano immediatamente l'output mentre la risposta completa viene ancora generata. Non lasciate mai max_tokens senza limiti negli endpoint di produzione.

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à per l'ottimizzazione della latenza

Quando la latenza è troppo elevata, affrontate i colli di bottiglia in ordine di priorità. Per prima cosa, abilitate lo streaming, così gli utenti vedranno immediatamente l'output anche se la latenza totale è elevata. In secondo luogo, accorciate il prompt di sistema per ridurre il TTFT. In terzo luogo, aggiungete il caching del prefisso del prompt per ammortizzare il costo del prefill tra richieste ripetute. In quarto luogo, passate a un modello più piccolo se la qualità lo consente. Infine, valutate l'inferenza self-hosted per ottenere il massimo controllo sia sul TTFT sia sul TPOT.

# 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)

Verifica rapida

Verificate la vostra comprensione di TTFT e TPOT come metriche della latenza degli LLM.

Riepilogo della lezione

In questa lezione avete imparato che: TTFT (Time to First Token) misura la reattività percepita e cresce con il numero di token in ingresso, TPOT (Time Per Output Token) determina la velocità di generazione ed è controllato principalmente dalle dimensioni del modello, mentre gli obiettivi SLA per endpoint con metriche percentili sono il metodo corretto per monitorare la latenza in produzione. Ora implementeremo il bilanciamento del carico tra più chiavi API.

Domande Frequenti

La lezione «Misurare la latenza degli LLM: TTFT e TPOT» è gratuita?

Sì — il testo completo di «Misurare la latenza degli LLM: TTFT e TPOT» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.

Cosa imparerò in «Misurare la latenza degli LLM: TTFT e TPOT»?

Definisca il time to first token e il time per output token come le due metriche chiave della latenza, strumentalizzi l'applicazione per misurarle entrambe e stabilisca obiettivi SLA per endpoint. Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Engineering Academy?

Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Misurare la latenza degli LLM: TTFT e TPOT»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?

Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Misurare la latenza degli LLM: TTFT e TPOT
  2. Bilanciamento del carico e strategie multi-key
  3. Provider di fallback e circuit breaker
  4. Budget di timeout e degrado controllato
← Torna a AI Engineering Academy