Caching dei Prompt LLM: Riduci i Costi API del 90% (Tutti e 3 i Provider)

Caching dei Prompt LLM: Riduci i Costi API del 90% (Tutti e 3 i Provider)

Il caching dei prompt LLM ti permette di riutilizzare token già elaborati tra le chiamate API -- riducendo i costi di input fino al 90% e il tempo al primo token fino all'85%. Se invii lo stesso prompt di sistema, le stesse definizioni di strumenti o gli stessi esempi few-shot ad ogni richiesta, stai pagando il prezzo pieno per un lavoro che la GPU ha già eseguito.

Questa guida copre OpenAI, Anthropic e Gemini con lo stesso chatbot implementato in tutti e tre gli SDK -- qualcosa che nessun'altra guida fa. Copriremo anche l'aggiornamento del caching automatico di Anthropic di febbraio 2026, scenari di costo in produzione con cifre reali in dollari, e gli anti-pattern che distruggono silenziosamente il tuo tasso di successo della cache.

Riepilogo Rapido -- Tutti e Tre i Provider a Colpo d'Occhio

Prima di entrare nei dettagli dell'implementazione, ecco il confronto completo. Se sai già quale provider stai usando, salta direttamente a quella sezione. Se stai valutando, questa tabella ti dice tutto in 10 secondi.

Conclusione chiave: OpenAI è il più semplice (zero config, 50% di sconto). Anthropic offre lo sconto più profondo (90%) con il massimo controllo. Gemini offre TTL configurabile e caching implicito sui modelli 2.5+ con sconti paragonabili ad Anthropic.

Come Funziona il Caching dei Prompt LLM?

Non devi capire i meccanismi interni dei transformer per usare il caching dei prompt in modo efficace. Ma devi capire un concetto: corrispondenza del prefisso.

La Cache KV in 60 Secondi

Quando un LLM elabora il tuo prompt, calcola stati di attenzione (coppie chiave-valore) per ogni token. Queste voci della cache KV sono la parte costosa -- consumano memoria GPU e tempo di calcolo. Il caching dei prompt memorizza questi stati calcolati in modo che la prossima richiesta con lo stesso prefisso salti completamente il ricalcolo.

La parola critica è prefisso. La cache corrisponde dall'inizio del tuo prompt. Se i primi 2.000 token corrispondono a una voce in cache ma il token 2.001 differisce, quei primi 2.000 token vengono serviti dalla cache. Tutto ciò che segue il punto di divergenza viene calcolato nuovamente.

Ecco perché l'ordine del prompt è importante. Struttura i tuoi prompt così:

1. Definizioni degli strumenti (le più statiche)
2. Prompt di sistema
3. Esempi few-shot statici
4. Contesto recuperato (semi-dinamico)
5. Cronologia della conversazione (cresce per turno)
6. Query dell'utente (sempre diversa)

Contenuto statico prima, contenuto dinamico alla fine. Più token corrispondono al prefisso in cache, maggiori sono i risparmi.

Caching dei Prompt vs Caching Semantico vs Caching delle Risposte

Questi tre termini vengono continuamente confusi. Il caching dei prompt (di cui tratta questa guida) riutilizza gli stati KV calcolati a livello GPU per prefissi di token identici -- zero perdita di accuratezza, stessa output di senza cache. Il caching semantico usa la similarità degli embedding per restituire risposte generate in precedenza per query "abbastanza simili" -- più veloce ma può restituire risposte errate. Il caching delle risposte memorizza coppie esatte input-output e restituisce la risposta in cache alla lettera -- funziona solo per richieste veramente identiche.

Il caching dei prompt è l'unica "ottimizzazione gratuita" -- riduce costo e latenza senza alcun compromesso sull'accuratezza. Per la matematica approfondita dei transformer dietro il caching KV, l'articolo tecnico di Hugging Face ha misurato una velocizzazione di ~5,21x su GPU T4.

Come Gestisce OpenAI il Caching dei Prompt?

