Ottimizzazione end-to-end: dal prompt alla rete
In questa pagina
Lezione aggiornata il 3 novembre 2026 sulla base della documentazione OpenAI:
temperatureetop_psono accettati solo con uno sforzo di ragionamento pari anone, mentre i modelli GPT-5.6 ragionano per impostazione predefinita (medium). Le chiamate che impostano questi parametri devono quindi specificarereasoning={"effort": "none"}(API Responses) oreasoning_effort="none"(Chat Completions). Fonti: Utilizzo di GPT-6 · GPT-5.6 Terra.
L’ottimizzazione è un sistema, non un parametro
Ridurre la latenza e i costi di un’applicazione LLM non significa semplicemente scegliere un modello più veloce. Si tratta di una catena di ottimizzazioni che si estende dal prompt alla configurazione di rete, dove l’anello più debole determina le prestazioni dell’intero sistema. Un team che dimezza la dimensione del prompt di sistema ma lascia che il server apra una nuova connessione TLS per ogni richiesta perderà in overhead di rete quanto risparmiato in token.
L’ordine in cui affronti queste leve è fondamentale. Inizia dal prompt, poiché impatta sia sui costi che sulla latenza senza richiedere modifiche infrastrutturali. Seguono i parametri API, poi la configurazione di rete e infine il modo in cui la tua applicazione consuma la risposta. Questa lezione ti guida attraverso ciascuna leva in questo ordine.
Ottimizza il prompt
Ogni token in input costa tempo e denaro, e la maggior parte dei prompt in produzione si porta dietro il bagaglio della fase di prototipazione: istruzioni aggiunte una alla volta, ognuna che riformula la precedente. Il tuo primo riflesso dovrebbe essere riscrivere il prompt in modo denso, rimuovendo forme di cortesia e ripetizioni senza toccare i vincoli effettivi trasmessi al modello.
# ❌ Prompt verboso
prompt_long = """
Sei un assistente esperto di analisi finanziaria. Devi sempre
rispondere in modo professionale e strutturato. Devi usare
dati numerici quando possibile. Devi evitare gergo inutile.
Devi essere conciso ma completo.
Analizza il seguente rapporto trimestrale: ...
"""
# ✅ Prompt ottimizzato (stesso risultato, meno token)
prompt_court = """Ruolo: Analista finanziario senior.
Vincoli: Strutturato, numerico, conciso.
Compito: Analizza questo rapporto trimestrale: ..."""
Entrambe le versioni trasmettono esattamente gli stessi cinque vincoli; la seconda lo fa senza le cinque frasi “Devi” che non aggiungono nulla per il modello. Su un servizio che elabora diecimila rapporti al giorno, questa riscrittura di trenta secondi si ripaga da sola ogni giorno.
Scegli il modello giusto per il compito
La seconda leva si basa sul fatto che non ogni chiamata richiede lo stesso modello. Instradare un’attività di estrazione di campi verso un modello ad alto ragionamento significa pagare per capacità che il compito non utilizza e attendere più a lungo per un risultato identico.
| Tipo di compito | Modello consigliato | Motivo |
|---|---|---|
| Classificazione / estrazione | gpt-5.6-luna | Veloce, economico |
| Ragionamento complesso | gpt-5.6-terra con ragionamento medium | Miglior rapporto qualità/costo |
| Compiti critici | gpt-5.6-sol con ragionamento high | Qualità massima, più lento |
| Alto volume | gpt-5.6-luna tramite Batch API | -50% costi |
Nella pratica, codifica questa scelta in una funzione di routing invece di lasciarla alla discrezione degli sviluppatori; altrimenti, il modello predefinito vincerà sempre:
import openai
client = openai.OpenAI()
def route_model(task: str, complexity: str) -> str:
"""Seleziona il modello ottimale in base al compito."""
if complexity == "low":
return "gpt-5.6-luna"
elif task in ("reasoning", "math", "code"):
return "gpt-5.6-terra"
elif complexity == "critical":
return "gpt-5.6-sol"
return "gpt-5.6-terra"
def optimized_call(prompt: str, task: str, complexity: str) -> str:
model = route_model(task, complexity)
response = client.responses.create(
model=model,
input=prompt,
)
return response.output_text
Ottimizza i parametri API
Una risposta troppo lunga spreca tempo di generazione che nessuno leggerà. Specifica sempre max_output_tokens: questo è un limite rigido che protegge sia la tua fattura che la tua interfaccia, impedendo a un prompt formulato male di degenerare in una digressione di duemila parole.
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature richiede effort none
input="Riassumi questo testo in una frase.",
max_output_tokens=100, # Limite rigido
temperature=0.0, # Deterministico = più veloce
)
I parametri di campionamento lavorano nella stessa direzione. Impostare temperature=0 rende le risposte deterministiche e leggermente più veloci, esattamente ciò che desideri per compiti di estrazione o classificazione dove la creatività è fonte di varianza, non un vantaggio. Ridurre top_p a 0.1 restringe lo spazio di ricerca e accelera la generazione; riserva questa impostazione ai compiti dove è accettabile una sola formulazione e mantieni i valori predefiniti dove la ricchezza della risposta fa parte del prodotto.
Ottimizza la rete
I costi di viaggio dei pacchetti si accumulano su ogni chiamata, eppure rimangono invisibili nelle metriche della tua applicazione. L’API OpenAI è ospitata principalmente sulla costa orientale degli USA: posizionare il tuo server applicativo nella stessa regione dell’endpoint può garantire un guadagno potenziale da 50 a 150 millisecondi nella latenza di rete. Per un’applicazione conversazionale, questa è una frazione significativa del Time to First Token (TTFT).
Il secondo guadagno deriva dal riutilizzo delle connessioni. Senza un pool, ogni richiesta ripete l’handshake TLS, aggiungendo diversi round-trip prima che fluisca qualsiasi dato utile. Configurare un client HTTP una volta per tutte risolve il problema:
import httpx
# Client con pool di connessioni persistenti
client_http = httpx.Client(
base_url="https://api.openai.com/v1",
timeout=60.0,
limits=httpx.Limits(
max_connections=20,
max_keepalive_connections=10,
),
)
Ottimizza il post-processing
L’ultimo anello è spesso quello che le persone dimenticano: un’applicazione che riceve una risposta in streaming ma attende la fine per visualizzarla annulla tutti i benefici dello streaming. Elabora la risposta al volo invece che dopo la ricezione completa.
async def progressive_processing(prompt: str):
"""Elabora ogni chunk non appena arriva."""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
buffer = ""
for event in stream:
if event.type == "response.output_text.delta":
buffer += event.delta
# Elabora per frase completa
if buffer.endswith((".", "!", "?")):
yield buffer.strip()
buffer = ""
Dividere per frase completa è un compromesso deliberato: emettere ogni token produce una visualizzazione tremolante, mentre attendere l’intero paragrafo ricrea la sensazione di attesa. La frase è l’unità che i lettori consumano naturalmente. Riutilizza questo schema ogni volta che la tua interfaccia deve visualizzare, leggere ad alta voce o trasmettere in streaming ciò che il modello produce.
Punti chiave
- Ottimizza prima il prompt: meno token = meno latenza e costi
- Instrada verso il modello giusto in base alla complessità del compito
- Limita
max_output_tokense usatemperature=0quando possibile - Riutilizza le connessioni HTTP ed elabora le risposte via streaming