Optimizing Costs at Scale
Ar an leathanach seo
An costas mar shriant innealtóireachta
Ní mórán rud é leid atá optamaithe go dona a chosnaíonn $0.002 in aghaidh an ghlao le linn forbartha. Ag milliún glao, cosnaíonn sé $2,000 — agus leanfaidh sé ort ag cur an méid sin ort gach mí go dtí go ndéanfaidh duine éigin é a athscríobh. Tiontaíonn an t-athrú scála seo an costas ina shriant innealtóireachta: ní réitíonn tú é trí chonradh a idirbheartú, ach trí chód a athrú.
Is é an infheictheacht an réamhriachtanas d’aon optamú. Insíonn bille míosúil duit cé mhéad a chaith tú, ní cá háit. Sin an fáth a dtosaíonn an ceacht seo le hionstraimiú sula gclúdaítear na luamháin laghdaithe.
A fhios cá dtéann an t-airgead
Ceithre ghné a chinneann costas glao, agus ní oibríonn siad ar an mbealach céanna. Fásann comharthaí ionchuir, a dhéanann achoimre ar an leid córais, ar stair an chomhrá agus ar theachtaireacht an úsáideora, de réir mar a fhadóidh an seisiún. Tá comharthaí aschuir — an freagra ginte — praghsáilte i bhfad níos airde ná comharthaí ionchuir. Faigheann comharthaí ionchuir sa taisce lascaine thart ar 50% den ráta ionchuir, rud a fhágann go bhfuil a rianú riachtanach chun aon bille a thuiscint. Ar deireadh, an tsamhail féin: tá GPT-5.6 Luna i bhfad níos saoire ná GPT-5.6 Sol, agus sáraíonn an fachtóir seo gach ceann eile.
Ciallaíonn rianú gach oibiacht usage a thugtar ar ais ag an API a thiontú go méid dollar, an ráta ceart a chur i bhfeidhm, agus an chuid sa taisce a aonrú.
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()
Éilíonn an tábla RATES aire leanúnach: beidh sé as dáta chomh luath agus a athróidh an ghreille praghsála oifigiúil. Déileáil leis mar shonraí cumraíochta le seiceáil, ní mar thairiseach cláir, agus déan meánchostas in aghaidh an ghlao ina mhéadracht a dhéanann tú athbhreithniú uirthi go seachtainiúil.
Ceithre luamhán le haghaidh laghdaithe
Is é an chéad luamhán, agus an ceann is brabúsaí i bhfad, ná íoc as samhail ardleibhéil nuair nach n-éilíonn an tasc í. Cuireann ródaireacht shainráite bunaithe ar chastacht cosc ar an sreabhadh réamhshocraithe ina gcríochnaíonn an trácht go léir ar an tsamhail is costasaí toisc gur léirigh sí sa chéad sampla a cóipeáladh.
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
Téann an dara luamhán níos faide nuair nach bhfuil a fhios roimh ré cé chomh casta agus atá an rud. In ionad an t-iarratas a aicmiú, déanann an t-easairthí triail ar an tsamhail is saoire ar dtús agus déanann sé éalú amháin má theipeann ar an bhfreagra seiceáil cáilíochta. Is bunúsach go leor an seiceáil a úsáidtear anseo — fad íosta agus easpa admhála aineolais — agus is é seo an pointe a bheidh ort a bheachtú: éiríonn easairthí a dhéanann éalú rómhinic níos costasaí ná glao díreach chuig an tsamhail cheart.
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
Díríonn an tríú luamhán ar chomharthaí ionchuir, a fhásann go ciúin in aon fheidhmchlár comhrá: faoin fichiú casadh, tá tú ag íoc as an naoi gcinn déaga roimhe sin le gach teachtaireacht. Trí stair a chomhbhrú trí an chéad teachtaireacht (a choinníonn an comhthéacs) agus an ceann deireanach (a choinníonn an cheist) a choinneáil, agus ansin an buiséad atá fágtha a líonadh leis na malartuithe is déanaí, caomhnaítear comhleanúnachas riachtanach ar chodán den chostas.
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]
Ní éilíonn an ceathrú luamhán aon scil algartamach, ach smacht amháin: tairgeann an Batch API laghdú 50%, agus níl le déanamh agat ach a aithint cad is féidir fanacht. Lig don tasc féin práinn a iompar óna chruthú, seachas é a dhíorthú ina dhiaidh sin — is é seo an t-aon bhealach chun cosc a chur ar gach rud dul go réamhshocraithe chuig an scuaine fíor-ama.
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
}
Rabhadh a fháil roimh an mbille
Is féidir leis na hoptamuithe seo go léir a bheith curtha ar ceal ag imlonnú amháin mí-ádhúil: lúb athiarrtha gan teorainn, leid córais faoi thrí, samhail a athraíodh de thaisme. Is é an foláireamh costais an líon sábháilteachta a thugann rabhadh duit laistigh d’uair an chloig seachas ag deireadh na míosa. Tabhair faoi deara an tairseach idirmheánach ag 80%: tiontaíonn sé aláram brúidiúil ina chomhartha luath, ag tabhairt ama duit gníomhú sula sáraíonn tú an teorainn.
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
Príomhphointí
- Rianaigh do chostais i bhfíor-am ag baint úsáide as
response.usage - Ródáil chuig an tsamhail is saoire atá in ann an tasc a dhéanamh
- Úsáid an Batch API (-50%) d’aon rud nach n-éilíonn próiseáil fíor-ama
- Laghdaigh comharthaí ionchuir trí stair a chomhbhrú
- Socraigh foláirimh costais chun iontais a sheachaint