Il caching dei prompt di OpenAI è completamente automatico. Da ottobre 2024, ogni chiamata API con 1.024+ token di input beneficia automaticamente del caching. Nessun opt-in, nessun header, nessuna modifica al codice.

Come Funziona il Caching Automatico di OpenAI

Quando invii una richiesta con almeno 1.024 token, OpenAI verifica se il prefisso corrisponde a una richiesta recente della tua organizzazione. I cache hit costano il 50% del prezzo standard del token di input. Dopo la soglia iniziale di 1.024 token, la cache corrisponde in incrementi di 128 token.

La cache vive per 5-10 minuti durante l'uso normale e può persistere fino a 24 ore durante i periodi di bassa attività. È circoscritta per organizzazione, quindi diversi progetti all'interno della stessa organizzazione beneficiano di cache condivise.

I modelli supportati includono GPT-4o, GPT-4o-mini, GPT-4.1, o1, o3-mini e tutti i modelli più recenti.

Esempio con Python SDK di OpenAI

from openai import OpenAI

client = OpenAI()

# Questo prompt di sistema è ~2.000 token -- ben al di sopra del minimo di 1.024
SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message},
        ],
    )

    # Verifica se il caching si è attivato
    usage = response.usage
    cached = usage.prompt_tokens_details.cached_tokens
    total_input = usage.prompt_tokens
    print(f"Cached: {cached}/{total_input} tokens ({cached/total_input*100:.0f}%)")

    return response.choices[0].message.content

# Prima chiamata: cache miss (prezzo pieno)
chat("Review this async function for race conditions...")

# Seconda chiamata entro 5-10 min: cache hit (50% di sconto sui token in cache)
chat("Now optimize the same function for throughput...")

La prima chiamata elabora tutto al prezzo pieno e riempie la cache. La seconda chiamata riutilizza i token del prompt di sistema in cache a metà prezzo. Vedrai qualcosa come Cached: 1920/2048 tokens (94%) nell'output.

Verdetto: OpenAI è il più facile con cui iniziare -- zero configurazione, il caching avviene e basta. Lo sconto del 50% è il più basso dei tre provider, ma nulla eguaglia la semplicità.

Come Gestisce Anthropic/Claude il Caching dei Prompt?

Anthropic offre due modalità: caching automatico (abilitato per impostazione predefinita da febbraio 2026) e caching esplicito con breakpoint cache_control. La cifra principale è difficile da ignorare -- le letture in cache costano solo il 10% del prezzo di input standard, uno sconto del 90%.

Caching Automatico vs Esplicito (Aggiornamento 2026)

Dal 5 febbraio 2026, Anthropic abilita il caching automatico per impostazione predefinita per tutti i prompt idonei. Non hai più bisogno del vecchio header beta. Il sistema determina automaticamente i breakpoint di cache ottimali.

Il caching esplicito è ancora disponibile quando vuoi un controllo dettagliato. Posizioni cache_control: {"type": "ephemeral"} su blocchi di contenuto specifici per contrassegnare esattamente dove dovrebbe essere il confine della cache. Questo è utile quando il tuo prompt ha una struttura specifica e vuoi garantire che determinate sezioni vengano memorizzate in cache.

Esistono due opzioni TTL:

• Cache da 5 minuti (predefinita): le scritture costano 1,25x il prezzo base di input, le letture costano 0,1x. Si ripaga dopo 1 cache hit.
• Cache da 1 ora: le scritture costano 2x il prezzo base di input, le letture costano 0,1x. Si ripaga dopo 2 cache hit. Disponibile sui modelli Claude 4.5+.

L'isolamento della cache è cambiato dal livello organizzazione al livello area di lavoro il 5 febbraio 2026. Ciò significa che diverse aree di lavoro all'interno della stessa organizzazione mantengono cache separate.

Quando lavori con il caching di Anthropic, aiuta strutturare il tuo prompt per un caching ottimale -- posizionare il contenuto statico prima di quello dinamico è ancora più importante qui poiché paghi un premio di scrittura.

Esempio con Python SDK di Anthropic

import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

