Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Monitoraġġ tal-ispejjeż u l-użu

Lezzjoni 16 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Monitoraġġ tal-ispejjeż u l-użu
  2. Fehim tal-fatturazzjoni
  3. Kalkolatur tal-ispejjeż
  4. Traċċar tal-ispejjeż f’ħin reali
  5. Klijent b’kontroll tal-baġit
  6. Ottimizzazzjoni tal-ispejjeż
  7. Punti Ewlenin

Monitoraġġ tal-ispejjeż u l-użu

L-ispejjeż tal-API jistgħu joħorġu mill-kontroll malajr ħafna jekk ma tħarisx lejhom. Din il-lezzjoni tgħallmek kif issegwi, tistma, u tikkontrolla n-nefqa tiegħek fil-produzzjoni. L-istorja tirrepeti ruħha minn proġett għal ieħor: karatteristika tidħol ħajja nhar il-Ħamis, ħadd ma jiċċekkja d-dashboard matul il-ġimgħa, u l-kont ta’ nhar it-Tnejn filgħodu jkun daqs il-baġit sħiħ tax-xahar. Il-passi hawn taħt jgħinuk taqbad id-devjazzjoni tal-ispejjeż hekk kif iseħħu, mhux tletin jum wara.

Fehim tal-fatturazzjoni

L-ispejjeż jiġu kkalkulati għal kull miljun token, bi prezzijiet differenti għall-input u l-output. Din l-asimmetrija għandha konsegwenzi diretti fuq il-għażliet tad-disinn tiegħek: li tibgħat dokument twil bħala input jiswef ferm inqas milli tħalli l-mudell jiġġenera wieħed twil. Kull tweġiba tirritorna l-għadd eżatt għaż-żewġ direzzjonijiet, allura qatt m’għandek bżonn tistma.

from openai import OpenAI
client = OpenAI()

# Every response includes usage metrics
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain OpenAI API billing."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")

# Output costs more than input!

Kalkolatur tal-ispejjeż

