Objetivo da Aula
Ao concluir esta aula, você será capaz de:
Calcular custo por query e custo por mês para qualquer modelo de LLM
Implementar comparar_modelos(cenario) para comparar toda a oferta de modelos
Implementar analise_sensibilidade(cenario, variacao) para simular variações de volume
Identificar o threshold onde modelos mais caros se tornam viáveis (ROI)
Estruturar análise de custo como argumento de negócio para escolha de modelo
Por que isso importa
Empresas escolhem modelos de LLM por performance em benchmarks, não por custo em produção. Um modelo 3x mais preciso que custa 10x mais pode ser inviável em 6 meses quando o volume escala. Análise de sensibilidade mostra o custo em 3 cenários (conservador, realista, agressivo) antes que a decisão seja irreversível.
Conceitos Fundamentais
FinOps: Modelo de Custo por Query e Análise de Sensibilidade
A planilha de FinOps de LLM: tokens de input médios × preço_input + tokens de output médios × preço_output = custo/query. Multiplicado pelo volume mensal = custo/mês por modelo. Monte a matriz para pelo menos 3 modelos (barato/médio/caro) nos eixos custo × qualidade × latência. Análise de sensibilidade: calcule para 0.5×, 1×, 1.5× e 2× o volume projetado. O ponto onde o modelo caro se justifica é quando o ganho de qualidade gera receita ou reduz custo de suporte suficiente para cobrir a diferença. Decisão crítica: benchmarks de qualidade (MMLU, HumanEval) não predizem custo em produção — construa seu próprio benchmark com tarefas reais do seu domínio e meça custo real por tarefa.
Estrutura de Preço de LLMs
MODELOS = {
"claude-haiku-4-5-20251001": {
"custo_input_1k": 0.00025, # $ por 1000 tokens de input
"custo_output_1k": 0.00125, # $ por 1000 tokens de output
"latencia_media_s": 1.2,
"qualidade_score": 7, # 1-10, avaliação interna
},
"claude-sonnet-4-6": {
"custo_input_1k": 0.003,
"custo_output_1k": 0.015,
"latencia_media_s": 2.5,
"qualidade_score": 9,
},
"claude-opus-4-8": {
"custo_input_1k": 0.015,
"custo_output_1k": 0.075,
"latencia_media_s": 5.0,
"qualidade_score": 10,
},
"gpt-4o-mini": {
"custo_input_1k": 0.00015,
"custo_output_1k": 0.0006,
"latencia_media_s": 1.0,
"qualidade_score": 6,
},
"gpt-4o": {
"custo_input_1k": 0.005,
"custo_output_1k": 0.015,
"latencia_media_s": 2.0,
"qualidade_score": 9,
},
}TODO 1: comparar_modelos(cenario)
def comparar_modelos(cenario: dict) -> list[dict]:
"""
cenario: {
"tokens_input_por_query": int,
"tokens_output_por_query": int,
"queries_por_dia": int,
}
Retorna lista de modelos ordenados por custo_mes crescente.
"""
queries_mes = cenario["queries_por_dia"] * 30
tokens_in = cenario["tokens_input_por_query"]
tokens_out = cenario["tokens_output_por_query"]
resultados = []
for nome, config in MODELOS.items():
# Custo por query (em dólares)
custo_query = (
(tokens_in / 1000) * config["custo_input_1k"] +
(tokens_out / 1000) * config["custo_output_1k"]
)
# Custo mensal total
custo_mes = custo_query * queries_mes
resultados.append({
"modelo": nome,
"custo_query_usd": round(custo_query, 6),
"custo_mes_usd": round(custo_mes, 2),
"latencia_s": config["latencia_media_s"],
"qualidade_score": config["qualidade_score"],
})
# Ordenar por custo mensal (mais barato primeiro)
resultados.sort(key=lambda x: x["custo_mes_usd"])
# Marcar o mais barato
if resultados:
resultados[0]["mais_barato"] = True
return resultadosTODO 2: analise_sensibilidade(cenario, variacao=0.5)
def analise_sensibilidade(cenario: dict, variacao: float = 0.5) -> dict:
"""
Simula o custo em 4 volumes: 0.5x, 1.0x, 1.5x, 2.0x o volume base.
variacao: passo entre cenários (default 0.5)
"""
fatores = [variacao, 1.0, 1 + variacao, 1 + 2 * variacao]
# → [0.5, 1.0, 1.5, 2.0] com variacao=0.5
resultado = {}
for fator in fatores:
# Criar cenário com volume ajustado
cenario_ajustado = dict(cenario)
cenario_ajustado["queries_por_dia"] = int(cenario["queries_por_dia"] * fator)
# Comparar todos os modelos neste volume
comparacao = comparar_modelos(cenario_ajustado)
# Extrair custo mensal por modelo
resultado[f"{fator:.1f}x"] = {
item["modelo"]: item["custo_mes_usd"]
for item in comparacao
}
return resultadoAprofundamento Técnico
Além do Custo por Token: TCO Completo
Custo Total de Propriedade (TCO) de um sistema de IA:
Custo de inferência (modelo): tokens × preço
Custo de desenvolvimento: eng_hours × custo_hora
Custo de manutenção/monitoramento: eng_hours_mes × custo_hora × 12
Custo de fallback/reliability: failover_cost
Custo de compliance: DPO, RIPD, auditoria
Custo de retrabalho (erros): taxa_erro × impacto_financeiro
TCO = soma de todos os acima ao longo de 12 meses
Um modelo 30% mais barato por token mas com 5% mais taxa de erro
pode custar 3x mais em TCO (custo de erros).Quando o Modelo Caro Vale a Pena
def calcular_roi_modelo_premium(
custo_mes_basico: float, # ex: 100
custo_mes_premium: float, # ex: 1000
taxa_erro_basico: float, # ex: 0.05 = 5%
taxa_erro_premium: float, # ex: 0.01 = 1%
custo_por_erro: float, # ex: 500 (suporte, churn, etc.)
queries_mes: int, # ex: 10000
) -> dict:
custo_erros_basico = taxa_erro_basico * queries_mes * custo_por_erro
custo_erros_premium = taxa_erro_premium * queries_mes * custo_por_erro
custo_total_basico = custo_mes_basico + custo_erros_basico
custo_total_premium = custo_mes_premium + custo_erros_premium
return {
"custo_total_basico": custo_total_basico,
"custo_total_premium": custo_total_premium,
"modelo_premium_vale": custo_total_premium < custo_total_basico,
"economia_mensal": custo_total_basico - custo_total_premium,
}Exemplos Anotados
Exemplo 1: Comparação para Chatbot de Suporte
cenario_suporte = {
"tokens_input_por_query": 500, # prompt + histórico
"tokens_output_por_query": 200, # resposta
"queries_por_dia": 1000,
}
resultados = comparar_modelos(cenario_suporte)
# gpt-4o-mini: $0.000195/query → $5.85/mês ← mais barato
# claude-haiku-4-5: $0.000375/query → $11.25/mês
# gpt-4o: $0.005500/query → $165.00/mês
# claude-sonnet-4-6: $0.004500/query → $135.00/mês
# claude-opus-4-8: $0.022500/query → $675.00/mêsExemplo 2: Sensibilidade ao Crescimento
sensibilidade = analise_sensibilidade(cenario_suporte)
# {
# "0.5x": {"gpt-4o-mini": 2.93, "claude-haiku": 5.63, "claude-opus": 337.50, ...},
# "1.0x": {"gpt-4o-mini": 5.85, "claude-haiku": 11.25, "claude-opus": 675.00, ...},
# "1.5x": {"gpt-4o-mini": 8.78, "claude-haiku": 16.88, "claude-opus": 1012.50, ...},
# "2.0x": {"gpt-4o-mini": 11.70, "claude-haiku": 22.50, "claude-opus": 1350.00, ...},
# }
# Insight: se crescer 2x, claude-opus passa de $675 → $1350/mês
# Com 1M queries/dia (escala enterprise): $675k/mês → inviávelPadrões e Armadilhas
Padrões
Padrão 1: Começar com o modelo mais barato, escalar com dados
Haiku para P0 → medir taxa de erro → se > threshold → subir para Sonnet
Nunca começar com Opus sem benchmark de custo em produçãoPadrão 2: Calcular sensibilidade ANTES de decidir
# Pergunta certa: "Se crescermos 3x, o custo ainda é aceitável?"
# Não: "Qual modelo é mais barato hoje?"
analise = analise_sensibilidade(cenario, variacao=0.5)
# Verificar se custo em 2.0x ainda cabe no orçamentoArmadilhas
⚠️ Armadilha 1: Ignorar tokens de sistema
# System prompt de 500 tokens × 1000 queries/dia = 500k tokens extras/dia
# Em claude-opus: +$7.50/dia = +$225/mês só no system prompt
# Sempre incluir system_prompt nos tokens_input_por_query⚠️ Armadilha 2: Tokens de output variam muito
Resposta esperada: "Sim, pode pedir" = 5 tokens
Resposta real gerada: parágrafo de 200 tokens
Medir output REAL em amostra de produção antes de projetar custo⚠️ Armadilha 3: Cache não é gratuito
Prompt cache do Claude: 90% de desconto nos tokens cacheados
Mas requer hit rate > 80% para valer
Se queries têm pouca sobreposição: cache não ajudaCom o modelo financeiro em mãos, você tem os critérios para defender decisões de arquitetura e escolha de modelo — a Parte XI integra tudo num projeto completo do conceito ao produto entregue.
Se não for realizar o laboratório, pule para o próximo capítulo.
Ponte para o Lab
TODO 1 — comparar_modelos(cenario): - Iterar MODELOS.items() - Para cada modelo: custo_query = (tokens_in/1000) × custo_input_1k + (tokens_out/1000) × custo_output_1k - custo_mes = custo_query × queries_por_dia × 30 - Retornar lista ordenada por custo_mes crescente
TODO 2 — analise_sensibilidade(cenario, variacao=0.5): - fatores = [variacao, 1.0, 1+variacao, 1+2*variacao] - Para cada fator: copiar cenário, multiplicar queries_por_dia pelo fator, chamar comparar_modelos - Retornar dict {fator_str: {modelo: custo_mes}}
Agora você está pronto para o lab.