Optimering af omkostninger i stor skala
På denne side
Omkostninger som en teknisk begrænsning
En dårligt optimeret prompt, der koster $0,002 pr. kald, er ubetydelig under udviklingen. Ved én million kald løber regningen op på $2.000 – og den vil fortsætte med at koste dig det hver eneste måned, indtil nogen omskriver koden. Dette skift i skala gør omkostninger til en teknisk begrænsning: Du løser det ikke ved at forhandle en kontrakt, men ved at ændre koden.
Synlighed er en forudsætning for enhver optimering. En månedlig regning fortæller dig, hvor meget du har brugt, ikke hvor. Derfor starter denne lektion med instrumentering, før vi dækker de muligheder, der kan reducere omkostningerne.
At vide, hvor pengene bliver af
Fire elementer bestemmer omkostningerne ved et kald, og de opfører sig ikke ens. Input-tokens, som samler system-prompten, samtalehistorikken og brugerens besked, vokser med sessionens varighed. Output-tokens – det genererede svar – faktureres betydeligt højere end input. Cachet input-tokens får cirka 50 % rabat på input-prisen, hvilket gør sporing af dem afgørende for at forstå enhver regning. Endelig selve modellen: GPT-5.6 Luna er langt billigere end GPT-5.6 Sol, og denne faktor dominerer alle andre.
Sporing betyder at konvertere hvert usage-objekt, der returneres af API’et, til et dollarbeløb, anvende den korrekte sats og isolere den cachede del.
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()
Tabellen RATES kræver konstant opmærksomhed: Den bliver forældet, så snart den officielle prisliste ændres. Behandle den som konfigurationsdata, der skal verificeres, ikke som en programkonstant, og gør den gennemsnitlige omkostning pr. kald til en metrik, du gennemgår ugentligt.
Fire løftestænger til reduktion
Den første løftestang – og langt den mest profitable – er at undgå at betale for en højtydende model, når opgaven ikke kræver det. Eksplicit routing baseret på kompleksitet forhindrer den standardmæssige drift, hvor al trafik ender på den dyreste model, blot fordi den optrådte i det første kopierede eksempel.
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
Den anden løftestang går videre, når kompleksiteten ikke er kendt på forhånd. I stedet for at klassificere anmodningen, prøver kaskaden den billigste model først og eskalerer kun, hvis svaret fejler et kvalitetscheck. Checket, der bruges her, er bevidst rudimentært – en minimumslængde og fraværet af en indrømmelse af uvidenhed – og det er her, du skal finpudse: En kaskade, der eskalerer for ofte, bliver dyrere end et direkte kald til den rigtige model.
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
Den tredje løftestang målretter input-tokens, som vokser lydløst i enhver samtaleapplikation: Ved det tyvende svar betaler du for de foregående nitten med hver eneste besked. Komprimering af historikken ved at beholde den første besked (som indeholder konteksten) og den sidste (som indeholder spørgsmålet) og derefter fylde det resterende budget med de seneste udvekslinger, bevarer den væsentlige sammenhængskraft til en brøkdel af omkostningerne.
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]
Den fjerde løftestang kræver ingen algoritmisk finesse, kun disciplin: Batch-API’et tilbyder en reduktion på 50 %, og du skal blot identificere, hvad der kan vente. Lad selve opgaven bære hastegraden fra sin oprettelse i stedet for at udlede den bagefter – det er den eneste måde at forhindre, at alt som standard havner i realtidskøen.
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
}
At blive advaret før regningen kommer
Alle disse optimeringer kan blive gjort til skamme af en enkelt uheldig deployment: En ubegrænset genforsøgsløkke, en system-prompt, der er tredoblet, eller en model, der er ændret ved en fejl. En omkostningsalarm er sikkerhedsnettet, der advarer dig inden for timer i stedet for ved månedens udgang. Bemærk den mellemliggende tærskel på 80 %: Den omdanner en brutal alarm til et tidligt signal, der giver dig tid til at handle, før du overskrider grænsen.
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
Vigtige pointer
- Spor dine omkostninger i realtid ved hjælp af
response.usage - Rout til den billigste model, der er i stand til at løse opgaven
- Brug Batch-API’et (-50 %) til alt, der ikke kræver realtidsbehandling
- Reducer input-tokens ved at komprimere historikken
- Opsæt omkostningsalarmer for at undgå overraskelser