Custos da API OpenAI: Como Otimizar

APIs de LLMs podem ficar muito caras se você não prestar atenção. Este guia te ensina a entender e otimizar custos sem sacrificar qualidade.

Preços Atuais (Janeiro 2025)

Preços podem mudar. Verifique em openai.com/pricing

Entendendo Tokens

O que é um token?
- ~4 caracteres em inglês
- ~2-3 caracteres em português
- 1 palavra ≈ 1.3 tokens

Exemplos:
"Olá" = 1 token
"Inteligência Artificial" = 3 tokens
"Como fazer um bolo de chocolate?" = 8 tokens

Para contar tokens:
import tiktoken
enc = tiktoken.encoding_for_model("gpt-4")
tokens = enc.encode("seu texto aqui")
print(len(tokens))

Calculando Custos

# Exemplo: Chatbot de suporte

Média por request:
- System prompt: ~200 tokens
- Histórico (5 mensagens): ~500 tokens  
- User message: ~50 tokens
- Response: ~200 tokens

Total por request:
- Input: ~750 tokens
- Output: ~200 tokens

Com GPT-4o:
- Input: 750 * $5 / 1M = $0.00375
- Output: 200 * $15 / 1M = $0.003
- Total: ~$0.007 por request

10.000 requests/dia:
- $0.007 * 10.000 = $70/dia
- ~$2.100/mês

Com GPT-4o-mini:
- ~$0.0003 por request
- ~$3/dia = ~$90/mês

Diferença: 23x mais barato!

Estratégias de Otimização

1. Escolher o Modelo Certo

Nem toda task precisa do GPT-4!

USE GPT-4o:
- Raciocínio complexo
- Código difícil
- Tasks críticas

USE GPT-4o-mini:
- Classificação
- Extração de dados
- Respostas simples
- Alto volume

USE GPT-3.5:
- Tasks muito simples
- Quando custo é crítico

Estratégia: Router por complexidade
if task.complexity == "high":
    model = "gpt-4o"
else:
    model = "gpt-4o-mini"

2. Caching de Respostas

import redis
import hashlib

redis_client = redis.Redis()

def get_cached_or_call(messages: list, model: str):
    # Criar key única
    key = hashlib.md5(
        f"{model}:{str(messages)}".encode()
    ).hexdigest()
    
    # Verificar cache
    cached = redis_client.get(key)
    if cached:
        return cached.decode()  # GRÁTIS!
    
    # Chamar API
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    
    result = response.choices[0].message.content
    
    # Cachear por 1 hora
    redis_client.setex(key, 3600, result)
    
    return result

# Cache pode economizar 30-50% em apps típicos!

3. Semantic Caching

# Cache por similaridade, não só match exato

from langchain.cache import GPTCache

# Perguntas similares retornam mesma resposta:
# "Qual o prazo de entrega?" ≈ "Quanto tempo demora para entregar?"

def similarity_based_cache(query: str):
    # Buscar queries similares no cache
    similar = find_similar_in_cache(query, threshold=0.95)
    
    if similar:
        return similar.response
    
    # Se não encontrou, chamar API
    response = call_llm(query)
    
    # Salvar no cache com embedding
    save_to_cache(query, response)
    
    return response

4. Prompts Mais Curtos

# Cada token conta!

❌ Prompt verboso (200 tokens):
"Você é um assistente de atendimento ao cliente muito 
prestativo e educado. Sua função é ajudar os clientes
com dúvidas sobre nossos produtos e serviços. Sempre
responda de forma clara e objetiva..."

✅ Prompt conciso (50 tokens):
"Assistente de suporte. Responda de forma clara e direta.
Produtos: [lista]. Políticas: [resumo]."

Economia: 75% só no system prompt!

5. Limitar Tamanho de Resposta

# Controlar max_tokens

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    max_tokens=150  # Limitar resposta
)

# Também no prompt:
"Responda em no máximo 2 frases."
"Seja conciso."

6. Batch Requests

# Se não precisa de resposta imediata, use batch

from openai import OpenAI

# Batch API (50% mais barato!)
batch_input = [
    {"messages": [{"role": "user", "content": "Query 1"}]},
    {"messages": [{"role": "user", "content": "Query 2"}]},
    # ...
]

# Submeter batch
batch = client.batches.create(
    input_file_id=file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"  # Resposta em até 24h
)

# Batch = 50% desconto, mas não é real-time

Monitoramento de Custos

# Sempre monitore!

import logging

logger = logging.getLogger(__name__)

def call_with_tracking(messages, model):
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    
    # Calcular custo
    input_tokens = response.usage.prompt_tokens
    output_tokens = response.usage.completion_tokens
    
    cost = calculate_cost(model, input_tokens, output_tokens)
    
    logger.info(f"API call: model={model}, "
                f"tokens={input_tokens}+{output_tokens}, "
                f"cost=$" + "{cost:.4f}")
    
    # Enviar para métricas (Datadog, etc.)
    metrics.increment("openai.calls")
    metrics.gauge("openai.cost", cost)
    
    return response

# Dashboard de custos:
# - Custo por dia/semana/mês
# - Custo por endpoint/feature
# - Alertas quando passar do budget

Alternativas Mais Baratas

Se custo é crítico, considere:

1. CLAUDE (Anthropic)
   - Claude 3.5 Sonnet: $3 input, $15 output (por 1M)
   - Qualidade similar ao GPT-4

2. GEMINI (Google)
   - Gemini 1.5 Flash: Muito barato
   - Bom para alto volume

3. OPEN SOURCE (Llama, Mistral)
   - Custo = infraestrutura
   - Sem custo por token
   - Together.ai, Groq = APIs baratas

4. FINE-TUNED SMALLER MODEL
   - Fine-tune GPT-3.5 para sua task
   - Pode superar GPT-4 em tasks específicas

Checklist de Otimização

□ Usando modelo certo para cada task?
□ Cache implementado?
□ Prompts são concisos?
□ max_tokens definido?
□ Histórico de conversa está limitado?
□ Batch para tasks não-urgentes?
□ Monitoramento de custos ativo?
□ Alertas de budget configurados?
□ Considerou alternativas mais baratas?