Optimera kostnader i stor skala
På denna sida
Kostnad som en teknisk begränsning
En dåligt optimerad prompt som kostar 0,002 USD per anrop är försumbar under utvecklingen. Vid en miljon anrop kostar den 2 000 USD – och den kommer att fortsätta kosta dig det varje månad tills någon skriver om den. Denna skalförändring gör kostnad till en teknisk begränsning: du löser den inte genom att förhandla om ett avtal, du löser den genom att ändra koden.
Synlighet är en förutsättning för all optimering. En månadsfaktura berättar hur mycket du spenderat, inte varför. Därför börjar denna lektion med instrumentering innan vi går igenom hävstänger för kostnadsreducering.
Att veta vart pengarna tar vägen
Fyra element bestämmer kostnaden för ett anrop, och de beter sig inte på samma sätt. Inmatningstokens, som aggregerar systemprompten, konversationshistoriken och användarens meddelande, växer med sessionens längd. Utmatningstokens – det genererade svaret – debiteras betydligt högre än inmatning. Cachade inmatningstokens får ungefär 50 % rabatt på inmatningspriset, vilket gör spårningen av dem avgörande för att förstå någon faktura. Slutligen själva modellen: GPT-5.6 Luna är betydligt billigare än GPT-5.6 Sol, och denna faktor dominerar alla andra.
Spårning innebär att omvandla varje usage-objekt som returneras av API:t till ett dollarbelopp, tillämpa rätt pris och isolera den cachade delen.
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 ständig uppmärksamhet: den blir föråldrad så snart den officiella prislistan ändras. Behandla den som konfigurationsdata som måste verifieras, inte som en programkonstant, och gör genomsnittskostnaden per anrop till en metrik du granskar varje vecka.
Fyra hävstänger för reducering
Den första hävstången, och långt den mest lönsamma, är att undvika att betala för en högvärdig modell när uppgiften inte kräver det. Explicit routning baserad på komplexitet förhindrar den glidande förändring där all trafik hamnar på den dyraste modellen helt enkelt för att den dök upp i det första kopierade exemplet.
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 andra hävstången går längre när komplexiteten inte är känd i förväg. Istället för att klassificera begäran försöker kaskaden med den billigaste modellen först och eskalerar endast om svaret misslyckas med en kvalitetskontroll. Kontrollen som används här är avsiktligt rudimentär – en minimilängd och frånvaron av ett erkännande av okunnighet – och detta är punkten du behöver förfina: en kaskad som eskalerar för ofta blir dyrare än ett direktanrop till rätt modell.
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 hävstången riktar in sig på inmatningstokens, som växer tyst i varje konversationsapplikation: vid det tjugonde svaret betalar du för de tidigare nitton vid varje meddelande. Genom att komprimera historiken genom att behålla det första meddelandet (som innehåller kontext) och det sista (som innehåller frågan), och sedan fylla återstående budget med de senaste utbytena, bevaras väsentlig sammanhang till en bråkdel av kostnaden.
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 fjärde hävstången kräver ingen algoritmisk finess, bara disciplin: Batch API:t erbjuder en reduktion på 50 %, och du behöver bara identifiera vad som kan vänta. Låt uppgiften själv bära på brådskan från sin skapelse, istället för att härleda den efteråt – detta är det enda sättet att förhindra att allt som standard hamnar i realtidskön.
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
}
Att få varning innan fakturan kommer
Alla dessa optimeringar kan omintetgöras av en enda olycklig distribution: en obegränsad retry-loop, en tredubblad systemprompt, en modell som ändrats av misstag. En kostnadslarm är säkerhetsnätet som varnar dig inom timmar istället för vid månadsskiftet. Observera den mellanliggande tröskeln vid 80 %: den förvandlar ett brutalt larm till en tidig signal, vilket ger dig tid att agera innan gränsen överskrids.
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
Viktiga punkter
- Spåra dina kostnader i realtid med hjälp av
response.usage - Routa till den billigaste modell som klarar uppgiften
- Använd Batch API:t (-50 %) för allt som inte kräver realtidsbearbetning
- Minska inmatningstokens genom att komprimera historiken
- Ställ in kostnadslarm för att undvika överraskningar