Observabilidade de custos em aplicações com IA

1. Fundamentos da observabilidade financeira em sistemas de IA

A observabilidade de custos em aplicações com inteligência artificial representa a evolução do conceito de FinOps para workloads de machine learning. Diferentemente da observabilidade técnica tradicional — que monitora latência, taxa de erros e throughput —, a observabilidade financeira foca em responder perguntas como: "Quanto custou cada requisição de inferência?", "Qual modelo está consumindo mais recursos financeiros?" e "Onde estão os vazamentos de orçamento?"

O principal desafio está na imprevisibilidade dos custos. Diferente de uma aplicação web tradicional onde o custo por requisição é relativamente estável, em sistemas de IA cada chamada a uma API de modelo proprietário varia conforme o número de tokens de entrada e saída. Além disso, operações como fine-tuning, embeddings e armazenamento em bancos vetoriais adicionam camadas de complexidade financeira.

2. Principais fontes de custo em aplicações com IA

Para implementar observabilidade de custos, é essencial mapear todas as fontes de despesa:

Custos de inferência: Modelos proprietários como GPT-4 e Claude cobram por token processado. Por exemplo, GPT-4 Turbo custa $0.01 por 1k tokens de entrada e $0.03 por 1k tokens de saída. Modelos abertos como Llama 3 podem ser executados localmente, mas exigem infraestrutura de GPU.

Custos de embedding e armazenamento: Serviços como OpenAI Embeddings ($0.0001/1k tokens) e bancos vetoriais como Pinecone ou Weaviate cobram por armazenamento e operações de consulta.

Custos de infraestrutura: GPUs sob demanda (ex: AWS p4d.24xlarge a $32.77/hora) vs. instâncias spot ou dedicadas. Cold starts em serverless podem gerar custos inesperados de inicialização.

Custos ocultos: Rate limiting que força retries, caching ineficiente que duplica chamadas, e prompts longos que consomem mais tokens que o necessário.

// Exemplo: Log estruturado de custo por requisição
{
  "timestamp": "2024-01-15T14:30:00Z",
  "request_id": "req_abc123",
  "model": "gpt-4-turbo",
  "prompt_tokens": 450,
  "completion_tokens": 120,
  "cost_prompt": 0.0045,
  "cost_completion": 0.0036,
  "total_cost": 0.0081,
  "user_id": "usr_456",
  "feature": "chat_corporativo"
}

3. Métricas e indicadores-chave para monitoramento de custos

As métricas essenciais para observabilidade financeira incluem:

  • Custo por requisição: Total de gasto dividido pelo número de chamadas
  • Custo por token: Entrada e saída separadamente, por modelo
  • Taxa de cache hit/miss: Percentual de requisições que puderam ser servidas do cache
  • Token waste ratio: Proporção de tokens gerados mas não utilizados pelo usuário final
  • Custo por operação RAG: Soma do custo de recuperação (embedding + busca vetorial) + geração
// Dashboard de custos em tempo real (pseudo-código Prometheus)
# HELP llm_cost_total Custo total acumulado de chamadas LLM
# TYPE llm_cost_total counter
llm_cost_total{model="gpt-4", environment="production"} 152.34

# HELP llm_cost_per_request Custo médio por requisição
# TYPE llm_cost_per_request gauge
llm_cost_per_request{model="gpt-3.5-turbo"} 0.0023

# HELP cache_hit_ratio Taxa de acerto do cache semântico
# TYPE cache_hit_ratio gauge
cache_hit_ratio{type="semantic"} 0.68

4. Ferramentas e estratégias de instrumentação

A instrumentação para observabilidade de custos requer integração em múltiplas camadas:

Logs estruturados: Cada chamada a modelo de IA deve registrar metadados financeiros. Utilize bibliotecas como structlog (Python) ou Winston (Node.js) para gerar logs JSON enriquecidos.

Dashboards em tempo real: Prometheus + Grafana permitem visualizar custos por modelo, por funcionalidade e por usuário. Ferramentas nativas como AWS Cost Explorer e Azure Cost Management oferecem visões consolidadas.

Integração com APIs de billing: A OpenAI fornece a Usage API que retorna dados de consumo em tempo real. AWS Cost Explorer API permite consultar gastos de instâncias GPU.

// Exemplo: Middleware de captura de custo em Python
import time
from openai import OpenAI

client = OpenAI()

