Optimizacija stroškov v velikem obsegu
Na tej strani
Stroški kot inženirska omejitev
Slabo optimiziran poziv, ki stane 0,002 $ na klic, je med razvojem zanemarljiv. Pri milijonu klicev to znaša 2.000 $ – in ta znesek boš plačeval vsak mesec, dokler ga nekdo ne bo prepisal. Ta premik v obsegu spremeni strošek v inženirsko omejitev: ne rešiš ga s pogajanji o pogodbi, temveč s spremembo kode.
Vidljivost je predpogoj za vsako optimizacijo. Mesečni račun ti pove, koliko si porabil, ne pa kje. Zato se ta lekcija začne z instrumentacijo, šele nato pa obravnava vzvode za zmanjšanje stroškov.
Vedeti, kam gre denar
Štirje elementi določajo strošek klica in se ne obnašajo enako. Vhodni žetoni, ki združujejo sistemski poziv, zgodovino pogovora in uporabnikovo sporočilo, rastejo s trajanjem seje. Izhodni žetoni – ustvarjeni odgovor – so zaračunani bistveno dražje od vhodnih. Predpomnjeni vhodni žetoni prejmejo približno 50-odstotni popust glede na vhodno ceno, zato je njihovo sledenje ključno za razumevanje katerega koli računa. Nazadnje, sam model: GPT-5.6 Luna je veliko cenejši od GPT-5.6 Sol in ta dejavnik prevlada nad vsemi drugimi.
Sledenje pomeni pretvorbo vsakega predmeta usage, ki ga vrne API, v dolarje, uporabo pravilne stopnje in izolacijo predpomnjenega dela.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Stopnje na milijon žetonov (julij 2026) — cached_input je okvirna (~50 % vhodne),
# prilagodi glede na uradni cenik
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:
"""Sledi stroškom v realnem času."""
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 "Ni zabeleženih klicev."
return (
f"Klici: {len(self.calls)} | "
f"Skupni strošek: ${self.total_cost:.4f} | "
f"Povprečni strošek: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Tabela RATES zahteva stalno pozornost: zastara takoj, ko se spremeni uradni cenik. Obravnavaj jo kot konfiguracijske podatke, ki jih je treba preverjati, ne kot programske konstante, in povprečni strošek na klic naj bo metrika, ki jo pregleduješ tedensko.
Štirje vzvodi za zmanjšanje
Prvi in daleč najbolj donosen vzvod je izogibanje plačevanju vrhunskega modela, ko naloga tega ne zahteva. Izrecno usmerjanje glede na kompleksnost prepreči privzeto drsenje, pri katerem ves promet konča na najdražjem modelu zgolj zato, ker se je pojavil v prvem kopiranem primeru.
async def economic_router(prompt: str, complexity: str) -> str:
"""Usmeri na najcenejši zmogljiv 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
Drugi vzvod gre še dlje, ko kompleksnost ni vnaprej znana. Namesto razvrščanja zahteve kaskada najprej preizkusi najcenejši model in eskalira le, če odgovor ne opravi preverjanja kakovosti. Preverjanje, uporabljeno tukaj, je namerno osnovno – minimalna dolžina in odsotnost priznanja nevednosti – in to je točka, ki jo boš moral izpopolniti: kaskada, ki prepogosto eskalira, postane dražja od neposrednega klica pravemu modelu.
async def model_cascade(prompt: str) -> str:
"""Najprej preizkusi najcenejši 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)
# Preveri kakovost (preprosta hevristika)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Zadnji rezultat, tudi če ni popoln
Tretji vzvod cilja na vhodne žetone, ki tiho rastejo v vsaki pogovorni aplikaciji: do dvajsetega obrata z vsakim sporočilom znova plačuješ za prejšnjih devetnajst. Stiskanje zgodovine tako, da obdržiš prvo sporočilo (ki vsebuje kontekst) in zadnje (ki vsebuje vprašanje), preostali proračun pa zapolniš z najnovejšimi izmenjavami, ohrani bistveno koherenco le za delček stroška.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Ohrani najnovejša sporočila znotraj proračuna."""
# Vedno obdrži prvo (kontekst) in zadnje (vprašanje)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Oceni žetone (približek: 1 žeton ≈ 4 znake)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Obdrži najnovejša sporočila
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]
Četrti vzvod ne zahteva algoritmične finesse, le disciplino: Batch API ponuja 50-odstotno zmanjšanje, identificirati moraš le, kaj lahko počaka. Naj naloga sama nosi nujnost že od svoje ustvaritve, namesto da bi jo sklepal naknadno – to je edini način, da preprečiš, da bi vse privzeto končalo v čakalni vrsti za realni čas.
def classify_urgency(tasks: list[dict]) -> dict:
"""Loči naloge na tiste za realni čas in paketne."""
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, # Primer
}
Opozorilo pred računom
Vse te optimizacije lahko uniči en sam nesrečen uvajanje: neomejena zanka za ponovne poskuse, potrojeno sistemsko pozivanje, pomota pri spremembi modela. Opozorilo o stroških je varnostna mreža, ki te opozori v nekaj urah, ne šele ob koncu meseca. Upoštevaj vmesni prag pri 80 %: brutalni alarm spremeni v zgodnji signal, ki ti da čas za ukrepanje, preden presežeš omejitev.
class CostAlert:
"""Sproži opozorila, ko stroški presežejo prag."""
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"OPOZORILO: dnevni strošek ${self.tracker.total_cost:.2f} "
f"presega prag ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"OPOZORILO: strošek pri {self.tracker.total_cost / self.threshold:.0%} "
f"dnevnega praga"
)
return None
Ključne ugotovitve
- Sledi svojim stroškom v realnem času z uporabo
response.usage - Usmerjaj na najcenejši model, ki zmore opravilo
- Uporabi Batch API (-50 %) za vse, kar ne zahteva obdelave v realnem času
- Zmanjšaj vhodne žetone s stiskanjem zgodovine
- Nastavi opozorila o stroških, da se izogneš presenečenjem