def chat(user_message: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
                "cache_control": {"type": "ephemeral"},  # Breakpoint esplicito
            }
        ],
        messages=[
            {"role": "user", "content": user_message},
        ],
    )

    # Leggi le metriche della cache dalla risposta
    usage = response.usage
    created = usage.cache_creation_input_tokens
    read = usage.cache_read_input_tokens
    standard = usage.input_tokens
    print(f"Cache write: {created}, Cache read: {read}, Standard: {standard}")

    return response.content[0].text

# Prima chiamata: cache_creation_input_tokens = ~1920 (scrittura a 1,25x)
chat("Review this async function for race conditions...")

# Seconda chiamata: cache_read_input_tokens = ~1920 (lettura a 0,1x -- 90% di sconto!)
chat("Now optimize the same function for throughput...")

Capire la Tariffazione Scrittura vs Lettura Cache

Ecco dove la tariffazione di Anthropic diventa interessante. Usando Claude Sonnet 4.5 ($3/MTok input base) come esempio:

• Input standard: $3,00 per milione di token
• Scrittura cache (5 min): $3,75 per milione di token (1,25x) -- paghi di più la prima volta
• Lettura cache: $0,30 per milione di token (0,1x) -- 90% più economico ad ogni hit successivo

La cache da 5 minuti si ripaga dopo soli 1 lettura. La cache da 1 ora ($6,00/MTok scrittura) si ripaga dopo 2 letture. Se fai più di un paio di richieste al minuto con lo stesso prefisso, i conti sono schiaccianti a tuo favore.

Verdetto: Anthropic offre lo sconto più profondo (90%) e il massimo controllo. La scelta migliore per carichi di lavoro ad alto volume e sensibili ai costi.

Come Gestisce Google Gemini il Caching dei Prompt?

Gemini adotta un approccio diverso con due meccanismi di caching distinti: caching del contesto esplicito (oggetti cache nominati che crei e referenzi) e caching implicito (automatico, zero config, aggiunto nel 2026 per i modelli Gemini 2.5+).

Caching del Contesto Esplicito (Cache Nominate)

A differenza di OpenAI e Anthropic dove il caching è trasparente, il caching esplicito di Gemini richiede che tu crei prima un oggetto cache nominato e poi lo referenzi nelle richieste successive. La soglia minima di token è di 1.024 token per i modelli Gemini Flash e 4.096 token per i modelli Pro. Il TTL è configurabile -- il valore predefinito è 1 ora, ma puoi impostarlo in base alle tue esigenze.

I token in cache su Gemini 2.5 Pro hanno un prezzo di $0,125/MTok rispetto al prezzo di input standard di $1,25/MTok -- uno sconto del 90%. C'è anche un costo di archiviazione di $4,50 per milione di token all'ora per Pro, e $1,00 per Flash.

Caching Implicito in Gemini 2.5 (2026)

A partire da Gemini 2.5 Pro e Flash, Google ha aggiunto il caching implicito -- caching automatico che funziona come l'approccio di OpenAI. Nessuna configurazione necessaria. Posiziona contenuto grande e comune all'inizio del tuo prompt e invia richieste con prefissi simili in rapida successione. Il sistema rileva automaticamente il contenuto idoneo al caching e trasferisce i risparmi.

Esempio con Python SDK di Gemini

from google import genai
from google.genai import types

client = genai.Client()

SYSTEM_PROMPT = """You are a senior Python developer specializing in async programming.
You follow PEP 8, use type hints, and write comprehensive docstrings.
When reviewing code, check for: race conditions, resource leaks, error handling,
and performance bottlenecks. Always suggest specific fixes with code examples.
[... imagine 1,800 more tokens of coding guidelines, examples, and rules ...]"""

# Passo 1: Crea un oggetto cache nominato
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        display_name="python-review-guidelines",
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",  # 1 ora
    ),
)

print(f"Cache created: {cache.name}, expires: {cache.expire_time}")

# Passo 2: Usa la cache nelle richieste
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Review this async function for race conditions...",
    config=types.GenerateContentConfig(
        cached_content=cache.name,
    ),
)

