Ottimizzazzjoni tal-Ispejjeż fuq Skala Kbira
F'din il-paġna
L-Ispejjeż bħala Vincolu tal-Inġinerija
Prompt mhux ottimizzat li jiswa $0.002 għal kull sejħa huwa negliġibbli waqt l-iżvilupp. F’miljun sejħa, jiswak $2,000—u se jkompli jiswa daqshekk kull xahar sakemm xi ħadd ma jiktebuh mill-ġdid. Din il-bidla fl-iskala tbiddel l-ispiża f’vincolu tal-inġinerija: ma ssolvihx billi tinnegozja kuntratt, issolvih billi tbiddel il-kodiċi.
Il-viżibbiltà hija l-prerekwiżit għal kwalunkwe ottimizzazzjoni. Kont finali ta’ kull xahar jgħidlek kemm nefqt, mhux fejn. Għalhekk din il-lezzjoni tibda bl-istrumentazzjoni qabel ma tkopri l-levi għat-tnaqqis.
Fejn Qed Imur il-Flus
Erba’ elementi jiddeterminaw l-ispiża ta’ sejħa, u dawn ma jaġixxux bl-istess mod. It-tokens tal-input, li jiġbru flimkien il-prompt tas-sistema, l-istorja tal-konversazzjoni u l-messaġġ tal-utent, jikbru mat-tul tas-sessjoni. It-tokens tal-output—ir-risposta ġġenerata—jiġu ffrattati b’mod sinifikanti ogħla mill-input. It-tokens tal-input fil-cache jirċievu skont ta’ madwar 50% mir-rata tal-input, u għalhekk it-traċċar tagħhom huwa essenzjali biex tifhem kwalunkwe kont. Fl-aħħar nett, il-mudell innifsu: GPT-5.6 Luna huwa ferm irħas minn GPT-5.6 Sol, u dan il-fattur jiddomina lill-oħrajn kollha.
It-traċċar ifisser li tikkonverti kull oġġett usage irritornat mill-API f’ammont ta’ dollaru, tapplika r-rata korretta, u tiżola l-parti fil-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()
It-tabella RATES teħtieġ attenzjoni kostanti: issir antika malli tinbidel il-grilja uffiċjali tal-prezzijiet. Itrattaha bħala data ta’ konfigurazzjoni li trid tiċċekkja, mhux bħala kostanti tal-programm, u agħmel l-ispiża medja għal kull sejħa metrika li tirrevedi kull ġimgħa.
Erba’ Levi għat-Tnaqqis
L-ewwel leva, u sa issa l-aktar profittabbli, hija li tevita li tħallas għal mudell high-end meta l-kompitu ma jeħtiġihx. Ir-rottaġġ espliċitu bbażat fuq il-kumplessità jipprevjeni d-deriva awtomatika fejn it-traffiku kollu jispiċċa fuq l-aktar mudell għali sempliċiment għax deher fl-ewwel eżempju kkupjat.
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
It-tieni leva tmur aktar ‘il quddiem meta l-kumplessità ma tkunx magħrufa minn qabel. Minflok ma tikklassifika t-talba, il-kaskata tipprova l-aktar mudell irħas l-ewwel u titla’ biss jekk ir-risposta tonqos minn kontroll tal-kwalità. Iċ-ċekk użat hawnhekk huwa deliberatament rudimentali—tul minimu u n-nuqqas ta’ ammissjoni ta’ injoranza—u dan huwa l-punt li trid tirfina: kaskata li titla’ wisq spiss issir aktar għolja minn sejħa diretta għall-mudell it-tajjeb.
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
It-tielet leva timmira lejn it-tokens tal-input, li jikbru b’mod silenzjuż f’kwalunkwe applikazzjoni konversazzjonali: sal-għoxrin dawra, tkun qed tħallas għad-dsatax-il preċedenti ma’ kull messaġġ. Il-kompressjoni tal-istorja billi żżomm l-ewwel messaġġ (li fih il-kuntest) u l-aħħar wieħed (li fih il-mistoqsija), imbagħad timla l-bqija tal-baġit bl-iskambji l-aktar riċenti, tippreżerva l-koerenza essenzjali bi frazzjoni tal-ispiża.
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]
Ir-raba’ leva ma teħtieġ l-ebda finesse algoritmika, biss dixxiplina: il-Batch API toffri tnaqqis ta’ 50%, u trid biss tidentifika x’jista’ jistenna. Ħalli l-kompitu nnifsu jġorr l-urġenza mill-ħolqien tiegħu, minflok ma tiddeduċiha wara—din hija l-unika mod biex tipprevjeni li kollox jidderiva awtomatikament lejn il-kjuw f’ħin reali.
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
}
Li Tirċievi Twissija Qabel il-Kont
L-ottimizzazzjonijiet kollha jistgħu jiġu mħassra b’dispjegament wieħed mix-xorti ħażina: loop ta’ retry mingħajr limitu, prompt tas-sistema mtripplikat, mudell mibdel bi żball. Allerta tal-ispejjeż hija x-xibka ta’ sigurtà li twissik fi żmien sigħat minflok fl-aħħar tax-xahar. Innota l-limitu intermedjarju f’80%: dan ibiddel allarma brutali f’sinjal bikri, u jagħtik il-ħin biex taġixxi qabel ma taqbeż il-limitu.
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 Ewlenin
- Ittraċċa l-ispejjeż tiegħek f’ħin reali bl-użu ta’
response.usage - Agħmel rotta lejn l-aktar mudell irħas kapaċi għall-kompitu
- Uża l-Batch API (-50%) għal kull ma ma jeħtiġx ipproċessar f’ħin reali
- Naqqas it-tokens tal-input billi tikkompressa l-istorja
- Ippara allerti tal-ispejjeż biex tevita sorpriżi