Ottimizzazione dei costi su larga scala
In questa pagina
Il costo come vincolo ingegneristico
Un prompt mal ottimizzato che costa 0,002 $ per chiamata sembra trascurabile durante lo sviluppo. A un milione di chiamate, il costo sale a 2.000 $: e continuerai a pagarlo ogni mese finché qualcuno non lo riscriverà. Questo cambio di scala trasforma il costo in un vincolo ingegneristico: non lo risolvi negoziando un contratto, ma modificando il codice.
La visibilità è il prerequisito per qualsiasi ottimizzazione. Una fattura mensile ti dice quanto hai speso, non dove. Per questo questa lezione inizia con l’instrumentation prima di affrontare le leve di riduzione.
Sapere dove vanno i soldi
Quattro elementi determinano il costo di una chiamata e non si comportano tutti allo stesso modo. I token in input, che aggregano il prompt di sistema, la cronologia della conversazione e il messaggio dell’utente, crescono con la durata della sessione. I token in output, ovvero la risposta generata, vengono fatturati a una tariffa significativamente più alta rispetto all’input. I token in input memorizzati nella cache beneficiano di uno sconto di circa il 50% rispetto alla tariffa standard per l’input: tracciarli è essenziale per comprendere qualsiasi fattura. Infine, il modello stesso: GPT-5.6 Luna costa molto meno di GPT-5.6 Sol, e questo fattore domina tutti gli altri.
Tracciare significa convertire ogni oggetto usage restituito dall’API in un importo in dollari, applicare la tariffa corretta e isolare la parte cached.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Rates per million tokens (July 2026) — cached_input is indicative (~50% of input),
# adjust according to the official pricing grid
RATES = {
"gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
"gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
"gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}
@dataclass
class CostTracker:
"""Tracks costs in real time."""
calls: list[dict] = field(default_factory=list)
def record(self, model: str, usage: dict) -> float:
input_tokens = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
output_tokens = usage.output_tokens
uncached_input_tokens = input_tokens - cached_tokens
rate = RATES.get(model, RATES["gpt-5.6-terra"])
cost = (
(uncached_input_tokens / 1_000_000) * rate["input"]
+ (cached_tokens / 1_000_000) * rate["cached_input"]
+ (output_tokens / 1_000_000) * rate["output"]
)
self.calls.append({
"model": model,
"input_tokens": input_tokens,
"cached_tokens": cached_tokens,
"output_tokens": output_tokens,
"cost": cost,
})
return cost
@property
def total_cost(self) -> float:
return sum(a["cost"] for a in self.calls)
def report(self) -> str:
if not self.calls:
return "No calls recorded."
return (
f"Calls: {len(self.calls)} | "
f"Total cost: ${self.total_cost:.4f} | "
f"Average cost: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
La tabella RATES richiede attenzione costante: diventa obsoleta non appena cambia la griglia dei prezzi ufficiale. Trattala come dati di configurazione da verificare, non come una costante del programma, e fai del costo medio per chiamata una metrica da rivedere settimanalmente.
Quattro leve per la riduzione
La prima leva, di gran lunga la più redditizia, è evitare di pagare per un modello di fascia alta quando il compito non lo richiede. Un routing esplicito basato sulla complessità previene la deriva predefinita per cui tutto il traffico finisce sul modello più costoso semplicemente perché appariva nel primo esempio copiato.
async def economic_router(prompt: str, complexity: str) -> str:
"""Routes to the cheapest capable model."""
if complexity == "simple":
model = "gpt-5.6-luna"
elif complexity == "medium":
model = "gpt-5.6-terra"
else:
model = "gpt-5.6-sol"
response = client.responses.create(model=model, input=prompt)
tracker.record(model, response.usage)
return response.output_text
La seconda leva va oltre quando la complessità non è nota in anticipo. Invece di classificare la richiesta, la cascata prova prima il modello più economico ed effettua un’escalation solo se la risposta non supera un controllo di qualità. Il controllo usato qui è volutamente rudimentale: una lunghezza minima e l’assenza di un’ammissione di ignoranza. Questo è il punto che dovrai affinare: una cascata che scala troppo spesso diventa più costosa di una chiamata diretta al modello giusto.
async def model_cascade(prompt: str) -> str:
"""Tries the cheapest model first."""
models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]
for model in models:
response = client.responses.create(
model=model,
input=prompt,
max_output_tokens=500,
)
tracker.record(model, response.usage)
# Check quality (simple heuristic)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Last result even if imperfect
La terza leva mira ai token in input, che crescono silenziosamente in qualsiasi applicazione conversazionale: al ventesimo turno, stai ripagando i precedenti diciannove con ogni messaggio. Comprimere la cronologia mantenendo il primo messaggio (che contiene il contesto) e l’ultimo (che contiene la domanda), riempiendo poi il budget rimanente con gli scambi più recenti, preserva la coerenza essenziale a una frazione del costo.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Keeps the most recent messages within budget."""
# Always keep the first (context) and last (question)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Estimate tokens (approximation: 1 token ≈ 4 characters)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Keep the most recent messages
result = []
tokens_used = 0
for msg in reversed(middle):
msg_tokens = len(msg["content"]) // 4
if tokens_used + msg_tokens > middle_budget:
break
result.insert(0, msg)
tokens_used += msg_tokens
return [first] + result + [last]
La quarta leva non richiede finezza algoritmica, solo disciplina: la Batch API offre una riduzione del 50% e devi solo identificare cosa può attendere. Lascia che sia il compito stesso a portare l’urgenza fin dalla sua creazione, invece di dedurla dopo: è l’unico modo per evitare che tutto finisca per default nella coda in tempo reale.
def classify_urgency(tasks: list[dict]) -> dict:
"""Separates tasks into real-time vs batch."""
real_time = []
batch = []
for task in tasks:
if task.get("urgency") == "immediate":
real_time.append(task)
else:
batch.append(task)
return {
"real_time": real_time,
"batch": batch,
"estimated_savings": len(batch) * 0.001, # Example
}
Ricevere avvisi prima della fattura
Tutte queste ottimizzazioni possono essere annullate da un singolo deploy sfortunato: un ciclo di retry illimitato, un prompt di sistema triplicato, un modello cambiato per errore. Un alert sui costi è la rete di sicurezza che ti avvisa entro ore invece che a fine mese. Nota la soglia intermedia all’80%: trasforma un allarme brutale in un segnale precoce, dandoti il tempo di agire prima di superare il limite.
class CostAlert:
"""Triggers alerts when costs exceed a threshold."""
def __init__(self, daily_threshold: float = 50.0):
self.threshold = daily_threshold
self.tracker = CostTracker()
def check(self) -> str | None:
if self.tracker.total_cost > self.threshold:
return (
f"ALERT: daily cost ${self.tracker.total_cost:.2f} "
f"exceeds threshold of ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"WARNING: cost at {self.tracker.total_cost / self.threshold:.0%} "
f"of daily threshold"
)
return None
Punti chiave
- Traccia i costi in tempo reale usando
response.usage - Instrada le richieste al modello più economico in grado di svolgere il compito
- Usa la Batch API (-50%) per tutto ciò che non richiede elaborazione in tempo reale
- Riduci i token in input comprimendo la cronologia
- Configura alert sui costi per evitare sorprese