# Verifica l'utilizzo della cache nella risposta
metadata = response.usage_metadata
print(f"Cached tokens: {metadata.cached_content_token_count}")
print(f"Total input tokens: {metadata.prompt_token_count}")

L'approccio esplicito ha un grande vantaggio: controlli il TTL con precisione. Se sai che il tuo job batch dura 4 ore, imposta un TTL di 4 ore ed evita la scadenza della cache a metà elaborazione.

Verdetto: Il TTL configurabile di Gemini e i due modalità di caching (esplicito + implicito) lo rendono versatile. La soglia minima è ora paragonabile agli altri provider, e lo sconto del 90% sulle letture in cache corrisponde ad Anthropic.

Confronto del Codice Affiancato -- Stesso Caso d'Uso, Tutti e 3 i Provider

Ecco lo stesso chatbot con un prompt di sistema in cache, implementato in tutti e tre gli SDK. Confronta l'esperienza dello sviluppatore direttamente.

# --- OpenAI: Zero config, chiama semplicemente l'API ---
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},  # Memorizzato in cache automaticamente
        {"role": "user", "content": user_message},
    ],
)
cached = response.usage.prompt_tokens_details.cached_tokens

# --- Anthropic: Breakpoint cache_control esplicito ---
import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},  # Contrassegna il confine della cache
    }],
    messages=[{"role": "user", "content": user_message}],
)
cached = response.usage.cache_read_input_tokens

# --- Gemini: Oggetto cache nominato ---
from google import genai
from google.genai import types

client = genai.Client()
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",
    ),
)
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=user_message,
    config=types.GenerateContentConfig(cached_content=cache.name),
)
cached = response.usage_metadata.cached_content_token_count

Se vuoi risparmi senza sforzo, scegli OpenAI. Se vuoi lo sconto più profondo e un controllo dettagliato, scegli Anthropic. Se hai bisogno di durate della cache configurabili o sei già su Google Cloud, scegli Gemini.

Calcolatore dei Costi in Produzione -- Risparmi Reali su Larga Scala

Le percentuali astratte non guidano le decisioni. I valori in dollari sì. Ecco tre scenari di produzione con stime di costo reali usando Claude Sonnet 4.5 ($3/MTok input), GPT-4o ($2,50/MTok input) e Gemini 2.5 Pro ($1,25/MTok input).

Prezzi verificati marzo 2026. Controlla Anthropic, OpenAI e Gemini per le tariffe aggiornate.

Ipotesi: 80% di tasso di successo della cache (realistico per prompt ben strutturati), token di output esclusi poiché il caching influenza solo i costi di input.

Al livello Growth, il caching Anthropic fa risparmiare $576/mese nonostante un prezzo base più alto di OpenAI. Su scala Enterprise, parliamo di $7.200/mese di risparmi con Anthropic -- o $86.400 all'anno. È l'equivalente dello stipendio di un ingegnere senior risparmiato con una modifica alla configurazione.

Il pattern è chiaro: più alto è il volume delle richieste e più lungo il prefisso statico, più il caching fa risparmiare. Lo sconto del 90% di Anthropic domina su larga scala, ma il prezzo base più basso di Gemini lo rende competitivo quando si considera il costo totale.

Anti-Pattern del Caching dei Prompt -- Quando NON Usare il Caching

Il caching sembra semplice finché il tuo tasso di successo non si posiziona misteriosamente allo 0%. Ecco gli errori che distruggono silenziosamente il caching dei prompt -- e come correggerli.

Errori che Rompono la Cache (Con Soluzioni)

Timestamp nei prompt di sistema -- L'errore più comune. Se il tuo prompt di sistema include datetime.now(), la chiave della cache cambia ogni secondo.

# MALE: Cache miss ad ogni singola richiesta
system_prompt = f"""You are a helpful assistant.
Current time: {datetime.now().isoformat()}
Always be helpful and accurate."""

# BENE: Sposta il timestamp nel messaggio utente
system_prompt = """You are a helpful assistant.
Always be helpful and accurate."""

