Reduza Custos de LLM: Estratégias de Otimização de Tokens

Reduza os custos de LLMs em 80% com otimização inteligente de tokens

Conteúdo da página

A otimização de tokens é a habilidade crucial que separa aplicações de LLMs com custo-efetividade de experimentos que drenam o orçamento.

Como os custos da API escalam linearmente com o uso de tokens, a compreensão e a implementação de estratégias de otimização podem reduzir despesas em 60-80% mantendo a qualidade.

Laços de agentes auto-hospedados adicionam uma segunda fatura em tokens de conclusão desperdiçados quando a amostragem é muito alta (temperatura quente); parâmetros de inferência agêntica para Qwen e Gemma coleta padrões que inibem novas tentativas sem comprometer o raciocínio. Essas novas tentativas ficam caras mais rápido quando os laços de reparo de saída estruturada ecoam prompts inteiros — esquemas rigorosos e rejeições de validação rápidas ajudam, como em Validação de saída estruturada de LLM em Python que se sustenta.

smart architecture

Entendendo a Economia de Tokens

Antes de otimizar, você precisa entender como os tokens e a precificação funcionam entre diferentes provedores de LLMs.

Fundamentos de Tokens

Tokens são as unidades fundamentais que os LLMs processam - aproximadamente equivalentes a 4 caracteres ou 0,75 palavras em inglês. A string “Hello, world!” contém aproximadamente 4 tokens. Diferentes modelos usam diferentes tokenizadores (GPT usa tiktoken, Claude usa o seu próprio), então as contagens de tokens variam ligeiramente entre provedores.

Comparação de Modelos de Precificação

Preços da OpenAI (em 2025):

  • GPT-4 Turbo: $0,01 entrada / $0,03 saída por 1K tokens
  • GPT-3.5 Turbo: $0,0005 entrada / $0,0015 saída por 1K tokens
  • GPT-4o: $0,005 entrada / $0,015 saída por 1K tokens

Preços da Anthropic:

  • Claude 3 Opus: $0,015 entrada / $0,075 saída por 1K tokens
  • Claude 3 Sonnet: $0,003 entrada / $0,015 saída por 1K tokens
  • Claude 3 Haiku: $0,00025 entrada / $0,00125 saída por 1K tokens

Para uma comparação abrangente dos Provedores de LLMs na Nuvem incluindo preços detalhados, recursos e casos de uso, confira nosso guia dedicado.

Insight Chave: Tokens de saída custam de 2 a 5 vezes mais que tokens de entrada. Limitar o comprimento da saída tem um impacto desproporcional nos custos.

Engenharia de Prompts para Eficiência

A engenharia de prompts eficaz reduz drasticamente o consumo de tokens sem sacrificar a qualidade.

1. Eliminar Redundância

Exemplo Ruim (127 tokens):

You are a helpful assistant. Please help me with the following task.
I would like you to analyze the following text and provide me with
a summary. Here is the text I would like you to summarize:
[text]
Please provide a concise summary of the main points.

Otimizado (38 tokens):

Summarize the key points:
[text]

Economia: Redução de 70% dos tokens, qualidade de saída idêntica.

2. Usar Formatos Estruturados

JSON e saídas estruturadas reduzem o desperdício de tokens causado por linguagem natural verbosa.

Em vez de:

Please extract the person's name, age, and occupation from this text
and format your response clearly.

Use:

Extract to JSON: {name, age, occupation}
Text: [input]

3. Otimização de Aprendizado Pouco-Aplicado (Few-Shot)

Exemplos few-shot são poderosos, mas caros. Otimize ao:

  • Usar o número mínimo de exemplos necessários (1-3 geralmente são suficientes)
  • Manter exemplos concisos - remova palavras desnecessárias
  • Compartilhar prefixos comuns - reduza instruções repetidas
# Optimized few-shot prompt
prompt = """Classify sentiment (pos/neg):
Text: "Great product!" -> pos
Text: "Disappointed" -> neg
Text: "{user_input}" ->"""

Para mais padrões de otimização em Python e atalhos de sintaxe, veja nosso Folha de Dicas Python.

Estratégias de Cache de Contexto

O cache de contexto é a otimização individualmente mais eficaz para aplicações com conteúdo estático repetido.

Como Funciona o Cache de Contexto

Provedores como OpenAI e Anthropic fazem o cache dos prefixes de prompts que aparecem em múltiplas requisições. Porções em cache custam de 50 a 90% a menos que tokens regulares.

Requisitos:

  • Conteúdo mínimo em cache: 1024 tokens (OpenAI) ou 2048 tokens (Anthropic)
  • TTL do Cache: 5-60 minutos dependendo do provedor
  • O conteúdo deve ser idêntico e aparecer no início do prompt

Exemplo de Implementação

from openai import OpenAI

client = OpenAI()

# System message cached across requests
SYSTEM_PROMPT = """You are a customer service AI for TechCorp.
Company policies:
[Large policy document - 2000 tokens]
"""

