Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Optimizing Costs at Scale

Ceacht 10 as 20 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. An costas mar shriant innealtóireachta
  2. A fhios cá dtéann an t-airgead
  3. Ceithre luamhán le haghaidh laghdaithe
  4. Rabhadh a fháil roimh an mbille
  5. Príomhphointí

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