Resposta Rápida: O prompt caching reduz os custos de entrada em APIs de LLM entre 50% e 90% e corta a latência TTFT em até 85% ao reutilizar tensores do KV cache entre requisições. A Anthropic oferece 90% de desconto de leitura com breakpoints explícitos (a partir de 1.024 tokens). A OpenAI fornece 50% de desconto automático sem taxa de escrita. A DeepSeek viabiliza 80% a 90% de economia com limite ultra baixo de 64 tokens e persistência NVMe.
1. Introdução: A economia do estado em APIs de LLM sem estado (Stateless)
As APIs modernas de Grandes Modelos de Linguagem (LLMs) são historicamente concebidas como sem estado (stateless): cada requisição HTTP POST enviada para /v1/chat/completions ou /v1/messages deve fornecer o histórico de diálogo completo, instruções de sistema, esquemas de ferramentas e documentos contextuais. Embora esse modelo simplifique o balanceamento de carga e o escalonamento horizontal em clusters de GPUs, ele impõe um custo computacional e financeiro gigantesco a fluxos de trabalho com agentes autônomos.
Em loops de agentes autônomos — como Claude Code, Roo Code, Aider, Devin ou pipelines corporativos de RAG — o agente retransmite repetidamente prompts de sistema idênticos, definições OpenAPI e estruturas de repositórios. No 15º turno de uma sessão típica de engenharia de software, 95% a 98% dos tokens transmitidos são prefixos estáticos que o modelo já ingeriu anteriormente.
No modelo tradicional, os provedores em nuvem cobravam a tarifa cheia por cada token a cada interação, obrigando os aceleradores a recalcularem multiplicações de matrizes pesadas (fase de prefill) sobre contexto inalterado. O Prompt Caching resolve essa ineficiência de forma definitiva. Ao reter os tensores Key-Value (KV) pré-computados na memória HBM da GPU, na memória RAM do servidor ou em unidades SSD NVMe ultrarrápidas, o motor de inferência ignora o prefill redundante.
Equipes de engenharia que aplicam prompt caching sistemático alcançam rotineiramente cortes de 60% a 88% nas faturas de API, reduzindo o Time-to-First-Token (TTFT) de vários segundos para algumas centenas de milissegundos.
2. Análise Arquitetural: Mecânica do KV Cache e o Gargalo do Prefill
Para dominar a economia do prompt caching, os engenheiros devem compreender a física computacional da inferência Transformer em aceleradores modernos (NVIDIA H100/B200, Google TPU v5e/v6e).
Pipeline Tradicional Sem Estado:
[Prompt estático + Esquemas de ferramentas + Histórico (64.000 tokens)]
│
▼
[Fase Prefill Completa (O(N²) FLOPs)]
Multiplicação densa de matrizes recalcula Q, K, V
│
▼
[Primeiro token gerado (TTFT: 2.8s)]
[Custo: Tarifa base cheia × 64.000 tokens]
Pipeline com Prompt Caching Ativado:
[Prefixo estático (60.000 tokens)] ──► [Hash do prefixo coincide!] ──► [Carregar tensores KV em cache]
│ (Evita FLOPs de matrizes)
[Query dinâmica (4.000 tokens)] ──► [Prefill apenas para o delta] ───────────┤
▼
[Primeiro token gerado (TTFT: 0.35s)]
[Custo: Tarifa leitura × 60k + Base × 4k]O gargalo computacional da Self-Attention
Na autoatenção multi-head padrão, os tokens de entrada são projetados nas matrizes Query ($Q$), Key ($K$) e Value ($V$):
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$
Na fase de prefill, a GPU processa todos os tokens simultaneamente. Como a autoatenção avalia as relações cruzadas entre cada par de tokens, o número de operações em ponto flutuante (FLOPs) escala quadraticamente em relação ao comprimento da sequência $N$:
$$\text{FLOPs}_{\text{prefill}} \approx 2 \cdot P \cdot N^2 + 4 \cdot N \cdot d_{\text{model}} \cdot d_{\text{ffn}}$$
Para um modelo de 70 bilhões de parâmetros com um prompt de 64.000 tokens, o prefill requer aproximadamente $5.8 \times 10^{14}$ operações de ponto flutuante antes de emitir a primeira palavra.
Na fase de decodificação (decode), os tokens são gerados de forma sequencial. Para evitar recalcular tokens passados, os vetores de ativação $K$ e $V$ são armazenados na memória: este é o KV Cache. A pegada de memória por token em $L$ camadas com $H_{kv}$ cabeças de dimensão $D$ é:
$$\text{Memory}_{\text{KV}} = 2 \times 2 \times L \times H_{kv} \times D \quad \text{(bytes em FP16 / BF16)}$$
O Prompt Caching estende esse KV cache para além dos limites de uma única requisição. Havendo correspondência de hash criptográfico, os tensores são carregados diretamente da memória, eliminando a fase de prefill.
3. Matriz Comparativa entre Provedores: Anthropic vs OpenAI vs DeepSeek
| Dimensão Arquitetural | Anthropic Claude | OpenAI (GPT-4o / o1 / o3) | DeepSeek (V3 / V4 / R1) |
|---|---|---|---|
| Mecanismo de Ativação | Breakpoints explícitos (cache_control) |
Automático por prefixo comum | Automático por prefixo comum |
| Limite Mínimo de Ativação | 1.024 tokens (Sonnet/Opus) 2.048 tokens (Haiku) |
1.024 tokens | 64 tokens (Alinhamento de bloco) |
| Granularidade dos Blocos | Breakpoints explícitos (máx. 4/requisição) | Incrementos de 128 tokens após 1.024 | Exatamente blocos de 64 tokens |
| Tempo de Vida (TTL) | 5 minutos (efêmero padrão) 1 hora (nível estendido) |
5 a 10 minutos (descarte dinâmico LRU) | Horas ou persistente (NVMe multinível) |
| Renovação de TTL | Reiniciado em 5m/1h a cada hit | Renovação contínua sob chamadas | Retido de forma persistente em SSD |
| Sobretaxa de Escrita (Write) | +25% (1.25x tarifa base para 5m) +100% (2.0x base para 1h) |
$0.00 (1.0x tarifa base de entrada) | $0.00 (1.0x tarifa base, sem sobretaxa) |
| Desconto de Leitura (Read) | 90% de desconto (0.10x tarifa base) | 50% de desconto (0.50x tarifa base) | 75% a 90% de desconto (0.10x–0.25x base) |
| Custos de Armazenamento | Inclusos na sobretaxa de escrita | Gratuito | Gratuito (descarregado em NVMe) |
| Redução de Latência (TTFT) | Até 85% mais rápido | Até 50% mais rápido | Até 80% mais rápido |
4. Tabela Geral de Tarifas por Modelo (USD por 1M de tokens)
| Modelo | Entrada Padrão ($/1M) | Escrita ($/1M) | Leitura ($/1M) | Desconto de Leitura | Saída Padrão ($/1M) | Limite Mínimo |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 (5m) / $1.60 (1h) | $0.08 | 90.0% | $4.00 | 2.048 tokens |
| Claude 3.7 Sonnet | $3.00 | $3.75 (5m) / $6.00 (1h) | $0.30 | 90.0% | $15.00 | 1.024 tokens |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 (5m) / $30.00 (1h) | $1.50 | 90.0% | $75.00 | 1.024 tokens |
| OpenAI GPT-4o mini | $0.15 | $0.15 | $0.075 | 50.0% | $0.60 | 1.024 tokens |
| OpenAI GPT-4o | $2.50 | $2.50 | $1.25 | 50.0% | $10.00 | 1.024 tokens |
| OpenAI o1 | $15.00 | $15.00 | $7.50 | 50.0% | $60.00 | 1.024 tokens |
| OpenAI o3-mini | $1.10 | $1.10 | $0.55 | 50.0% | $4.40 | 1.024 tokens |
| DeepSeek V3 / V4 (Fora de Pico) | $0.14 | $0.14 | $0.014 | 90.0% | $0.28 | 64 tokens |
| DeepSeek V3 / V4 (Pico) | $0.27 | $0.27 | $0.027 | 90.0% | $1.10 | 64 tokens |
| DeepSeek R1 (Raciocínio) | $0.55 | $0.55 | $0.14 | 74.5% | $2.19 | 64 tokens |
| Google Gemini 2.5 Flash | $0.15 | $0.15 | $0.0375 | 75.0% | $0.60 | 32.768 tokens |
| Google Gemini 2.5 Pro | $1.25 | $1.25 | $0.3125 | 75.0% | $5.00 | 32.768 tokens |
5. Formalização Matemática e Ponto de Equilíbrio (Break-Even)
Cálculo do ponto de equilíbrio ($N^*$)
Para a Anthropic com 25% de taxa de escrita ($R_{\text{write}} = 1.25 R_{\text{base}}$, $R_{\text{read}} = 0.10 R_{\text{base}}$):
$$1.25 + 0.10(N - 1) \le N \implies 1.15 \le 0.90N \implies N \ge \frac{1.15}{0.90} \approx 1.278$$
Teorema 1: Com o TTL de 5 minutos da Anthropic, o prompt caching é rentável a partir da segunda requisição (N = 2).
Para o TTL estendido de 1 hora ($R_{\text{write}} = 2.0 R_{\text{base}}$):
$$2.0 + 0.10(N - 1) \le N \implies 1.90 \le 0.90N \implies N \ge 2.11$$
Teorema 2: Com o TTL de 1 hora da Anthropic, o ponto de equilíbrio é superado na terceira requisição (N = 3).
Limite assintótico de 90% de economia
Para sessões longas ($N \to \infty$):
$$\lim_{N \to \infty} S(N) = 1 - \frac{R_{\text{read}}}{R_{\text{base}}}$$
- Anthropic e DeepSeek: $1 - 0.10 = \mathbf{90.0\%}$ de economia máxima.
- OpenAI: $1 - 0.50 = \mathbf{50.0\%}$ de economia máxima.
6. Exemplos de Implementação de Código
Anthropic Claude (Python)
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-3-7-sonnet-20250219",
max_tokens=2048,
system=[
{
"type": "text",
"text": "Especificações de arquitetura do sistema...\n" * 400,
"cache_control": {"type": "ephemeral"} # Breakpoint
}
],
messages=[{"role": "user", "content": "Refatore o middleware de autenticação."}]
)
print("Tokens lidos do cache:", getattr(response.usage, "cache_read_input_tokens", 0))OpenAI (TypeScript / Node.js)
import OpenAI from "openai";
const openai = new OpenAI();
const res = await openai.chat.completions.create({
model: "gpt-4o",
messages: [
{ role: "system", content: "Diretrizes estáticas de suporte...\n".repeat(400) },
{ role: "user", content: "Consultar histórico de pedidos" }
]
});
console.log("Tokens em cache:", (res.usage as any)?.prompt_tokens_details?.cached_tokens ?? 0);7. Casos de Uso Reais e Retorno de Investimento
- Agentes de programação (Claude Code, monorepo de 250k linhas): 20 engenheiros reduziram o gasto mensal de $29.700 para $4.334 / mês (85.4% de economia líquida).
- RAG sobre documentos extensos (OpenAI GPT-4o): 50.000 consultas mensais sobre manuais normativos caíram de $5.625 para $2.975,63 / mês (47.1% de economia).
- Atendimento ao cliente em massa (DeepSeek V3/V4): 2 milhões de conversas mensais passaram de $3.360 para $378,34 / mês (88.7% de economia).
8. Cinco Antipadrões que Quebram o Cache
- Timestamps dinâmicos no prompt de sistema: Alteram o hash SHA-256 a cada segundo, zerando a taxa de acerto do cache.
- Ordem aleatória na lista de ferramentas (Tools): A serialização JSON desordenada invalida o hash. Ordene sempre alfabeticamente.
- Variáveis dinâmicas inseridas no início ou no meio: O cache exige prefixo comum rígido. Mantenha os dados dinâmicos estritamente no final.
- Ignorar o vencimento do TTL de 5 minutos: Se houver pausas longas entre turnos, utilize o TTL estendido de 1 hora.
- Não atingir o limite mínimo de 1.024 tokens: Textos menores não ativam o cache na Anthropic ou OpenAI.
9. Veredito e Recomendações LLMPodium
- Para agentes autônomos de código: A Anthropic Claude 3.7 Sonnet oferece o maior retorno graças ao desconto de 90% na leitura.
- Para pipelines existentes sem refatoração: A OpenAI GPT-4o garante 50% de economia direta com zero alteração de código.
- Para volumes astronômicos ao menor custo: O DeepSeek V3/V4 é imbatível com seu limite de 64 tokens e leitura a $0.014/1M.