Risposta Rapida: Il prompt caching abbatte i costi di input delle API LLM dal 50% al 90% e riduce la latenza TTFT fino all'85% riutilizzando i tensori del KV cache tra le richieste. Anthropic offre il 90% di sconto in lettura con breakpoint espliciti (da 1.024 token). OpenAI applica uno sconto automatico del 50% senza sovrapprezzo di scrittura. DeepSeek garantisce risparmi dell'80%–90% da una soglia di appena 64 token con memoria NVMe persistente.
1. Introduzione: L'economia dello stato nelle API LLM senza stato (Stateless)
Le API dei Large Language Model (LLM) moderni sono storicamente progettate per essere completamente prive di stato (stateless): ogni richiesta HTTP POST inviata a /v1/chat/completions o /v1/messages deve includere l'intera cronologia della conversazione, le istruzioni di sistema, le definizioni dei tool e i documenti di contesto. Sebbene l'assenza di stato semplifichi il bilanciamento del carico e la scalabilità orizzontale dei cluster GPU, essa comporta un costo computazionale ed economico insostenibile nei workflow agentici multi-turno.
Nei loop di agenti autonomi — come Claude Code, Roo Code, Aider, Devin o nei motori RAG aziendali — l'agente ritrasmette continuamente prompt di sistema identici, schemi OpenAPI e strutture di repository. Al 15° turno di una sessione di sviluppo software tipica, il 95%–98% di tutti i token trasmessi è costituito da prefissi statici già elaborati più volte dal modello.
In passato, i provider cloud addebitavano la tariffa intera per ogni token a ogni turno, costringendo i chip a eseguire pesanti moltiplicazioni matriciali (fase prefill) su contesti immutati. Il Prompt Caching risolve radicalmente questa inefficienza. Conservando i tensori Key-Value (KV) precalcolati nella memoria GPU HBM, nella RAM dell'host o su unità NVMe veloci, il motore di inferenza salta completamente la fase di prefill ridondante.
I team di ingegneria che adottano il prompt caching ottengono regolarmente riduzioni dal 60% all'88% sulla fattura complessiva delle API, riducendo il Time-to-First-Token (TTFT) da diversi secondi a poche centinaia di millisecondi.
2. Architettura interna: Meccanica del KV Cache e collo di bottiglia del Prefill
Per comprendere la sostenibilità economica del prompt caching, è fondamentale analizzare i vincoli fisici dell'inferenza Transformer su acceleratori moderni (NVIDIA H100/B200, Google TPU v5e/v6e).
Pipeline tradizionale senza stato (Stateless):
[Prompt di sistema statico + Schemi tool + Cronologia (64.000 token)]
│
▼
[Fase Prefill completa (O(N²) FLOPs)]
Moltiplicazioni matriciali ricalcolano tutti i Q, K, V
│
▼
[Primo token generato (TTFT: 2.8s)]
[Costo: Tariffa base piena × 64.000 token]
Pipeline con Prompt Caching abilitato:
[Prefisso statico (60.000 token)] ──► [Corrispondenza Hash!] ──► [Carica tensori KV memorizzati]
│ (Evita FLOPs matriciali)
[Query dinamica (4.000 token)] ──► [Prefill solo per il delta] ───────┤
▼
[Primo token generato (TTFT: 0.35s)]
[Costo: Tariffa lettura × 60k + Base × 4k]La complessità quadratica della Self-Attention
Nell'attenzione standard, i token di input sono proiettati nelle matrici Query ($Q$), Key ($K$) e Value ($V$):
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$
Durante la fase di prefill, la GPU elabora tutti i token contemporaneamente. Poiché la self-attention valuta le relazioni reciproche tra ogni coppia di token, il numero di operazioni in virgola mobile (FLOPs) cresce in modo quadratico rispetto alla lunghezza della sequenza $N$: $$\text{FLOPs}_{\text{prefill}} \approx 2 \cdot P \cdot N^2 + 4 \cdot N \cdot d_{\text{model}} \cdot d_{\text{ffn}}$$
Per un modello da 70 miliardi di parametri con un prompt da 64.000 token, la fase di prefill richiede circa $5.8 \times 10^{14}$ FLOPs prima di produrre anche un solo token di output.
Durante la fase di decodifica (decode), i token vengono emessi in modo sequenziale. Per non ricalcolare i token precedenti, i vettori di attivazione $K$ e $V$ vengono conservati in memoria: questo è il KV Cache. L'impronta di memoria per token su $L$ livelli con $H_{kv}$ teste di dimensione $D$ è: $$\text{Memory}_{\text{KV}} = 2 \times 2 \times L \times H_{kv} \times D \quad \text{(byte in FP16 / BF16)}$$
Il Prompt Caching estende questo KV cache tra richieste HTTP separate. Quando l'hash crittografico di un prefisso coincide con un blocco esistente, il sistema carica direttamente i tensori, azzerando il prefill.
3. Matrice comparativa tra i provider: Anthropic vs OpenAI vs DeepSeek
| Parametro Architetturale | Anthropic Claude | OpenAI (GPT-4o / o1 / o3) | DeepSeek (V3 / V4 / R1) |
|---|---|---|---|
| Meccanismo di attivazione | Breakpoint espliciti (cache_control) |
Automatico su prefisso comune | Automatico su prefisso comune |
| Soglia minima di attivazione | 1.024 token (Sonnet/Opus) 2.048 token (Haiku) |
1.024 token | 64 token (Allineamento blocco) |
| Granularità dei blocchi | Breakpoint definiti (max 4 per richiesta) | Blocchi di 128 token oltre 1.024 | Esattamente blocchi da 64 token |
| Durata di conservazione (TTL) | 5 minuti (predefinito) 1 ora (livello esteso) |
5 a 10 minuti (evizione dinamica LRU) | Ore o persistente (NVMe multilivello) |
| Rinnovo del TTL | Rinnovato a 5m/1h a ogni cache hit | Prolungato durante l'utilizzo continuo | Mantenuto stabile su SSD |
| Sovrapprezzo di scrittura | +25% (1.25x tariffa base per 5m) +100% (2.0x base per 1h) |
$0.00 (1.0x tariffa base di input) | $0.00 (1.0x tariffa base, zero costi aggiuntivi) |
| Sconto di lettura | 90% di sconto (0.10x tariffa base) | 50% di sconto (0.50x tariffa base) | 75%–90% di sconto (0.10x–0.25x base) |
| Costi di archiviazione | Inclusi nel sovrapprezzo di scrittura | Gratis | Gratis (offload su NVMe) |
| Riduzione latenza (TTFT) | Fino all'85% più veloce | Fino al 50% più veloce | Fino all'80% più veloce |
4. Matrice globale dei prezzi per modello (USD per 1M di token)
| Modello | Input Base ($/1M) | Scrittura ($/1M) | Lettura ($/1M) | Sconto Lettura | Output Base ($/1M) | Soglia Minima |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 (5m) / $1.60 (1h) | $0.08 | 90.0% | $4.00 | 2.048 token |
| Claude 3.7 Sonnet | $3.00 | $3.75 (5m) / $6.00 (1h) | $0.30 | 90.0% | $15.00 | 1.024 token |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 (5m) / $30.00 (1h) | $1.50 | 90.0% | $75.00 | 1.024 token |
| OpenAI GPT-4o mini | $0.15 | $0.15 | $0.075 | 50.0% | $0.60 | 1.024 token |
| OpenAI GPT-4o | $2.50 | $2.50 | $1.25 | 50.0% | $10.00 | 1.024 token |
| OpenAI o1 | $15.00 | $15.00 | $7.50 | 50.0% | $60.00 | 1.024 token |
| OpenAI o3-mini | $1.10 | $1.10 | $0.55 | 50.0% | $4.40 | 1.024 token |
| DeepSeek V3 / V4 (Off-Peak) | $0.14 | $0.14 | $0.014 | 90.0% | $0.28 | 64 token |
| DeepSeek V3 / V4 (Peak) | $0.27 | $0.27 | $0.027 | 90.0% | $1.10 | 64 token |
| DeepSeek R1 (Ragionamento) | $0.55 | $0.55 | $0.14 | 74.5% | $2.19 | 64 token |
| Google Gemini 2.5 Flash | $0.15 | $0.15 | $0.0375 | 75.0% | $0.60 | 32.768 token |
| Google Gemini 2.5 Pro | $1.25 | $1.25 | $0.3125 | 75.0% | $5.00 | 32.768 token |
5. Formalizzazione matematica e calcolo del punto di pareggio
Calcolo del break-even ($N^*$)
Per Anthropic con sovrapprezzo di scrittura del 25% ($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: Con il TTL di 5 minuti di Anthropic, il caching diventa vantaggioso a partire dalla seconda richiesta (N = 2). Per il TTL esteso di 1 ora ($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: Con il TTL di 1 ora di Anthropic, il punto di pareggio si raggiunge alla terza richiesta (N = 3).
Limite asintotico del 90% di risparmio
Per sessioni lunghe ($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\%}$ di risparmio massimo.
- OpenAI: $1 - 0.50 = \mathbf{50.0\%}$ di risparmio massimo.
6. Codice di implementazione pratica
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": "Specifiche tecniche dell'architettura...\n" * 400,
"cache_control": {"type": "ephemeral"} # Breakpoint
}
],
messages=[{"role": "user", "content": "Genera la migrazione del database."}]
)
print("Token letti da 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: "Linee guida fisse...\n".repeat(400) },
{ role: "user", content: "Verifica stato ordine #789" }
]
});
console.log("Token in cache:", (res.usage as any)?.prompt_tokens_details?.cached_tokens ?? 0);7. Casi di studio reali e ROI
- Agenti di programmazione (Claude Code, monorepo da 250k LOC): 20 ingegneri hanno ridotto i costi mensili da $29.700 a $4.334 / mese (85.4% di risparmio netto).
- RAG documentale finanziario (OpenAI GPT-4o): 50.000 query mensili su testi normativi da 45k token sono scese da $5.625 a $2.975,63 / mese (47.1% di risparmio).
- Assistenza clienti ad altissimo volume (DeepSeek V3/V4): 2 milioni di interazioni al mese sono passate da $3.360 a $378,34 / mese (88.7% di risparmio).
8. I cinque errori critici che invalidano la cache
- Timestamp dinamici nel prompt di sistema: Modificano l'hash SHA-256 ogni secondo, azzerando l'hit rate.
- Ordine casuale nella definizione dei tool: Serializzazioni disordinate generano mismatch. Ordinare sempre alfabeticamente.
- Variabili dinamiche inserite all'inizio o al centro: Il caching richiede un prefisso comune continuo. Posizionare i dati dinamici sempre alla fine.
- Scadenza del TTL di 5 minuti: Dopo pause prolungate, valutare il TTL da 1 ora.
- Invio di prompt inferiori alla soglia: Se inferiori a 1.024 token su Anthropic o OpenAI, non vengono memorizzati nella cache.
9. Conclusioni e verdetto LLMPodium
- Ideale per agenti di programmazione: Anthropic Claude 3.7 Sonnet offre il miglior rapporto costo/prestazioni grazie al 90% di sconto in lettura.
- Ideale per integrazioni immediate a zero modifiche: OpenAI GPT-4o garantisce il 50% di risparmio senza toccare una riga di codice.
- Campione di convenienza su volumi immensi: DeepSeek V3/V4 è insuperabile con la sua soglia da 64 token e $0.014/1M.