user_message = f"[Current time: {datetime.now().isoformat()}]\n{user_query}"

Contenuto specifico dell'utente prima del contenuto statico -- Se metti session_id o preferenze utente all'inizio, ogni utente ottiene un prefisso unico.

# MALE: Prefisso unico per utente = zero riutilizzo della cache
messages = [
    {"role": "system", "content": f"User ID: {user_id}\nPreferences: {prefs}\n{GUIDELINES}"},
    {"role": "user", "content": query},
]

# BENE: Contenuto statico prima, contesto utente alla fine
messages = [
    {"role": "system", "content": GUIDELINES},  # Uguale per tutti gli utenti -> in cache
    {"role": "user", "content": f"Context: User {user_id}, prefs: {prefs}\n{query}"},
]

Quando il Caching dei Prompt Non Aiuta Davvero

Alcuni scenari non beneficeranno del caching anche se strutturi i tuoi prompt perfettamente:

• Prompt a uso singolo: Se ogni richiesta ha un contesto completamente unico senza prefisso condiviso, non c'è nulla da memorizzare in cache.
• Prompt molto corti: Sotto i 1.024 token (OpenAI/Anthropic) o i 4.096 token (Gemini Pro), il caching non si attiva.
• Richieste poco frequenti: Se le richieste sono distanziate di ore, la cache scade prima che arrivi una seconda richiesta. La finestra di 5-10 minuti di OpenAI e il TTL predefinito di 5 minuti di Anthropic significano che hai bisogno di traffico costante.

Il Caching dei Prompt Funziona con lo Streaming?

Sì. Il caching dei prompt e lo streaming sono indipendenti -- il caching opera sui token di input, lo streaming influisce sulla consegna dell'output. Risolvono problemi diversi in fasi diverse del ciclo di vita della richiesta.

La cache gestisce la fase di prefill (elaborazione del tuo prompt di input). Lo streaming gestisce la fase di decodifica (generazione e invio incrementale dei token di output). Ottieni entrambi i vantaggi simultaneamente: prefill più veloce grazie al cache hit, più consegna progressiva dell'output grazie allo streaming.

Ecco un esempio di streaming con caching abilitato:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": "Explain Python's GIL..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    # Dopo il completamento dello streaming, controlla le metriche della cache
    usage = stream.get_final_message().usage
    print(f"\nCache read: {usage.cache_read_input_tokens} tokens")

Il miglioramento del TTFT grazie al caching è in realtà il più notevole con lo streaming. Senza caching, aspetti il prefill completo prima che il primo token venga restituito in streaming. Con il caching, il prefill è quasi istantaneo, quindi i token iniziano a fluire quasi immediatamente.

Come Monitorare i Tassi di Successo della Cache in Produzione

Configurare il caching è metà della battaglia. Sapere se funziona davvero è l'altra metà. Se il tuo tasso di successo della cache scende sotto il 50%, qualcosa è cambiato nella struttura del tuo prompt e stai lasciando soldi sul tavolo.

Metriche Cache Specifiche del Provider

Un Semplice Logger del Tasso di Successo della Cache

Ecco una funzione di utilità che puoi inserire in qualsiasi progetto per monitorare i tassi di successo della cache tramite i campi di risposta API:

import logging

logger = logging.getLogger("cache_monitor")

def log_cache_metrics(provider: str, usage: dict) -> float:
    """Estrae e registra le metriche della cache dalla risposta di qualsiasi provider. Restituisce il tasso di successo."""

    if provider == "openai":
        cached = getattr(usage.prompt_tokens_details, "cached_tokens", 0)
        total = usage.prompt_tokens
    elif provider == "anthropic":
        cached = usage.cache_read_input_tokens
        created = usage.cache_creation_input_tokens
        total = cached + created + usage.input_tokens
    elif provider == "gemini":
        cached = getattr(usage, "cached_content_token_count", 0)
        total = usage.prompt_token_count
    else:
        raise ValueError(f"Unknown provider: {provider}")

    hit_rate = (cached / total * 100) if total > 0 else 0
    logger.info(f"[{provider}] Cache hit rate: {hit_rate:.1f}% ({cached}/{total} tokens)")

    if hit_rate < 50:
        logger.warning(f"[{provider}] Low cache hit rate! Check prompt structure.")

    return hit_rate

