Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Kosten optimaliseren op schaal

Les 10 van 20 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Kosten als technische beperking
  2. Inzicht in de kostenposten
  3. Vier hefbomen voor reductie
  4. Waarschuwingen voordat de factuur komt
  5. Belangrijkste punten

Kosten als technische beperking

Een slecht geoptimaliseerde prompt die $0,002 per aanroep kost, is verwaarloosbaar tijdens de ontwikkeling. Bij één miljoen aanroepen loopt dit op tot $2.000 – en deze kosten blijven maandelijks terugkeren totdat iemand de code herschrijft. Deze schaalvergroting maakt van kosten een technische beperking: u lost dit niet op door een contract te onderhandelen, maar door de code aan te passen.

Inzicht is de voorwaarde voor elke optimalisatie. Een maandelijkse factuur vertelt u hoeveel u hebt uitgegeven, maar niet waar. Daarom begint deze les met instrumentatie voordat we ingaan op de hefbomen voor kostenreductie.

Inzicht in de kostenposten

Vier elementen bepalen de kosten van een aanroep, en ze gedragen zich niet allemaal hetzelfde. Input-tokens, die de systeemprompt, de conversatiegeschiedenis en het gebruikersbericht samenvoegen, groeien naarmate de sessie langer duurt. Output-tokens – het gegenereerde antwoord – worden aanzienlijk hoger gefactureerd dan input. Gecachete input-tokens krijgen ongeveer 50% korting op het inputtarief, waardoor het volgen hiervan essentieel is om elke factuur te begrijpen. Tot slot is er het model zelf: GPT-5.6 Luna is veel goedkoper dan GPT-5.6 Sol, en deze factor weegt zwaarder dan alle andere.

Bijhouden betekent dat u elk usage-object dat door de API wordt teruggegeven, omzet naar een dollarbedrag, het juiste tarief toepast en het gecachete deel isoleert.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Tarieven per miljoen tokens (juli 2026) — cached_input is indicatief (~50% van input),
# pas aan volgens het officiële prijsoverzicht
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:
    """Houdt kosten in realtime bij."""
    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 "Geen aanroepen geregistreerd."
        return (
            f"Aanroepen: {len(self.calls)} | "
            f"Totale kosten: ${self.total_cost:.4f} | "
            f"Gemiddelde kosten: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

De RATES-tabel vereist constante aandacht: deze wordt verouderd zodra het officiële prijsoverzicht wijzigt. Behandel dit als configuratiegegevens die u moet verifiëren, niet als een programmaconstante, en maak van de gemiddelde kosten per aanroep een metric die u wekelijks controleert.

Vier hefbomen voor reductie

De eerste hefboom, en verreweg de meest rendabele, is voorkomen dat u betaalt voor een hoogwaardig model wanneer de taak dit niet vereist. Expliciete routering op basis van complexiteit voorkomt de standaardafwijking waarbij al het verkeer eindigt bij het duurste model, simpelweg omdat dit in het eerste gekopieerde voorbeeld stond.

async def economic_router(prompt: str, complexity: str) -> str:
    """Routeert naar het goedkoopste model dat de taak aankan."""
    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

De tweede hefboom gaat verder wanneer de complexiteit niet van tevoren bekend is. In plaats van het verzoek te classificeren, probeert de cascade eerst het goedkoopste model en escaleert alleen als het antwoord niet slaagt voor een kwaliteitscontrole. De controle die hier wordt gebruikt is bewust rudimentair – een minimumlengte en de afwezigheid van een toegeving van onwetendheid – en dit is het punt dat u zult moeten verfijnen: een cascade die te vaak escaleert, wordt duurder dan een directe aanroep van het juiste model.

async def model_cascade(prompt: str) -> str:
    """Probeert eerst het goedkoopste 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)

        # Controleer kwaliteit (eenvoudige heuristic)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Laatste resultaat, ook als het niet perfect is

De derde hefboom richt zich op input-tokens, die in elke conversationele applicatie stilletjes groeien: bij de twintigste beurt betaalt u bij elk bericht opnieuw voor de vorige negentien. Door de geschiedenis te comprimeren – het eerste bericht (dat de context bevat) en het laatste (dat de vraag bevat) behouden, en het resterende budget vullen met de meest recente uitwisselingen – behoudt u de essentiële coherentie tegen een fractie van de kosten.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Behoudt de meest recente berichten binnen het budget."""
    # Bewaar altijd het eerste (context) en laatste (vraag) bericht
    if len(messages) <= 2:
        return messages

    first = messages[0]
    last = messages[-1]
    middle = messages[1:-1]

    # Schat tokens (benadering: 1 token ≈ 4 tekens)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Bewaar de meest recente berichten
    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]

De vierde hefboom vereist geen algoritmische finesse, alleen discipline: de Batch API biedt een reductie van 50%, en u hoeft alleen maar te identificeren wat kan wachten. Laat de taak zelf de urgentie dragen vanaf het moment van creatie, in plaats van deze achteraf af te leiden – dit is de enige manier om te voorkomen dat alles standaard naar de realtime-wachtrij gaat.

def classify_urgency(tasks: list[dict]) -> dict:
    """Scheidt taken in realtime versus 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,  # Voorbeeld
    }

Waarschuwingen voordat de factuur komt

Al deze optimalisaties kunnen teniet worden gedaan door één enkele ongelukkige deployment: een onbegrensde retry-lus, een verdrievoudigde systeemprompt, een model dat per ongeluk is gewijzigd. Een kostenalert is het veiligheidsnet dat u binnen enkele uren waarschuwt in plaats van aan het einde van de maand. Let op de tussenliggende drempel van 80%: dit verandert een hard alarm in een vroeg signaal, zodat u tijd hebt om actie te ondernemen voordat u de limiet overschrijdt.

class CostAlert:
    """Activeert alerts wanneer kosten een drempel overschrijden."""

    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: dagelijkse kosten ${self.tracker.total_cost:.2f} "
                f"overschrijdt drempel van ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"WAARSCHUWING: kosten op {self.tracker.total_cost / self.threshold:.0%} "
                f"van de dagelijkse drempel"
            )
        return None

Belangrijkste punten

  • Houd uw kosten in realtime bij met behulp van response.usage
  • Routeer naar het goedkoopste model dat de taak aankan
  • Gebruik de Batch API (-50%) voor alles wat geen realtime verwerking vereist
  • Verminder input-tokens door de geschiedenis te comprimeren
  • Stel kostenalerts in om verrassingen te voorkomen