Оптимизиране на разходите в мащаб
На тази страница
Разходите като инженерно ограничение
Лошо оптимизиран подкан, струващ $0.002 на заявка, е пренебрежим по време на разработка. При един милион заявки обаче цената става $2,000 – и ще продължи да Ви струва толкова всеки месец, докато някой не го пренапише. Тази промяна в мащаба превръща разхода в инженерно ограничение: не го решавате чрез преговори за договор, а чрез промяна на кода.
Видимостта е предпоставка за всяка оптимизация. Месечната фактура Ви показва колко сте похарчили, но не и къде. Затова този урок започва с инструментиране, преди да премине към лостовете за намаляване.
Да знаете къде отиват парите
Четири елемента определят цената на една заявка и те не се държат по един и същи начин. Входните токени, които обединяват системния подкан, историята на разговора и съобщението на потребителя, нарастват с продължителността на сесията. Изходните токени – генерираният отговор – се таксуват значително по-високо от входните. Кешiranите входни токени получават отстъпка от приблизително 50% спрямо тарифата за вход, което прави проследяването им от съществено значение за разбирането на всяка фактура. И накрая, самият модел: GPT-5.6 Luna е много по-евтин от GPT-5.6 Sol и този фактор доминира над всички останали.
Проследяването означава превръщане на всеки обект usage, върнат от API, в доларова сума, прилагане на правилната тарифа и изолиране на кешirаната част.
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()
Таблицата RATES изисква постоянно внимание: тя остарява веднага щом официалната ценова листа се промени. Третирайте я като конфигурационни данни за проверка, а не като програмна константа, и направете средната цена на заявка метрика, която преглеждате седмично.
Четири лоста за намаляване
Първият лост и далеч най-печелившият е избягването на плащане за модел от висок клас, когато задачата не го изисква. Изричното насочване въз основа на сложността предотвратява стандартното отклонение, при което целият трафик попада на най-скъпия модел просто защото се е появил в първия копиран пример.
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
Вторият лост отива по-далеч, когато сложността не е известна предварително. Вместо да класифицирате заявката, каскадата първо пробва най-евтиния модел и ескалира само ако отговорът не премине проверка за качество. Проверката, използвана тук, е умишлено елементарна – минимална дължина и липса на признание за незнание – и това е точката, която ще трябва да усъвършенствате: каскада, която ескалира твърде често, става по-скъпа от директна заявка към правилния модел.
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
Третият лост цели входните токени, които нарастват незабележимо във всяко конферентно приложение: до двадесетия завой Вие плащате отново за предишните деветнадесет с всяко съобщение. Компресирането на историята чрез запазване на първото съобщение (което съдържа контекста) и последното (което съдържа въпроса), след което запълване на останалия бюджет с най-скорошните размени, запазва съществената кохерентност за част от цената.
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]
Четвъртият лост не изисква алгоритмична финес, а само дисциплина: Batch API предлага намаление от 50% и просто трябва да идентифицирате какво може да изчака. Нека самата задача носи спешността от своето създаване, вместо да я изводите впоследствие – това е единственият начин да предотвратите всичко по подразбиране да попада в опашката за реално време.
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
}
Предупреждение преди фактурата
Всички тези оптимизации могат да бъдат унищожени от едно единствено неуспешно внедряване: цикъл на повторни опити без ограничения, утроен системен подкан, модел, променен по грешка. Известлението за разходи е защитната мрежа, която Ви предупреждава в рамките на часове, а не в края на месеца. Обърнете внимание на междинния праг от 80%: той превръща бруталната аларма в ранен сигнал, давайки Ви време да действате, преди да надвишите лимита.
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
Ключови изводи
- Проследявайте разходите си в реално време, използвайки
response.usage - Насочвайте към най-евтиния модел, способен да изпълни задачата
- Използвайте Batch API (-50%) за всичко, което не изисква обработка в реално време
- Намалете входните токени чрез компресиране на историята
- Настройте известия за разходи, за да избегнете изненади