def tracked_completion(messages, model="gpt-3.5-turbo", user_id=None):
    start = time.time()
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    elapsed = time.time() - start

    # Calcular custo baseado no modelo
    cost_per_input_token = 0.0015 / 1000  # GPT-3.5
    cost_per_output_token = 0.002 / 1000

    cost = (response.usage.prompt_tokens * cost_per_input_token +
            response.usage.completion_tokens * cost_per_output_token)

    # Log estruturado
    log_data = {
        "event": "llm_completion",
        "model": model,
        "prompt_tokens": response.usage.prompt_tokens,
        "completion_tokens": response.usage.completion_tokens,
        "cost": round(cost, 6),
        "latency_ms": round(elapsed * 1000, 2),
        "user_id": user_id
    }
    print(json.dumps(log_data))

    return response

5. Otimização de custos baseada em observabilidade

Com dados de observabilidade em mãos, é possível implementar estratégias de otimização:

Roteamento inteligente: Para queries simples (ex: "Qual é o horário de funcionamento?"), utilize modelos menores como GPT-3.5 ou Llama 3 8B. Para consultas complexas, direcione para GPT-4. Um classificador de complexidade pode reduzir custos em até 60%.

Caching semântico: Armazene embeddings e respostas de consultas frequentes. Um cache com 70% de hit ratio pode reduzir custos de inferência drasticamente.

Controle de orçamento por usuário: Defina limites diários ou mensais por tenant. Alertas proativos evitam surpresas na fatura.

// Exemplo: Roteador inteligente de modelos
function routeRequest(query, context) {
    const complexity = analyzeComplexity(query);

    if (complexity === 'simple' && cache.has(query)) {
        return cache.get(query); // Custo zero
    }

    if (complexity === 'simple') {
        return callModel('gpt-3.5-turbo', query); // $0.002/req
    } else if (complexity === 'medium') {
        return callModel('claude-3-haiku', query); // $0.003/req
    } else {
        return callModel('gpt-4', query); // $0.03/req
    }
}

6. Governança e práticas operacionais

A governança de custos em IA exige políticas claras:

Rate limiting por tenant: Em aplicações multi-cliente, implemente quotas diárias. Um cliente que excede 1000 requisições/dia pode ter seu tráfego limitado ou redirecionado para modelos mais baratos.

Revisão periódica de logs: Analise logs de custo semanalmente para identificar anomalias — picos noturnos inexplicáveis, loops de retry, ou usuários que abusam do sistema.

Automação de shutdown: Instâncias GPU ociosas devem ser automaticamente desligadas após período de inatividade. Use AWS Lambda ou Azure Functions para monitorar e agir.

// Política de rate limiting (pseudo-código)
// Por tenant: máximo 500 requisições/dia com GPT-4
// Após limite: fallback para GPT-3.5 ou recusa

const quota = {
  "tenant_abc": { daily_limit_gpt4: 500, daily_used: 0 },
  "tenant_xyz": { daily_limit_gpt4: 100, daily_used: 0 }
};

function checkQuota(tenantId, model) {
  if (model === 'gpt-4' && quota[tenantId].daily_used >= quota[tenantId].daily_limit_gpt4) {
    return 'fallback'; // Redireciona para modelo mais barato
  }
  return 'proceed';
}

7. Estudo de caso e boas práticas em produção

Cenário: Chatbot corporativo com RAG para suporte ao cliente, atendendo 10.000 usuários ativos.

Pipeline de custos:
1. Usuário envia pergunta
2. Sistema verifica cache semântico (hit ratio: 65%)
3. Se cache miss: embedding da query (custo: $0.0001)
4. Busca vetorial no banco (custo: $0.0005)
5. Geração de resposta com LLM (custo: $0.008 para GPT-3.5, $0.04 para GPT-4)

Comparação de cenários:
- Modelo grande sempre (GPT-4 para todas): $0.0406 por requisição → $406/dia para 10k requisições
- Roteamento dinâmico: 60% GPT-3.5, 30% cache hit, 10% GPT-4 → $0.0087 por requisição → $87/dia

Checklist de implantação:
- Antes: Configurar logging de custos, definir orçamentos por funcionalidade
- Durante: Monitorar em tempo real, configurar alertas de estouro
- Depois: Revisar logs semanais, ajustar roteamento com base em padrões de uso

// Métricas pós-implantação do roteamento dinâmico
// Redução de custo: 78.6%
// Custo médio por requisição: de $0.0406 para $0.0087
// Satisfação do usuário: mantida em 94%

Conclusão: A observabilidade de custos não é um luxo, mas uma necessidade para aplicações de IA em produção. Sem ela, empresas podem ter surpresas financeiras que comprometem a viabilidade do negócio. A combinação de logs estruturados, dashboards em tempo real, roteamento inteligente e governança automatizada forma a base para um sistema de IA financeiramente sustentável.

Referências