Optimalizácia nákladov vo veľkom meradle
Na tejto strane
Náklady ako inžinierske obmedzenie
Zle optimalizovaný prompt, ktorý stojí 0,002 $ za volanie, je počas vývoja zanedbateľný. Pri milióne volaní to však znamená 2 000 $ – a bude ťa to stáť toľko každý mesiac, kým to niekto neprepíše. Tento posun v rozsahu mení náklady na inžinierske obmedzenie: neriešiš ho vyjednávaním zmluvy, ale zmenou kódu.
Viditeľnosť je predpokladom akejkoľvek optimalizácie. Mesačný účet ti povie, koľko si minul, nie kde. Preto táto lekcia začína inštrumentáciou až potom prechádza k pákam na znižovanie nákladov.
Vedieť, kam peniaze idú
Náklady na volanie určujú štyri prvky a každý sa správa inak. Vstupné tokeny, ktoré zahŕňajú systémový prompt, históriu konverzácie a správu používateľa, rastú s dĺžkou relácie. Výstupné tokeny – generovaná odpoveď – sú fakturované výrazne drahšie ako vstupné. Tokeny vstupnej medzipamäte (cache) získavajú približne 50 % zľavu oproti vstupnej sadzbe, preto je ich sledovanie kľúčové pre pochopenie akéhokoľvek účtu. Nakoniec je tu samotný model: GPT-5.6 Luna je oveľa lacnejší ako GPT-5.6 Sol a tento faktor dominuje všetkým ostatným.
Sledovanie znamená previesť každý objekt usage vrátený API na dolárovú sumu, aplikovať správnu sadzbu a izolovať časť z medzipamäte.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Sadzby za milión tokenov (júl 2026) — cached_input je orientačné (~50 % zo vstupu),
# upravte podľa oficiálneho cenníka
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:
"""Sleduje náklady v reálnom čase."""
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 "Žiadne volania neboli zaznamenané."
return (
f"Volania: {len(self.calls)} | "
f"Celkové náklady: ${self.total_cost:.4f} | "
f"Priemerné náklady: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Tabuľka RATES si vyžaduje neustálu pozornosť: zastará hneď, ako sa zmení oficiálny cenník. Považuj ju za konfiguračné údaje, ktoré treba overovať, nie za programovú konštantu, a urob z priemerných nákladov na volanie metriku, ktorú budeš týždenne kontrolovať.
Štyri páky na znižovanie nákladov
Prvou pákou a zďaleka najvýhodnejšou je vyhnúť sa plateniu za špičkový model, keď úloha jeho výkon nevyžaduje. Explicitné smerovanie založené na zložitosti zabraňuje postupnému driftu, pri ktorom sa všetka premávka skončí na najdrahšom modeli len preto, že sa objavil v prvom skopírovanom príklade.
async def economic_router(prompt: str, complexity: str) -> str:
"""Smeruje na najlacnejší model, ktorý úlohu zvládne."""
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
Druhá páka ide ešte ďalej, keď nie je zložitosť vopred známa. Namiesto klasifikácie požiadavky sa kaskáda najprv pokúsi použiť najlacnejší model a eskaluje len vtedy, ak odpoveď neprejde kontrolou kvality. Kontrola použitá tu je zámerne rudimentárna – minimálna dĺžka a absencia priznania nevedomosti – a práve toto je bod, ktorý budeš musieť vylepšiť: kaskáda, ktorá eskaluje príliš často, sa stane drahšou než priame volanie správneho modelu.
async def model_cascade(prompt: str) -> str:
"""Najprv skúsi najlacnejší model."""
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)
# Kontrola kvality (jednoduchá heuristika)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Posledný výsledok, aj keď nie je dokonalý
Tretia páka cieli na vstupné tokeny, ktoré v akejkoľvek konverzačnej aplikácii ticho rastú: pri dvadsiatom kole platíš za každú správu aj za predchádzajúcich devätnásť. Kompresia histórie zachovaním prvej správy (ktorá drží kontext) a poslednej (ktorá drží otázku) a vyplnením zostávajúceho rozpočtu najnovšími výmenami zachováva základnú koherenciu za zlomok nákladov.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Udrží najnovšie správy v rámci rozpočtu."""
# Vždy zachovaj prvú (kontext) a poslednú (otázka)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Odhad tokenov (aproximácia: 1 token ≈ 4 znaky)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Zachovaj najnovšie správy
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]
Štvrtá páka nevyžaduje algoritmickú finesu, iba disciplínu: Batch API ponúka 50 % zľavu a stačí identifikovať, čo môže počkať. Nechaj úlohu niesť naliehavosť už od jej vytvorenia, namiesto toho, aby si ju odvodzoval dodatočne – toto je jediný spôsob, ako zabrániť tomu, aby všetko implicitne smerovalo do fronty reálneho času.
def classify_urgency(tasks: list[dict]) -> dict:
"""Rozdeľuje úlohy na reálny čas 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, # Príklad
}
Dostať varovanie pred účtom
Všetky tieto optimalizácie môže zničiť jediné nešťastné nasadenie: neobmedzená slučka opakovaných pokusov, strojnásobený systémový prompt alebo omylom zmenený model. Upozornenie na náklady je bezpečnostnou sieťou, ktorá ťa varuje v priebehu hodín, nie až na konci mesiaca. Všimni si stredný prah na 80 %: mení brutálny alarm na včasný signál, ktorý ti dáva čas konať skôr, ako prekročíš limit.
class CostAlert:
"""Spúšťa upozornenia, keď náklady prekročia prah."""
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: denné náklady ${self.tracker.total_cost:.2f} "
f"prekročili prah ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"WARNING: náklady dosiahli {self.tracker.total_cost / self.threshold:.0%} "
f"denného prahu"
)
return None
Kľúčové poznatky
- Sleduj svoje náklady v reálnom čase pomocou
response.usage - Smeruj požiadavky na najlacnejší model, ktorý úlohu zvládne
- Pre všetko, čo nevyžaduje spracovanie v reálnom čase, použi Batch API (-50 %)
- Znižuj počet vstupných tokenov kompresiou histórie
- Nastav si upozornenia na náklady, aby ťa nič neprekvapilo