# This gets cached automatically
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "How do I return an item?"}
    ]
)

# Subsequent calls within cache TTL use cached system prompt
# Paying only for user message + output

Impacto no Mundo Real: Aplicações com bases de conhecimento ou instruções extensas veem uma redução de custos de 60-80%.

Estratégia de Seleção de Modelo

Usar o modelo certo para cada tarefa é crucial para a otimização de custos.

A Escada de Modelos

  1. GPT-4 / Claude Opus - Raciocínio complexo, tarefas criativas, precisão crítica
  2. GPT-4o / Claude Sonnet - Equilíbrio desempenho/custo, uso geral
  3. GPT-3.5 / Claude Haiku - Tarefas simples, classificação, extração
  4. Modelos menores ajustados (fine-tuned) - Tarefas repetitivas especializadas

Padrão de Roteamento

def route_request(task_complexity, user_query):
    """Route to appropriate model based on complexity"""
    
    # Simple classification - use Haiku
    if task_complexity == "simple":
        return call_llm("claude-3-haiku", user_query)
    
    # Moderate - use Sonnet
    elif task_complexity == "moderate":
        return call_llm("claude-3-sonnet", user_query)
    
    # Complex reasoning - use Opus
    else:
        return call_llm("claude-3-opus", user_query)

Estudo de Caso: Um chatbot de atendimento ao cliente roteando 80% das consultas para GPT-3.5 e 20% para GPT-4 reduziu os custos em 75% em comparação com o uso do GPT-4 para tudo.

Processamento em Lote (Batch Processing)

Para cargas de trabalho sem sensibilidade temporal, o processamento em lote oferece descontos de 50% na maioria dos provedores.

API de Lote da OpenAI

from openai import OpenAI
client = OpenAI()

# Create batch file
batch_requests = [
    {"custom_id": f"request-{i}", 
     "method": "POST",
     "url": "/v1/chat/completions",
     "body": {
         "model": "gpt-3.5-turbo",
         "messages": [{"role": "user", "content": query}]
     }}
    for i, query in enumerate(queries)
]

# Submit batch (50% discount, 24hr processing)
batch = client.batches.create(
    input_file_id=upload_batch_file(batch_requests),
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Casos de Uso:

  • Etiquetagem e anotação de dados
  • Geração de conteúdo para blogs/SEO
  • Geração de relatórios
  • Traduções em lote
  • Geração sintética de conjuntos de dados

Técnicas de Controle de Saída

Como tokens de saída custam de 2 a 5 vezes mais, controlar o comprimento da saída é crítico.

1. Definir Máximo de Tokens

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    max_tokens=150  # Hard limit prevents runaway costs
)

2. Usar Sequências de Parada

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stop=["END", "\n\n\n"]  # Stop at markers
)

3. Solicitar Formatos Concisos

Adicione instruções como:

  • “Responda em menos de 50 palavras”
  • “Forneça apenas tópicos em bullet points”
  • “Retorne apenas JSON, sem explicação”

Streaming para Melhor UX

Embora o streaming não reduza custos, ele melhora o desempenho percebido e permite encerramento precoce.

stream = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        token = chunk.choices[0].delta.content
        print(token, end="")
        
        # Early termination if response goes off-track
        if undesired_pattern(token):
            break

Otimização de RAG

A Geração Aumentada por Recuperação (RAG) adiciona contexto, mas um RAG não otimizado desperdiça tokens.

Padrão de RAG Eficiente

def optimized_rag(query, vector_db):
    # 1. Retrieve relevant chunks
    chunks = vector_db.search(query, top_k=3)  # Not too many
    
    # 2. Compress chunks - remove redundancy
    compressed = compress_chunks(chunks)  # Custom compression
    
    # 3. Truncate to token limit
    context = truncate_to_tokens(compressed, max_tokens=2000)
    
    # 4. Structured prompt
    prompt = f"Context:\n{context}\n\nQ: {query}\nA:"
    
    return call_llm(prompt)

Técnicas de Otimização:

  • Use fragmentação semântica (em vez de tamanho fixo)
  • Remova a formatação de markdown dos fragmentos recuperados
  • Implemente re-ordenação (re-ranking) para obter o conteúdo mais relevante
  • Considere o resumo de fragmentos para documentos grandes

Cache de Respostas

Armazene em cache requisições idênticas ou semelhantes para evitar chamadas de API inteiramente.

Implementação com Redis

import redis
import hashlib
import json

redis_client = redis.Redis()

def cached_llm_call(prompt, model="gpt-4", ttl=3600):
    # Create cache key from prompt + model
    cache_key = hashlib.md5(
        f"{model}:{prompt}".encode()
    ).hexdigest()
    
    # Check cache
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # Call LLM
    response = call_llm(model, prompt)
    
    # Cache result
    redis_client.setex(
        cache_key, 
        ttl, 
        json.dumps(response)
    )
    
    return response