Il-konverżjoni ta’ dawn il-kontaturi f’dollari teħtieġ gradilja tal-prezzijiet. Iżolaha f’struttura ddedikata minflok ma tferrex kostanti madwar il-kodiċi tiegħek: meta jinbidlu l-prezzijiet jew iżżid mudell, ikollok bżonn timmodifika linja waħda biss. Ir-rati hawn taħt huma indikattivi u għandhom jiġu vverifikati matul kull reviżjoni tal-baġit.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Approximate prices in USD per million tokens
# Always check current prices on platform.openai.com/pricing
RATES = {
    "gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
    "gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
    "gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}

def calculate_cost(model: str, input_tokens: int,
                   output_tokens: int) -> float:
    """Calculates the cost of a call in USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unknown model: {model}")

    input_cost = (input_tokens / 1_000_000) * rate.input_per_million
    output_cost = (output_tokens / 1_000_000) * rate.output_per_million

    return input_cost + output_cost

# Example
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Result: Cost: $0.008000

Tmienja minn għaxra ta’ ċenteżmu għal kull sejħa tidher rassiguranti sakemm timmultiplikaha bl-ħamsin elf sejħa kuljum ta’ chatbot fil-produzzjoni—dik hija erba’ mitt dollaru kuljum. Dejjem idda l-abitudni li taħseb f’volumi mensili, qatt mhux għal kull sejħa.

Traċċar tal-ispejjeż f’ħin reali

Il-kalkoli tal-unitajiet huma inutili jekk ma jiġux aggregati. Dan it-traċċar jaggrega n-nefqa fuq tliet assi—skont il-jum, skont il-mudell, u skont in-numru ta’ sejħiet—u jqabbel it-total tal-jum ma’ baġit li tkun stabbilejt. L-allerti huma gradwati: twissija meta jifdal inqas minn 20% tal-baġit, segwita minn allert iebsa meta tinqabeż il-limitu. Dan il-pass intermedjarju huwa prezzjuż għax jagħtik ħin biex tintervjeni qabel ma jitqatta’ s-servizz.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Real-time API cost tracking."""

    def __init__(self, daily_budget_usd: float = 10.0):
        self.daily_budget = daily_budget_usd
        self.costs_per_day: dict[str, float] = defaultdict(float)
        self.costs_per_model: dict[str, float] = defaultdict(float)
        self.calls_per_day: dict[str, int] = defaultdict(int)
        self.total_tokens = 0

    def record(self, model: str, input_tokens: int,
               output_tokens: int):
        """Records the costs of a call."""
        cost = calculate_cost(model, input_tokens, output_tokens)
        today = date.today().isoformat()

        self.costs_per_day[today] += cost
        self.costs_per_model[model] += cost
        self.calls_per_day[today] += 1
        self.total_tokens += input_tokens + output_tokens

        return cost

    def remaining_budget(self) -> float:
        """Returns the remaining budget for today."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Checks if the budget is close to the limit."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALERT: Daily budget exceeded!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNING: ${remaining:.2f} remaining on daily budget")
            return True
        return False

    def report(self) -> dict:
        """Generates a cost report."""
        return {
            "total_cost_usd": sum(self.costs_per_day.values()),
            "cost_today_usd": self.costs_per_day.get(
                date.today().isoformat(), 0
            ),
            "remaining_budget_usd": self.remaining_budget(),
            "costs_per_model": dict(self.costs_per_model),
            "total_tokens": self.total_tokens,
        }

# Usage
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Klijent b’kontroll tal-baġit

Il-monitoraġġ mhux dejjem biżżejjed: quddiem loop difettuża li ssejjaħ l-API kontinwament, għandek bżonn “circuit breaker” finanzjarju. Dan il-klijent jiċċekkja l-baġit li fadal qabel ma joħroġ it-talba u jirrifjuta ċ-ċar is-sejħa jekk l-invilupp ikun eżawrit. Is-servizz jiddeterjora, iżda b’mod ikkontrollat mingħajr kontijiet sorprendenti. Il-kontabbiltà tal-ispejjeż iseħħ wara, ladarba l-użu attwali jkun magħruf.

class BudgetControlledClient:
    """Client that refuses calls if the budget is exceeded."""

    def __init__(self, daily_budget: float = 10.0):
        self.client = OpenAI()
        self.tracker = CostTracker(daily_budget_usd=daily_budget)

    def create(self, model: str, input: str, **kwargs) -> object:
        """API call with budget control."""
        # Check budget before the call
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Daily budget exhausted. "
                f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
            )

        response = self.client.responses.create(
            model=model,
            input=input,
            **kwargs
        )

        cost = self.tracker.record(
            model=model,
            input_tokens=response.usage.input_tokens,
            output_tokens=response.usage.output_tokens
        )

        # Alert if budget is low
        self.tracker.budget_alert()

        return response

# Usage
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Hello!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blocked: {e}")

Ottimizzazzjoni tal-ispejjeż

1. Għażla tal-mudell it-tajjeb

Il-leva l-aktar qawwija tibqa’ r-routing skont il-kumplessità. Kompitu ta’ klassifikazzjoni fi tliet kategoriji m’għandux bżonn l-aktar mudell għali: għal dan il-kompitu, id-differenza fil-kont tilħaq fattur ta’ ħamsa u għoxrin għal kwalità identika. Agħmel il-kumplessità parametru espliċitu tal-funzjoni tiegħek minflok deċiżjoni mwaħħla fil-loġika.

# Relative cost per task (approximate, ~300 input tokens / 20 output):
# Simple classification: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# The right model makes a 25x difference in costs!

def optimized_call(prompt: str, complexity: str) -> str:
    """Chooses the most economical suitable model."""
    model = {
        "simple": "gpt-5.6-luna",
        "standard": "gpt-5.6-terra",
        "complex": "gpt-5.6-sol",
    }.get(complexity, "gpt-5.6-terra")

    response = client.responses.create(model=model, input=prompt)
    return response.output_text

2. Caching tat-tweġibiet

It-tieni leva hija li tevita li tħallas darbtejn għall-istess tweġiba. FAQ, katalogu tal-prodotti, jew formola standard jiġġeneraw prompts identiċi għalkollox għexieren ta’ drabi kuljum. Iċ-ċavetta tal-cache tgħaqqad il-mudell, l-input, u l-parametri—li tinkludihom kollha huwa essenzjali, inkella bidla fit-temperatura tirritorna silenzjużament it-tweġiba l-qadima.

import hashlib

class CachedClient:
    """Client with cache to avoid redundant calls."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Create a cache key
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache hit!")
            return self.cache[cache_key]

        response = self.client.responses.create(
            model=model, input=input, **kwargs
        )

        self.cache[cache_key] = response.output_text
        return response.output_text

3. Limitazzjoni tat-tokens tal-output

Fl-aħħar nett, poġġi limitu fuq l-output kull meta t-tul tiegħu jkun prevedibbli. Peress li l-output huwa l-parti għalja, li titlob kelma waħda waqt li tawtorizza elfejn token iħalli l-bieb miftuħ għal tweġiba verbali li tħallas għaliha iżda ma tużahiex.

# Always set max_output_tokens for predictable tasks
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Expecting a single word
)

Rati sal-5 ta’ Awwissu 2026 — il-prezzijiet jinbidlu regolarment: qabel kwalunkwe kalkolu tal-baġit, ivverifika l-gradilja attwali fuq il-paġna uffiċjali tal-prezzijiet ta’ OpenAI.

Punti Ewlenin

  • L-ispejjeż jiddependu mill-mudell U d-direzzjoni (input vs output)
  • Implimenta traċċar tal-ispejjeż b’allerti tal-baġit
  • Uża l-mudell it-tajjeb għal kull kompitu: Luna għall-volum, Terra b’mod default
  • Il-caching jista’ jnaqqas drammatikament l-ispejjeż għal talbiet ripetittivi
  • Stabbilixxi max_output_tokens meta t-tul tat-tweġiba jkun prevedibbli
  • Iċċekkja d-dashboard ta’ OpenAI għat-traċċar uffiċjali tal-konsum