Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Otimização de Custos em Escala

Aula 10 de 20 Atualizada a 28 de julho de 2026 Avancado
Nesta página
  1. O Custo como Restrição de Engenharia
  2. Saber Para Onde Vai o Dinheiro
  3. Quatro Alavancas de Redução
  4. Ser Alertado Antes da Fatura
  5. Pontos-chave

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