Cache Semântico: Para consultas semelhantes (não idênticas), use incorporações vetoriais (embeddings) para encontrar respostas em cache.

Monitoramento e Análise

Rastreie o uso de tokens para identificar oportunidades de otimização.

Métricas Essenciais

class TokenTracker:
    def __init__(self):
        self.metrics = {
            'total_tokens': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0,
            'requests': 0
        }
    
    def track_request(self, response, model):
        usage = response.usage
        self.metrics['input_tokens'] += usage.prompt_tokens
        self.metrics['output_tokens'] += usage.completion_tokens
        self.metrics['total_tokens'] += usage.total_tokens
        self.metrics['cost'] += calculate_cost(usage, model)
        self.metrics['requests'] += 1
    
    def report(self):
        return {
            'avg_tokens_per_request': 
                self.metrics['total_tokens'] / self.metrics['requests'],
            'total_cost': self.metrics['cost'],
            'input_output_ratio': 
                self.metrics['input_tokens'] / self.metrics['output_tokens']
        }

Alertas de Custo

Configure alertas quando o uso exceder limites:

def check_cost_threshold(daily_cost, threshold=100):
    if daily_cost > threshold:
        send_alert(f"Daily cost ${daily_cost} exceeded ${threshold}")

Técnicas Avançadas

1. Modelos de Compressão de Prompts

Use modelos dedicados para comprimir prompts:

  • LongLLMLingua
  • AutoCompressors
  • Tokens de aprendizado de compressão

Esses podem alcançar razões de compressão de 10x mantendo 90%+ do desempenho da tarefa.

2. Decodificação Especulativa

Execute um modelo pequeno ao lado de um modelo grande para prever tokens, reduzindo as chamadas do modelo grande. Tipicamente, aceleração de 2-3x e redução de custos para qualidade similar.

3. Quantização

Para modelos auto-hospedados, a quantização (4-bit, 8-bit) reduz memória e computação:

  • 4-bit: ~75% de redução de memória, perda mínima de qualidade
  • 8-bit: ~50% de redução de memória, perda negligível de qualidade

Se você está executando LLMs localmente, o Ollama fornece uma excelente plataforma para implantar modelos quantizados com configuração mínima. Para seleção de hardware e benchmarks de desempenho, nossa comparação NVIDIA DGX Spark vs Mac Studio vs RTX-4080 mostra o desempenho do mundo real em diferentes configurações de hardware executando modelos quantizados grandes.

Checklist de Otimização de Custos

  • Perfilhar o uso atual de tokens e custos por endpoint
  • Auditar prompts por redundância - remover palavras desnecessárias
  • Implementar cache de contexto para conteúdo estático > 1K tokens
  • Configurar roteamento de modelos (pequeno para simples, grande para complexo)
  • Adicionar limites de max_tokens a todas as requisições
  • Implementar cache de respostas para consultas idênticas
  • Usar API de lote para cargas de trabalho não urgentes
  • Habilitar streaming para melhor UX
  • Otimizar RAG: menos fragmentos, melhor ordenação
  • Monitorar com rastreamento de tokens e alertas de custo
  • Considerar ajuste fino (fine-tuning) para tarefas repetitivas
  • Avaliar modelos menores (Haiku, GPT-3.5) para classificação

Estudo de Caso do Mundo Real

Cenário: Chatbot de suporte ao cliente, 100K requisições/mês

Antes da Otimização:

  • Modelo: GPT-4 para todas as requisições
  • Tokens de entrada médios: 800
  • Tokens de saída médios: 300
  • Custo: 100K × (800 × 0,00003 + 300 × 0,00006) = $4.200/mês

Após a Otimização:

  • Roteamento de modelos: 80% GPT-3.5, 20% GPT-4
  • Cache de contexto: 70% dos prompts em cache
  • Compressão de prompt: redução de 40%
  • Cache de respostas: taxa de acerto de cache de 15%

Resultados:

  • 85% das requisições evitaram o GPT-4
  • 70% se beneficiam do desconto de cache de contexto
  • 40% menos tokens de entrada
  • Custo efetivo: $780/mês
  • Economia: 81% ($3.420/mês)

Conclusão

A otimização de tokens transforma a economia de LLMs de proibitivamente cara para escalável de forma sustentável. Ao implementar compressão de prompts, cache de contexto, seleção inteligente de modelos e cache de respostas, a maioria das aplicações alcança uma redução de custos de 60-80% sem comprometimento da qualidade.

Comece com as vitórias rápidas: audite seus prompts, habilite o cache de contexto e roteie tarefas simples para modelos menores. Monitore seu uso de tokens religiosamente - o que é medido é otimizado. A diferença entre uma aplicação de LLM com custo-efetividade e uma cara não é a tecnologia — é a estratégia de otimização.

Artigos Relacionados

Subscrever

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.