Un sistema di produzione sano dovrebbe mantenere tassi di successo della cache del 70-90%. Se sei sotto il 50%, rivisita la sezione degli anti-pattern. Puoi anche integrare questo con metriche di valutazione automatizzate per rilevare regressioni nella tua pipeline di prompt.

Il Caching dei Prompt in Casi d'Uso Reali

Gli esempi di chatbot sopra illustrano la meccanica, ma il caching dei prompt brilla davvero in pattern architetturali specifici.

Pipeline RAG

In un setup RAG, il tuo prompt di sistema e i tuoi esempi few-shot sono statici per tutte le query. I documenti recuperati cambiano ogni volta. Struttura il tuo prompt per massimizzare il prefisso in cache:

1. Prompt di sistema (in cache)
2. Esempi few-shot (in cache)
3. Documenti recuperati (dinamico -- va alla fine)
4. Query dell'utente (sempre unica)

Con un prompt di sistema da 5.000 token e 3.000 token di esempi few-shot, sono 8.000 token in cache ad ogni richiesta. Con 1.000 richieste/giorno su Anthropic, risparmieresti circa $6,50/giorno solo sul prefisso in cache. Quando recuperi e memorizzi in cache blocchi di contesto, assicurati che l'output del recupero venga dopo il prefisso statico.

Chatbot Multi-Turno

Le conversazioni multi-turno sono un punto di forza per il caching dei prompt. Ogni turno si aggiunge alla cronologia della conversazione, ma tutta la conversazione precedente è già in cache dai turni precedenti. Il vantaggio della cache si accumula -- al turno 10, potresti avere 15.000 token di cronologia in cache con solo 200 token freschi dall'ultimo messaggio dell'utente.

Sistemi Agentici e Definizioni di Strumenti MCP

Se stai costruendo agenti con l'uso di strumenti, le tue definizioni di strumenti sono schemi JSON statici ripetuti ad ogni singola chiamata API. Un agente tipico potrebbe avere 20+ strumenti per un totale di 3.000-5.000 token di definizioni. Quello è materiale eccellente per il caching.

Questo è particolarmente rilevante per le architetture basate su MCP dove le definizioni degli strumenti del server vengono inviate ad ogni chiamata. Con il cache_control esplicito di Anthropic, puoi contrassegnare l'array tools per il caching e garantire che quei token vengano riutilizzati.

Quale Provider Dovresti Scegliere?

Se stai già usando un provider, inizia lì -- il caching dei prompt non richiede di cambiare. LiteLLM funge da livello proxy che normalizza i parametri di caching tra i provider, utile se stai instradando richieste a più modelli.

FAQ -- Caching dei Prompt LLM

Cos'è il caching dei prompt negli LLM?

Il caching dei prompt memorizza gli stati di attenzione calcolati (cache KV) dai prefissi dei prompt elaborati in precedenza. Quando una richiesta successiva inizia con la stessa sequenza di token, il provider riutilizza quegli stati memorizzati invece di ricalcolarli -- riducendo sia il costo che la latenza senza impatto sulla qualità dell'output.

Quanto risparmia il caching dei prompt sui costi API?

I risparmi vanno dal 50% al 90% a seconda del provider. OpenAI offre uno sconto del 50% sui token di input in cache. Anthropic offre fino al 90% di sconto (letture in cache a 0,1x del prezzo base). Gemini offre circa il 90% di sconto sulle letture in cache. I risparmi effettivi dipendono dal tuo tasso di successo della cache, dalla lunghezza del prompt e dalla frequenza delle richieste.

Il caching dei prompt di OpenAI avviene automaticamente?

Sì, da ottobre 2024. Qualsiasi chiamata API con 1.024+ token di input beneficia automaticamente del caching. Nessun opt-in, nessun header, nessuna modifica al codice richiesta. La cache corrisponde ai prefissi di token dall'inizio del prompt.

