Cache de Prompts

Estratégias de cache para prompts de LLM, incluindo cache de prompts da Anthropic, cache de respostas e CAG (Cache Augmented Generation).

Capacidades

• prompt-cache
• response-cache
• kv-cache
• cag-patterns
• cache-invalidation

Pré-requisitos

• Conhecimento: Fundamentos de cache, uso de API de LLM, funções de hash
• Habilidades recomendadas: gerenciamento de janela de contexto

Escopo

• Não cobre: Cache de CDN, cache de consultas de banco de dados, cache de ativos estáticos
• Limites: Foco em cache específico para LLM, cobre cache de prompt e de resposta

Ecossistema

Ferramentas Primárias

• Cache de Prompts da Anthropic - Cache de prompts nativo na API Claude
• Redis - Cache em memória para respostas (ioredis em servidores; @upstash/redis via HTTP em serverless, veja upstash-redis)
• Cache da OpenAI - Cache automático na API OpenAI

Padrões

Cache de Prompts da Anthropic

Use o cache de prompts nativo do Claude para prefixos repetidos

Quando usar: Usando a API Claude com prompts de sistema ou contexto estáveis

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

// Cache as partes estáveis do seu prompt async function queryWithCaching(userQuery: string) { const response = await client.messages.create({ model: "claude-sonnet-4-20250514", max_tokens: 1024, system: [ { type: "text", text: LONG_SYSTEM_PROMPT, // Suas instruções detalhadas cache_control: { type: "ephemeral" } // Cache isso! }, { type: "text", text: KNOWLEDGE_BASE, // Grande contexto estático cache_control: { type: "ephemeral" } } ], messages: [ { role: "user", content: userQuery } // Parte dinâmica ] });

// Verifique o uso do cache
console.log(`Cache read: ${response.usage.cache_read_input_tokens}`);
console.log(`Cache write: ${response.usage.cache_creation_input_tokens}`);

return response;

}

// Economia de custo: Redução de 90% em tokens cacheados // Economia de latência: Até 2x mais rápido

Cache de Respostas

Cache de respostas completas de LLM para consultas idênticas ou similares

Quando usar: Mesmas consultas feitas repetidamente

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

const redis = new Redis(process.env.REDIS_URL); // Alternativa Serverless/edge sem conexão persistente: // import { Redis } from '@upstash/redis'; const redis = Redis.fromEnv(); // então use redis.set(key, value, { ex: ttl })

class ResponseCache { private ttl = 3600; // 1 hora padrão

// Cache de correspondência exata
async getCached(prompt: string): Promise<string | null> {
    const key = this.hashPrompt(prompt);
    return await redis.get(`response:${key}`);
}

async setCached(prompt: string, response: string): Promise<void> {
    const key = this.hashPrompt(prompt);
    await redis.set(`response:${key}`, response, 'EX', this.ttl);
}

private hashPrompt(prompt: string): string {
    return createHash('sha256').update(prompt).digest('hex');
}

// Cache de similaridade semântica
async getSemanticallySimilar(
    prompt: string,
    threshold: number = 0.95
): Promise<string | null> {
    const embedding = await embed(prompt);
    const similar = await this.vectorCache.search(embedding, 1);

    if (similar.length && similar[0].similarity > threshold) {
        return await redis.get(`response:${similar[0].id}`);
    }
    return null;
}

// Cache com reconhecimento de temperatura
async getCachedWithParams(
    prompt: string,
    params: { temperature: number; model: string }
): Promise<string | null> {
    // Cache apenas respostas de baixa temperatura
    if (params.temperature > 0.5) return null;

    const key = this.hashPrompt(
        `${prompt}|${params.model}|${params.temperature}`
    );
    return await redis.get(`response:${key}`);
}

}

Geração Aumentada por Cache (CAG)

Pré-cache de documentos no prompt em vez de recuperação RAG

Quando usar: O corpus de documentos é estável e cabe na janela de contexto

// CAG: Pré-computar contexto de documento, cachear no prompt // Melhor que RAG quando: // - Documentos são estáveis // - O total cabe na janela de contexto // - Latência é crítica

class CAGSystem { private cachedContext: string | null = null; private lastUpdate: number = 0;

async buildCachedContext(documents: Document[]): Promise<void> {

…