Como Fazer Cache de Requisições de API de IA e Economizar 30-40%

Toda vez que sua aplicação envia a mesma pergunta para um LLM, você está pagando pela mesma resposta duas vezes. Na maioria das aplicações em produção, 20-40% das requisições são duplicatas ou quase duplicatas.

Cache resolve isso. Veja como implementar corretamente.

Por Que Fazer Cache de Respostas de LLM?

Três motivos:

1. Redução de custo: Não pague pela mesma resposta duas vezes. Economia típica: 20-40%.
2. Menor latência: Uma resposta cacheada retorna em milissegundos em vez de 1-3 segundos.
3. Alívio de rate limit: Menos chamadas de API significa menos pressão nos limites do provedor.

Tipos de Cache para LLM

1. Cache Exato (Simples, Alta Precisão)

Armazena a resposta para um prompt exatamente igual. Se o mesmo prompt chegar de novo, retorna a resposta cacheada.

import { createHash } from 'crypto';
import Redis from 'ioredis';

const redis = new Redis();

function getCacheKey(messages: Message[], model: string): string {
  const payload = JSON.stringify({ messages, model });
  return `llm:${createHash('sha256').update(payload).digest('hex')}`;
}

async function cachedCompletion(params: CompletionParams) {
  const key = getCacheKey(params.messages, params.model);

  // Verifica cache
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

  // Chama LLM
  const response = await openai.chat.completions.create(params);

  // Armazena com TTL
  await redis.setex(key, 3600, JSON.stringify(response));

  return response;
}

Prós: Simples, zero falsos positivos, determinístico Contras: Só funciona com prompts idênticos — “qual o clima?” e “como está o tempo?” são diferentes

Melhor para: Classificação, tradução, extração estruturada — tarefas onde o mesmo input se repete exatamente.

2. Cache Semântico (Mais Inteligente, Maior Taxa de Hit)

Usa embeddings para encontrar prompts com significado similar, mesmo que as palavras sejam diferentes.

"Como faço para devolver um produto?"  →  cache hit
"Qual o processo de reembolso?"        →  mesma intenção → serve resposta cacheada
"Posso mandar algo de volta?"          →  mesma intenção → serve resposta cacheada

Como funciona:

1. Gera um embedding (vetor) para o prompt recebido
2. Busca em um banco de vetores por embeddings similares
3. Se a similaridade excede um threshold (ex: 0.95), retorna a resposta cacheada
4. Caso contrário, chama o LLM e armazena a nova resposta + embedding

async function semanticCachedCompletion(params: CompletionParams) {
  const prompt = params.messages[params.messages.length - 1].content;

  // Gera embedding
  const embedding = await getEmbedding(prompt);

  // Busca no banco de vetores por prompts similares
  const results = await qdrant.search('cache', {
    vector: embedding,
    limit: 1,
    score_threshold: 0.95,
  });

  if (results.length > 0) {
    return results[0].payload.response;
  }

  // Chama LLM
  const response = await openai.chat.completions.create(params);

  // Armazena no banco de vetores
  await qdrant.upsert('cache', {
    points: [{
      id: generateId(),
      vector: embedding,
      payload: { prompt, response, timestamp: Date.now() }
    }]
  });

  return response;
}

Prós: Captura prompts semanticamente similares, taxa de hit muito maior Contras: Requer infraestrutura de embedding, pequeno risco de falsos positivos, adiciona latência do embedding

Melhor para: Suporte ao cliente, bots de FAQ, qualquer app com fraseamento diverso das mesmas perguntas.

3. Cache Híbrido (O Melhor dos Dois)

Tenta cache exato primeiro (rápido, zero risco), depois cache semântico (mais lento, maior recall):

Requisição → Cache exato? → Retorna imediatamente
                   ↓ miss
          Cache semântico? → Retorna resposta cacheada
                   ↓ miss
          Chama LLM → Armazena em ambos os caches

Estratégias de Invalidação de Cache

Baseada em Tempo (TTL)

Defina um time-to-live nas respostas cacheadas:

Baseada em Versão

Invalide o cache quando seus prompts mudarem. Inclua uma versão na chave de cache:

const PROMPT_VERSION = 'v3';

function getCacheKey(messages, model) {
  const payload = JSON.stringify({ messages, model, v: PROMPT_VERSION });
  return `llm:${hash(payload)}`;
}

Quando atualizar seu system prompt, incremente a versão e o cache antigo é automaticamente ignorado.

Baseada em Eventos

Invalide entradas específicas quando os dados subjacentes mudarem:

// Quando dados do produto atualizam, limpa cache relacionado
async function onProductUpdate(productId: string) {
  const keys = await redis.keys(`llm:product:${productId}:*`);
  if (keys.length) await redis.del(...keys);
}

O Que NÃO Cachear

Nem tudo deve ser cacheado:

• Geração criativa: “Escreva um poema sobre gatos” — usuários esperam outputs diferentes cada vez
• Conversas com histórico: Conversas multi-turno onde o contexto muda
• Queries sensíveis a tempo: “Que horas são?” ou “Quais as últimas notícias?”
• Respostas personalizadas: Quando a resposta depende de dados específicos do usuário não presentes no prompt

Medindo a Eficácia do Cache

Acompanhe essas métricas:

Taxa de hit = respostas_cacheadas / total_requisições × 100%
Economia = cache_hits × custo_médio_por_requisição
Melhoria de latência = latência_média_sem_cache - latência_média_com_cache

Benchmarks alvo:

• Taxa de hit > 20%: Bom, você está economizando
• Taxa de hit > 40%: Excelente, redução significativa de custos
• Taxa de hit > 60%: Seu caso de uso é muito amigável a cache

Usando um AI Gateway para Cache

Construir cache do zero significa gerenciar Redis, banco de vetores, embeddings, lógica de TTL e invalidação — infraestrutura significativa.

Um AI gateway como o Floopy oferece cache exato e semântico integrados. Você não precisa mudar seu código:

// Mesmo código, cache acontece automaticamente no gateway
const client = new OpenAI({
  baseURL: "https://api.floopy.ai/v1",
  apiKey: process.env.FLOOPY_API_KEY,
});

O gateway cuida de geração de chave de cache, gerenciamento de TTL, matching semântico e analytics de cache — tudo configurável pelo dashboard.

Principais Conclusões

1. Comece com cache exato — é simples, sem risco, e captura mais duplicatas do que você imagina
2. Adicione cache semântico para apps voltados ao usuário onde o fraseamento varia
3. Defina TTLs apropriados — equilibre frescor vs. economia
4. Não cachear tudo — tarefas criativas e sensíveis a tempo devem pular o cache
5. Meça a taxa de hit — se estiver abaixo de 10%, seu caso de uso pode não se beneficiar de cache
6. Versione suas chaves de cache — invalide automaticamente quando os prompts mudarem