Otimização de Custos em Escala
Nesta página
O Custo como Restrição de Engenharia
Um prompt mal otimizado que custa $0,002 por chamada é negligenciável durante o desenvolvimento. Com um milhão de chamadas, o custo sobe para $2.000 — e continuará a custar-lhe esse valor todos os meses até que alguém o reescreva. Esta mudança de escala transforma o custo numa restrição de engenharia: não se resolve negociando um contrato, resolve-se alterando o código.
A visibilidade é o pré-requisito para qualquer otimização. Uma fatura mensal indica quanto gastou, não onde. É por isso que esta lição começa com instrumentação antes de abordar as alavancas de redução.
Saber Para Onde Vai o Dinheiro
Quatro elementos determinam o custo de uma chamada e não se comportam da mesma forma. Os tokens de entrada, que agregam o prompt do sistema, o histórico da conversa e a mensagem do utilizador, crescem com a duração da sessão. Os tokens de saída — a resposta gerada — são faturados significativamente mais caro que os de entrada. Os tokens de entrada em cache beneficiam de um desconto de aproximadamente 50% sobre a tarifa de entrada, tornando o seu acompanhamento essencial para compreender qualquer fatura. Por fim, o próprio modelo: o GPT-5.6 Luna é muito mais barato que o GPT-5.6 Sol, e este fator domina todos os outros.
Acompanhar significa converter cada objeto usage devolvido pela API num valor em dólares, aplicar a tarifa correta e isolar a parte em cache.
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()
A tabela RATES exige atenção constante: torna-se desatualizada assim que a grelha de preços oficial muda. Trate-a como dados de configuração a verificar, não como uma constante do programa, e faça do custo médio por chamada uma métrica que revê semanalmente.
Quatro Alavancas de Redução
A primeira alavanca, e de longe a mais rentável, é evitar pagar por um modelo de gama alta quando a tarefa não o exige. O encaminhamento explícito baseado na complexidade previne a deriva padrão onde todo o tráfego acaba no modelo mais caro simplesmente porque apareceu no primeiro exemplo copiado.
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
A segunda alavanca vai mais longe quando a complexidade não é conhecida antecipadamente. Em vez de classificar o pedido, a cascata tenta primeiro o modelo mais barato e escala apenas se a resposta falhar numa verificação de qualidade. A verificação usada aqui é deliberadamente rudimentar — um comprimento mínimo e a ausência de admissão de ignorância — e é neste ponto que terá de refinar: uma cascata que escala demasiado frequentemente torna-se mais cara do que uma chamada direta ao modelo certo.
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
A terceira alavanca visa os tokens de entrada, que crescem silenciosamente em qualquer aplicação conversacional: na vigésima troca, está a pagar pelas dezanove anteriores com cada mensagem. Comprimir o histórico mantendo a primeira mensagem (que detém o contexto) e a última (que detém a pergunta), preenchendo depois o orçamento restante com as trocas mais recentes, preserva a coerência essencial a uma fração do custo.
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]
A quarta alavanca não exige finesse algorítmica, apenas disciplina: a Batch API oferece uma redução de 50%, e só precisa de identificar o que pode esperar. Deixe que a própria tarefa carregue a urgência desde a sua criação, em vez de a deduzir afterward — esta é a única forma de impedir que tudo seja encaminhado por defeito para a fila em tempo real.
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
}
Ser Alertado Antes da Fatura
Todas estas otimizações podem ser desfeitas por uma única implementação infeliz: um ciclo de repetição sem limites, um prompt do sistema triplicado, um modelo alterado por engano. Um alerta de custo é a rede de segurança que o avisa em horas e não no final do mês. Note o limiar intermédio a 80%: transforma um alarme brutal num sinal precoce, dando-lhe tempo para agir antes de exceder o limite.
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
Pontos-chave
- Acompanhe os seus custos em tempo real usando
response.usage - Encaminhe para o modelo mais barato capaz de realizar a tarefa
- Utilize a Batch API (-50%) para tudo o que não exija processamento em tempo real
- Reduza os tokens de entrada comprimindo o histórico
- Configure alertas de custo para evitar surpresas