AI / LLM
LLM cost budgets: код и cost-арифметика
Суть Читай реальный код учёта token и ценовую арифметику, предсказывай расход и выбирай фикс с наибольшим рычагом — cost-арифметика, per-tenant budget, routing и cache savings.
Высота — путь к senior
НольJuniorMiddleSenior
Ты на senior-высоте — в орбитеCost-инциденты диагностируются в счётчиках token и ценовой математике, а не в прозе. Прочитай код и числа, затем выбери фикс, который senior-инженер сделает первым.
Цель
Отработай цикл, который ты запускаешь на каждом скачке расходов: прочитай место вызова, посчитай per-token арифметику в уме, найди, где утекает budget, и потянись за фиксом с наибольшим рычагом раньше, чем поднимешь любой cap.
Сниппет 1 — per-turn cost-арифметика
// Sonnet 4.6: $3 / 1M вход, $15 / 1M выход
const PRICE = { in: 3 / 1e6, out: 15 / 1e6 };
// сессия на 50 ходов, system prompt на 4000 token повторно каждый ход,
// history растёт ~600 token/ход, каждый ответ ~400 output token.
let inputTotal = 0;
for (let turn = 1; turn <= 50; turn++) {
const history = 600 * (turn - 1);
inputTotal += 4000 + history; // system prompt + накопленный history
}
const outputTotal = 50 * 400;
const cost = inputTotal * PRICE.in + outputTotal * PRICE.out; Викторина
Completed
Какое утверждение о стоимости этой сессии верно?
Heads-up Per-token выход 5x, но output-token всего 20 000 (~$0.30) против ~935 000 input-token (~$2.80). Объём бьёт rate здесь — повторно отправляемый префикс и растущий history затмевают выход.
Heads-up System prompt постоянен, но history растёт ~600 token/ход, так что per-turn вход поднимается с 4000 до ~33 400. Сумма квадратична по числу ходов, а не плоская.
Heads-up Stateless-модель повторно отправляет полный префикс каждый ход, если не prompt-кэшировать его. Здесь он оплачен все 50 раз — 200 000 token — главная цель для caching.
Сниппет 2 — per-tenant budget enforcement
async function callModel(tenantId: string, req: Request) {
const spent = await budget.getMonthlySpend(tenantId); // async-чтение
if (spent >= LIMIT[tenantId]) throw new BudgetExceeded();
const res = await llm.create(req); // биллит token
await budget.add(tenantId, costOf(res)); // запись после
return res;
} Викторина
Completed
У этого per-tenant budget-гарда есть дефект, который вскроет всплеск конкурентных запросов. Какой и в чём фикс?
Heads-up await отдаёт управление event loop — он не сериализует между конкурентными запросами. Несколько вызовов в полёте читают один и тот же pre-update spend и все проходят проверку. Это классическая check-then-act гонка.
Heads-up Запись после необходима, ведь истинную стоимость в token знаешь только из ответа. Дефект — неатомарный read-check-write, а не тайминг записи; зарезервируй оценку, затем сверь.
Heads-up Per-tenant лимиты верны для честного изолированного cost-контроля. Дефект — concurrency-safety и отсутствие per-request cap, а не гранулярность лимита.
Сниппет 3 — решение о model routing
// Haiku $1/$5, Opus $5/$25 (за 1M вход/выход). Средняя задача: 1k вход, 500 выход.
const opusOnly = 1000 * 5/1e6 + 500 * 25/1e6; // сразу на Opus
// Cascade: сначала Haiku; при провале платим ещё и Opus. p = escalation rate.
function cascade(p) {
const haiku = 1000 * 1/1e6 + 500 * 5/1e6;
const opus = 1000 * 5/1e6 + 500 * 25/1e6;
return haiku + p * opus; // Haiku платим всегда
} Викторина
Completed
opusOnly ≈ $0.0175/задача. При каком escalation rate p cascade перестаёт экономить деньги?
Heads-up При p = 0.5 cascade = 0.0035 + 0.5 × 0.0175 = $0.01225, всё ещё ниже $0.0175 Opus-only. Break-even по стоимости ~0.8; операционный порог ниже, но не 0.5.
Heads-up Только пока p достаточно мал. Так как ты всегда платишь за Haiku плюс долю за Opus, высокий escalation rate делает cascade дороже Opus-only — break-even здесь p ≈ 0.8.
Heads-up При p ≈ 0.2 ещё экономишь по стоимости ($0.0035 + 0.2 × 0.0175 ≈ $0.007). Цифра ~30% — алярм по качеству/latency, а не cost break-even, который для этих чисел ~0.8.
Сниппет 4 — расчёт cache savings
// Anthropic: cache read = 0.1x базового входа; 5-мин write = 1.25x базового входа.
// Стабильный префикс = 10 000 token, базовый вход $3/1M, переиспользуется N ходов.
function prefixCost(N: number, cached: boolean) {
const base = 10000 * 3/1e6; // полноценная отправка
if (!cached) return N * base; // повторно каждый ход
const write = 10000 * (3 * 1.25)/1e6; // одна cache write
const read = 10000 * (3 * 0.1)/1e6; // каждая cache read
return write + (N - 1) * read;
} Викторина
Completed
Для префикса на 10 000 token, переиспользуемого 50 ходов, сколько примерно экономит caching и когда окупается?
Heads-up 0.1x — это per-read rate, а не итог экономии. За 50 ходов ты заменяешь 50 полноценных отправок на одну write 1.25x плюс 49 чтений по 0.1x — примерно 88% сокращения на префиксе, не 10%.
Heads-up Write 1.25x платится один раз. Уже ко второму ходу итог write-плюс-read (~1.35x) бьёт две полноценные отправки (2x); за 50 ходов чтения 0.1x доминируют и экономишь ~88%.
Heads-up Prompt caching удешевляет повторно отправляемый вход — стабильный префикс. Выход генерируется заново каждый ход и не кэшируется, так что экономия целиком на повторяемом входном префиксе.
Итог
Каждое cost-решение читается в счётчиках и арифметике: повторно отправляемый префикс плюс растущий history делают долгую сессию квадратичной по входу; per-tenant budget-гард должен быть атомарным (reserve/commit) и в паре с per-request cap, иначе гонки конкурентности пробьют лимит; cascade Haiku→Opus экономит лишь пока escalation rate низок (cost break-even ~0.8, операционный алярм ~30%); а prompt-кэширование префикса 10k за 50 ходов режет ~88% и окупается на первом попадании. Сначала посчитай, затем чини самый большой член — обычно повторно отправляемый context — раньше, чем тронешь cap.