Optimizarea costurilor la scară largă
Pe această pagină
Costul ca restricție de inginerie
Un prompt slab optimizat, care costă 0,002 USD pe apel, este neglijabil în timpul dezvoltării. La un milion de apeluri, costul ajunge la 2.000 USD – și va continua să vă coste această sumă în fiecare lună până când cineva îl rescrie. Această schimbare de scară transformă costul într-o restricție de inginerie: nu o rezolvați negociind un contract, ci modificând codul.
Vizibilitatea este prerechizita oricărei optimizări. O factură lunară vă spune cât ați cheltuit, nu unde. De aceea, această lecție începe cu instrumentarea înainte de a aborda pârghiile de reducere.
Înțelegerea destinației banilor
Patru elemente determină costul unui apel, iar acestea nu se comportă la fel. Tokenii de intrare, care agregă promptul de sistem, istoricul conversației și mesajul utilizatorului, cresc odată cu durata sesiunii. Tokenii de ieșire – răspunsul generat – sunt facturați semnificativ mai scump decât cei de intrare. Tokenii de intrare din cache beneficiază de o reducere de aproximativ 50% față de tariful de intrare, ceea ce face ca urmărirea lor să fie esențială pentru înțelegerea oricărei facturi. În final, modelul în sine: GPT-5.6 Luna este mult mai ieftin decât GPT-5.6 Sol, iar acest factor domină toți ceilalți.
Urmărirea înseamnă convertirea fiecărui obiect usage returnat de API într-o sumă în dolari, aplicarea tarifului corect și izolarea porțiunii din cache.
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()
Tabelul RATES necesită o atenție constantă: devine învechit imediat ce grila oficială de prețuri se modifică. Tratați-l ca pe date de configurație care trebuie verificate, nu ca pe o constantă de program, și faceți din costul mediu pe apel o metrică pe care o revizuiți săptămânal.
Patru pârghii de reducere
Prima pârghie, și de departe cea mai profitabilă, este evitarea plății pentru un model de gamă superioară atunci când sarcina nu o necesită. Rutarea explicită bazată pe complexitate previne derivarea implicită prin care tot traficul ajunge pe cel mai scump model, simplu pentru că a apărut în primul exemplu copiat.
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
A doua pârghie merge mai departe atunci când complexitatea nu este cunoscută dinainte. În loc să clasificați cererea, cascada încearcă mai întâi cel mai ieftin model și escaladează doar dacă răspunsul nu trece de o verificare a calității. Verificarea folosită aici este în mod deliberat rudimentară – o lungime minimă și absența unei admiteri a ignoranței – iar acesta este punctul pe care va trebui să îl rafinați: o cascadă care escaladează prea des devine mai scumpă decât un apel direct către modelul potrivit.
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
A treia pârghie vizează tokenii de intrare, care cresc silențios în orice aplicație conversațională: la a douăzecea interacțiune, plătiți din nou pentru cele nouăsprezece anterioare la fiecare mesaj. Compresia istoricului prin păstrarea primului mesaj (care deține contextul) și a ultimului (care deține întrebarea), umplând apoi bugetul rămas cu cele mai recente schimburi, păstrează coerența esențială la o fracțiune din cost.
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]
A patra pârghie nu necesită finețe algoritmică, ci doar disciplină: Batch API oferă o reducere de 50%, iar dumneavoastră trebuie doar să identificați ce poate aștepta. Lăsați sarcina însăși să poarte urgența de la crearea sa, în loc să o deduceți ulterior – aceasta este singura modalitate de a preveni ca totul să ajungă implicit în coada de procesare în timp real.
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
}
Primirea alertelor înainte de sosirea facturii
Toate aceste optimizări pot fi anulate de o singură implementare norocoasă: o buclă de reîncercare fără limite, un prompt de sistem triplat, un model schimbat din greșeală. O alertă de cost este plasa de siguranță care vă avertizează în câteva ore, nu la sfârșitul lunii. Rețineți pragul intermediar de 80%: acesta transformă o alarmă brutală într-un semnal timpuriu, oferindu-vă timp să acționați înainte de a depăși limita.
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
Puncte cheie
- Urmăriți costurile în timp real folosind
response.usage - Rutați către cel mai ieftin model capabil să execute sarcina
- Utilizați Batch API (-50%) pentru orice nu necesită procesare în timp real
- Reduceți tokenii de intrare prin compresia istoricului
- Configurați alerte de cost pentru a evita surprizele