Kosten optimaliseren op schaal
Op deze pagina
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