Qual è la differenza tra caching dei prompt e caching semantico?

Il caching dei prompt corrisponde a prefissi di token esatti a livello GPU -- non c'è perdita di accuratezza e gli output sono identici alle richieste non in cache. Il caching semantico usa la similarità degli embedding per trovare query precedenti "abbastanza vicine" e restituire risposte in cache -- è più veloce ma può restituire risposte errate o obsolete. Risolvono problemi fondamentalmente diversi.

Quanto dura la cache dei prompt?

Varia per provider. OpenAI: 5-10 minuti (fino a 24 ore con conservazione estesa). Anthropic: 5 minuti (predefinito) o 1 ora (disponibile sui modelli Claude 4.5+, costa 2x in scrittura). Gemini: configurabile, 1 ora per impostazione predefinita per le cache esplicite. Il TTL del caching implicito è gestito automaticamente da Google.

Qual è la lunghezza minima di token per il caching dei prompt?

OpenAI: 1.024 token. Anthropic: 1.024 token per la maggior parte dei modelli attuali. Gemini: 1.024 token per i modelli Flash, 4.096 per i modelli Pro. I prompt al di sotto di queste soglie non attiveranno il caching -- questo è il problema più comune del tipo "non funziona".

Il caching dei prompt funziona con le risposte in streaming?

Sì. Il caching e lo streaming operano su fasi diverse della richiesta. Il caching accelera la fase di prefill dell'input; lo streaming consegna i token di output in modo incrementale. Entrambi funzionano simultaneamente, e noterai il miglioramento del TTFT di più con lo streaming abilitato.

Quando NON dovrei usare il caching dei prompt?

Evita di fare affidamento sul caching quando i tuoi prompt sono sotto la soglia minima di token, quando includi timestamp o ID di sessione nel prompt di sistema, quando ruoti gli esempi few-shot tra le chiamate, o quando le richieste sono troppo poco frequenti per raggiungere la cache prima che scada (finestra di 5-10 minuti per OpenAI/Anthropic).

Posso usare il caching dei prompt con LangChain o LiteLLM?

Sì. LangChain passa i parametri di caching specifici del provider attraverso i suoi wrapper API. LiteLLM fornisce una sintassi di caching unificata che normalizza cache_control per Anthropic, OpenAI, Gemini, Vertex AI e Bedrock -- particolarmente utile per configurazioni multi-provider.

Cos'è un cache hit vs un cache miss?

Un cache hit significa che il provider ha trovato un prefisso corrispondente in memoria e ha riutilizzato gli stati KV memorizzati -- paghi la tariffa scontata dei token in cache e ottieni un TTFT più veloce. Un cache miss significa che non è stata trovata alcuna corrispondenza, quindi il prompt completo viene elaborato da zero al prezzo standard. Controlla i campi cached_tokens (OpenAI), cache_read_input_tokens (Anthropic) o cachedContentTokenCount (Gemini) nella risposta API per vedere quale si è verificato.

Verdetto Finale

Il caching dei prompt è l'ottimizzazione a minor sforzo e maggior rendimento nell'intero stack API LLM. Non cambi il tuo modello, non sacrifichi la qualità, e l'implementazione va da "non fare nulla" (OpenAI) ad "aggiungere un campo" (Anthropic) a "creare un oggetto cache" (Gemini).

Inizia con il caching automatico del tuo provider attuale. Misura il tuo tasso di successo della cache con l'utilità di logging sopra. Se sei sotto il 70%, ristruttura i tuoi prompt (statico prima, dinamico alla fine) ed elimina gli anti-pattern. La maggior parte dei team vede una riduzione dei costi del 50-80% nel giorno successivo all'implementazione di queste modifiche.

Fonti

• Anthropic Prompt Caching Documentation
• OpenAI Prompt Caching Guide
• Gemini Context Caching Documentation
• Anthropic Model Pricing
• Gemini API Pricing
• KV Caching Explained -- Hugging Face Blog
• LiteLLM Prompt Caching Documentation