Prestazioni in Produzione
In questa pagina
Oltre la Cache: Prestazioni Globali
La cache riduce i costi, ma l’integrazione in produzione dipende da molto più che dalla semplice fattura: latenza percepita dall’utente, throughput sostenuto, affidabilità frente a errori transitori e capacità di diagnosticare i degradi. Un’applicazione che costa poco ma risponde in 12 secondi o fallisce una volta su 50 non è performante. Questa lezione copre le quattro dimensioni fondamentali una volta padroneggiato il costo.
Streaming: Risparmiare Tempo Senza Davvero Risparmiare Tempo
Per qualsiasi interfaccia in cui un umano attende una risposta, lo streaming SSE (Server-Sent Events) cambia radicalmente la percezione. Senza di esso, l’utente fissa il cursore mentre il modello genera 500 token; con esso, le prime parole appaiono dopo poche centinaia di millisecondi e la lettura inizia durante la generazione. Il tempo totale è lo stesso, ma il tempo percepito si riduce di un fattore multiplo.
import requests
import json
def appel_streaming(messages, model="grok-4.20"):
reponse = requests.post(
"https://api.x.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": model,
"messages": messages,
"stream": True
},
stream=True
)
for ligne in reponse.iter_lines():
if ligne and ligne.startswith(b"data: "):
donnees = ligne[6:]
if donnees == b"[DONE]":
break
chunk = json.loads(donnees)
token = chunk["choices"][0]["delta"].get("content", "")
yield token
Il parametro stream: True non cambia né il numero di token fatturati né la loro tariffa. Ciò che migliori è il TTFT, ovvero il time to first token. Nota che la funzione è un generatore: cede il controllo token per token, permettendoti di scrivere direttamente nella risposta HTTP del tuo server senza mantenere l’intera generazione in memoria.
Scegliere il Modello per la Latenza
La seconda leva sulla latenza è la scelta del modello, che dipende principalmente dallo sforzo di ragionamento. Un modello di ragionamento produce token di ragionamento invisibili prima di abbozzare la risposta: la qualità sale, ma anche il ritardo. Agli estremi, grok-build-0.1 è il più veloce del catalogo, adatto a usi in tempo reale come la classificazione al volo o l’autocompletamento; grok-4.20-0309 nella variante non-reasoning e grok-4.3 offrono un compromesso ragionevole tra qualità e velocità; grok-4.5 con ragionamento profondo si colloca all’altro estremo, riservato ai compiti che lo richiedono davvero.
La conseguenza pratica è che non scegli un modello per un’applicazione intera, ma per uno specifico passaggio. Uno schema comune prevede una chiamata iniziale veloce per decidere: questa richiesta è banale, ambigua o complessa? Invii poi solo la frazione di casi che lo giustificano a un modello di ragionamento. Dividi così sia la latenza media sia il costo medio senza degradare i casi difficili.
Gestire gli Errori Senza Peggiorare la Situazione
Il codice 429 trattato nella Lezione 3 non è l’unico che incontrerai. La distinzione chiave risiede tra gli errori che meritano un retry e quelli per cui ritentare aggiunge solo traffico inutile.
| Codice | Natura | Azione |
|---|---|---|
| 429 Too Many Requests | Recuperabile | Backoff esponenziale (Lezione 3) |
| 500 Internal Server Error | Recuperabile | Retry con backoff; l’errore è lato server |
| 502 / 503 Service Unavailable | Recuperabile | Retry dopo alcuni secondi |
| 400 Bad Request | Definitivo | Richiesta malformata; correggi il payload |
| 401 Unauthorized | Definitivo | Chiave API non valida o scaduta |
| 413 Payload Too Large | Definitivo | Il prompt supera il limite di contesto |
Puoi codificare questa regola in tre righe; vale la pena isolarla in una funzione invece di sparpagliare istruzioni if ovunque:
def classifier_erreur(status_code):
recuperable = {429, 500, 502, 503}
return status_code in recuperable
Timeout e Resilienza
Un timeout impostato male crea due problemi opposti: troppo breve e abbandoni richieste che avrebbero avuto successo; troppo lungo e blocchi i tuoi worker mentre la coda si allunga. Impostane tre separatamente. La connessione deve stabilirsi in 10 secondi; oltre tale soglia, il problema è di rete. La lettura in modalità non-streaming scala con il modello: 120 secondi per un modello di ragionamento, 60 secondi per grok-build-0.1. In streaming, la soglia rilevante non è la durata totale ma l’intervallo tra i chunk, impostato intorno ai 30 secondi.
Un punto merita vera cautela: quando un timeout scade durante una generazione lunga, non riavviare automaticamente. Il modello potrebbe aver già consumato token di ragionamento che pagheresti una seconda volta, e nulla garantisce che la prima richiesta non abbia avuto successo lato server. Un meccanismo di idempotenza—una chiave di richiesta che conservi per riconoscere un duplicato—or un resume esplicito funzionano meglio di un retry cieco.
Cosa Strumentare
Quattro famiglie di metriche bastano per diagnosticare la maggior parte degli incidenti.
| Metrica | Cosa Rivela | Obiettivo |
|---|---|---|
| TTFT | Latenza iniziale percepita | Monitorare per modello |
| Tasso di Successo | Affidabilità dell’integrazione | Maggiore del 99,5% |
| Tasso di Cache | Qualità della struttura del prompt | Maggiore del 50% |
| Costo per Richiesta | Deriva del budget, media mobile | Stabile nel tempo |
Aggiungi la latenza al 95° percentile. La media maschera sempre i casi estremi, e sono proprio quelli a generare ticket di supporto: un P95 a 8 secondi significa che un utente su 20 attende 8 secondi, cosa che nessuna media di 1,2 secondi rivelerebbe.
Punti chiave
- Lo streaming SSE riduce la latenza percepita senza impattare sui costi
- Scegli un modello veloce per il tempo reale e un modello di ragionamento per la qualità
- Distingui gli errori recuperabili (429, 500, 502/503) dagli errori definitivi (400, 401)
- Configura timeout adatti al modello in uso
- Monitora TTFT, tasso di successo, tasso di cache e costo medio per richiesta