Caché de Prompts LLM: Reduce los Costos de API un 90% (Los 3 Proveedores)

Caché de Prompts LLM: Reduce los Costos de API un 90% (Los 3 Proveedores)

El caché de prompts LLM te permite reutilizar tokens ya procesados entre llamadas a la API -- reduciendo los costos de entrada hasta un 90% y el tiempo hasta el primer token hasta un 85%. Si envías el mismo prompt de sistema, las mismas definiciones de herramientas o los mismos ejemplos few-shot en cada solicitud, estás pagando el precio completo por un trabajo que la GPU ya realizó.

Esta guía cubre OpenAI, Anthropic y Gemini con el mismo chatbot implementado en los tres SDK -- algo que ninguna otra guía hace. También cubrimos la actualización de caché automático de Anthropic de febrero de 2026, escenarios de costos en producción con cifras reales en dólares, y los antipatrones que destruyen silenciosamente tu tasa de aciertos de caché.

Resumen Rápido -- Los Tres Proveedores de un Vistazo

Antes de profundizar en los detalles de implementación, aquí tienes la comparación completa. Si ya sabes qué proveedor usas, salta directamente a esa sección. Si estás evaluando, esta tabla te dice todo en 10 segundos.

Conclusión clave: OpenAI es el más sencillo (cero configuración, 50% de descuento). Anthropic ofrece el descuento más profundo (90%) con mayor control. Gemini ofrece TTL configurable y caché implícito en modelos 2.5+ con descuentos comparables a Anthropic.

¿Cómo Funciona el Caché de Prompts LLM?

No necesitas entender los mecanismos internos de los transformers para usar el caché de prompts de manera efectiva. Pero sí necesitas entender un concepto: coincidencia de prefijos.

El Caché KV en 60 Segundos

Cuando un LLM procesa tu prompt, calcula estados de atención (pares clave-valor) para cada token. Estas entradas del caché KV son la parte costosa -- consumen memoria de GPU y tiempo de cómputo. El caché de prompts almacena estos estados calculados para que la siguiente solicitud con el mismo prefijo omita completamente el recálculo.

La palabra clave es prefijo. El caché coincide desde el inicio de tu prompt. Si los primeros 2.000 tokens coinciden con una entrada en caché pero el token 2.001 difiere, esos primeros 2.000 tokens se sirven desde el caché. Todo lo que viene después del punto de divergencia se calcula de nuevo.

Por eso importa el orden del prompt. Estructura tus prompts así:

1. Definiciones de herramientas (las más estáticas)
2. Prompt de sistema
3. Ejemplos few-shot estáticos
4. Contexto recuperado (semi-dinámico)
5. Historial de conversación (crece por turno)
6. Consulta del usuario (siempre diferente)

Contenido estático primero, contenido dinámico al final. Cuantos más tokens coincidan con el prefijo en caché, mayores serán los ahorros.

Caché de Prompts vs Caché Semántico vs Caché de Respuestas

Estos tres términos se confunden constantemente. El caché de prompts (de lo que trata esta guía) reutiliza los estados KV calculados a nivel GPU para prefijos de tokens idénticos -- cero pérdida de precisión, misma salida que sin caché. El caché semántico usa similitud de embeddings para devolver respuestas generadas previamente para consultas "suficientemente similares" -- más rápido pero puede devolver respuestas incorrectas. El caché de respuestas almacena pares exactos de entrada-salida y devuelve la respuesta en caché tal cual -- solo funciona para solicitudes verdaderamente idénticas.

El caché de prompts es la única "optimización gratuita" -- reduce costo y latencia sin ningún compromiso de precisión. Para las matemáticas profundas de los transformers detrás del caché KV, el artículo técnico de Hugging Face midió una aceleración de ~5,21x en GPUs T4.

¿Cómo Gestiona OpenAI el Caché de Prompts?

El caché de prompts de OpenAI es completamente automático. Desde octubre de 2024, cada llamada a la API con 1.024+ tokens de entrada se beneficia automáticamente del caché. Sin opt-in, sin encabezados, sin cambios de código.

Cómo Funciona el Caché Automático de OpenAI

Cuando envías una solicitud con al menos 1.024 tokens, OpenAI comprueba si el prefijo coincide con una solicitud reciente de tu organización. Los aciertos de caché cuestan 50% del precio estándar del token de entrada. Después del umbral inicial de 1.024 tokens, el caché coincide en incrementos de 128 tokens.

El caché dura 5-10 minutos durante el uso normal y puede persistir hasta 24 horas durante períodos de menor actividad. Está delimitado por organización, por lo que distintos proyectos dentro de la misma organización se benefician de cachés compartidos.

Los modelos compatibles incluyen GPT-4o, GPT-4o-mini, GPT-4.1, o1, o3-mini y todos los modelos más recientes.

Ejemplo con Python SDK de OpenAI

from openai import OpenAI

client = OpenAI()

# Este prompt de sistema tiene ~2.000 tokens -- muy por encima del mínimo de 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},
        ],
    )

    # Verificar si el caché se activó
    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

# Primera llamada: fallo de caché (precio completo)
chat("Review this async function for race conditions...")

# Segunda llamada en 5-10 min: acierto de caché (50% de descuento en tokens en caché)
chat("Now optimize the same function for throughput...")

La primera llamada procesa todo al precio completo y llena el caché. La segunda llamada reutiliza los tokens del prompt de sistema en caché a mitad de precio. Verás algo como Cached: 1920/2048 tokens (94%) en la salida.

Veredicto: OpenAI es el más fácil para comenzar -- cero configuración, el caché simplemente ocurre. El descuento del 50% es el más bajo de los tres proveedores, pero nada iguala su simplicidad.

¿Cómo Gestiona Anthropic/Claude el Caché de Prompts?

Anthropic ofrece dos modos: caché automático (habilitado por defecto desde febrero de 2026) y caché explícito con puntos de ruptura cache_control. La cifra principal es difícil de ignorar -- las lecturas en caché cuestan solo el 10% del precio de entrada estándar, un descuento del 90%.

Caché Automático vs Explícito (Actualización 2026)

A partir del 5 de febrero de 2026, Anthropic activa el caché automático por defecto para todos los prompts elegibles. Ya no necesitas el antiguo encabezado beta. El sistema determina automáticamente los puntos de ruptura de caché óptimos.

El caché explícito sigue disponible cuando quieres un control detallado. Colocas cache_control: {"type": "ephemeral"} en bloques de contenido específicos para marcar exactamente dónde debe estar el límite del caché. Esto es útil cuando tu prompt tiene una estructura específica y quieres garantizar que ciertas secciones se almacenen en caché.

Existen dos opciones de TTL:

• Caché de 5 minutos (predeterminado): las escrituras cuestan 1,25x el precio base de entrada, las lecturas cuestan 0,1x. Se amortiza después de 1 acierto de caché.
• Caché de 1 hora: las escrituras cuestan 2x el precio base de entrada, las lecturas cuestan 0,1x. Se amortiza después de 2 aciertos de caché. Disponible en modelos Claude 4.5+.

El aislamiento del caché cambió del nivel de organización al nivel de espacio de trabajo el 5 de febrero de 2026. Esto significa que distintos espacios de trabajo dentro de la misma organización mantienen cachés separados.

Al trabajar con el caché de Anthropic, ayuda estructurar tu prompt para un caché óptimo -- colocar el contenido estático antes del dinámico es aún más importante aquí ya que pagas una prima de escritura.

Ejemplo con Python SDK de 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"},  # Punto de ruptura explícito
            }
        ],
        messages=[
            {"role": "user", "content": user_message},
        ],
    )

    # Leer métricas de caché desde la respuesta
    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

# Primera llamada: cache_creation_input_tokens = ~1920 (escritura a 1,25x)
chat("Review this async function for race conditions...")

# Segunda llamada: cache_read_input_tokens = ~1920 (lectura a 0,1x -- ¡90% de descuento!)
chat("Now optimize the same function for throughput...")

Entender la Tarificación de Escritura vs Lectura de Caché

Aquí es donde la tarificación de Anthropic se vuelve interesante. Usando Claude Sonnet 4.5 ($3/MTok entrada base) como ejemplo:

• Entrada estándar: $3,00 por millón de tokens
• Escritura de caché (5 min): $3,75 por millón de tokens (1,25x) -- pagas más la primera vez
• Lectura de caché: $0,30 por millón de tokens (0,1x) -- 90% más barato en cada acierto posterior

El caché de 5 minutos se amortiza después de solo 1 lectura. El caché de 1 hora ($6,00/MTok escritura) se amortiza después de 2 lecturas. Si haces más de un par de solicitudes por minuto con el mismo prefijo, la matemática está abrumadoramente a tu favor.

Veredicto: Anthropic ofrece el descuento más profundo (90%) y el mayor control. La mejor opción para cargas de trabajo de alto volumen y sensibles al costo.

¿Cómo Gestiona Google Gemini el Caché de Prompts?

Gemini adopta un enfoque diferente con dos mecanismos de caché distintos: caché de contexto explícito (objetos de caché nombrados que creas y referencías) y caché implícito (automático, cero configuración, añadido en 2026 para modelos Gemini 2.5+).

Caché de Contexto Explícito (Cachés Nombrados)

A diferencia de OpenAI y Anthropic donde el caché es transparente, el caché explícito de Gemini requiere que primero crees un objeto de caché nombrado y luego lo referencias en solicitudes posteriores. El umbral mínimo de tokens es de 1.024 tokens para modelos Gemini Flash y 4.096 tokens para modelos Pro. El TTL es configurable -- el valor predeterminado es 1 hora, pero puedes ajustarlo según tus necesidades.

Los tokens en caché en Gemini 2.5 Pro tienen un precio de $0,125/MTok frente al precio de entrada estándar de $1,25/MTok -- un descuento del 90%. También hay un costo de almacenamiento de $4,50 por millón de tokens por hora para Pro, y $1,00 para Flash.

Caché Implícito en Gemini 2.5 (2026)

A partir de Gemini 2.5 Pro y Flash, Google añadió el caché implícito -- caché automático que funciona como el enfoque de OpenAI. Sin configuración necesaria. Coloca contenido grande y común al inicio de tu prompt y envía solicitudes con prefijos similares en rápida sucesión. El sistema detecta automáticamente el contenido apto para caché y transmite los ahorros.

Ejemplo con Python SDK de 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 ...]"""

# Paso 1: Crear un objeto de caché nombrado
cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        display_name="python-review-guidelines",
        system_instruction=SYSTEM_PROMPT,
        ttl="3600s",  # 1 hora
    ),
)

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

# Paso 2: Usar el caché en solicitudes
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,
    ),
)

# Verificar el uso del caché en la respuesta
metadata = response.usage_metadata
print(f"Cached tokens: {metadata.cached_content_token_count}")
print(f"Total input tokens: {metadata.prompt_token_count}")

El enfoque explícito tiene una gran ventaja: controlas el TTL con precisión. Si sabes que tu trabajo por lotes dura 4 horas, establece un TTL de 4 horas y evita la expiración del caché a mitad del procesamiento.

Veredicto: El TTL configurable de Gemini y sus dos modos de caché (explícito + implícito) lo hacen versátil. El umbral mínimo es ahora comparable a otros proveedores, y el descuento del 90% en lecturas en caché coincide con Anthropic.

Comparación de Código Lado a Lado -- Mismo Caso de Uso, Los 3 Proveedores

Aquí está el mismo chatbot con un prompt de sistema en caché, implementado en los tres SDK. Compara la experiencia del desarrollador directamente.

# --- OpenAI: Cero configuración, simplemente llama a la API ---
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},  # En caché automáticamente
        {"role": "user", "content": user_message},
    ],
)
cached = response.usage.prompt_tokens_details.cached_tokens

# --- Anthropic: Punto de ruptura cache_control explícito ---
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"},  # Marcar límite de caché
    }],
    messages=[{"role": "user", "content": user_message}],
)
cached = response.usage.cache_read_input_tokens

# --- Gemini: Objeto de caché nombrado ---
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

Si quieres ahorros sin esfuerzo, ve con OpenAI. Si quieres el mayor descuento y control detallado, elige Anthropic. Si necesitas tiempos de caché configurables o ya estás en Google Cloud, elige Gemini.

Calculadora de Costos en Producción -- Ahorros Reales a Escala

Los porcentajes abstractos no impulsan decisiones. Las cifras en dólares sí. Aquí hay tres escenarios de producción con estimaciones de costos reales usando Claude Sonnet 4.5 ($3/MTok entrada), GPT-4o ($2,50/MTok entrada) y Gemini 2.5 Pro ($1,25/MTok entrada).

Precios verificados marzo de 2026. Consulta Anthropic, OpenAI y Gemini para las tarifas actuales.

Supuestos: 80% de tasa de aciertos de caché (realista para prompts bien estructurados), tokens de salida excluidos ya que el caché solo afecta los costos de entrada.

En el nivel Growth, el caché de Anthropic ahorra $576/mes a pesar de tener un precio base más alto que OpenAI. A escala Enterprise, estamos hablando de $7.200/mes en ahorros con Anthropic -- o $86.400 al año. Eso es el salario de un ingeniero senior ahorrado con un simple cambio de configuración.

El patrón es claro: cuanto mayor es el volumen de solicitudes y más largo el prefijo estático, más ahorra el caché. El descuento del 90% de Anthropic domina a escala, pero el precio base más bajo de Gemini lo hace competitivo cuando se considera el costo total.

Antipatrones de Caché de Prompts -- Cuándo NO Usar Caché

El caché parece sencillo hasta que tu tasa de aciertos misteriosamente se sitúa en 0%. Aquí están los errores que destruyen silenciosamente el caché de prompts -- y cómo solucionarlos.

Errores que Rompen el Caché (Con Soluciones)

Marcas de tiempo en los prompts de sistema -- El error más común. Si tu prompt de sistema incluye datetime.now(), la clave del caché cambia cada segundo.

# MALO: Fallos de caché en cada solicitud
system_prompt = f"""You are a helpful assistant.
Current time: {datetime.now().isoformat()}
Always be helpful and accurate."""

# BUENO: Mover la marca de tiempo al mensaje del usuario
system_prompt = """You are a helpful assistant.
Always be helpful and accurate."""

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

Contenido específico del usuario antes del contenido estático -- Si pones session_id o preferencias del usuario al inicio, cada usuario obtiene un prefijo único.

# MALO: Prefijo único por usuario = cero reutilización del caché
messages = [
    {"role": "system", "content": f"User ID: {user_id}\nPreferences: {prefs}\n{GUIDELINES}"},
    {"role": "user", "content": query},
]

# BUENO: Contenido estático primero, contexto del usuario al final
messages = [
    {"role": "system", "content": GUIDELINES},  # Igual para todos los usuarios -> en caché
    {"role": "user", "content": f"Context: User {user_id}, prefs: {prefs}\n{query}"},
]

Cuándo el Caché de Prompts Genuinamente No Ayuda

Algunos escenarios no se beneficiarán del caché aunque estructures tus prompts perfectamente:

• Prompts de un solo uso: Si cada solicitud tiene un contexto completamente único sin prefijo compartido, no hay nada que almacenar en caché.
• Prompts muy cortos: Por debajo de 1.024 tokens (OpenAI/Anthropic) o 4.096 tokens (Gemini Pro), el caché no se activa.
• Solicitudes poco frecuentes: Si las solicitudes están separadas por horas, el caché expira antes de que llegue una segunda solicitud. La ventana de 5-10 minutos de OpenAI y el TTL predeterminado de 5 minutos de Anthropic significan que necesitas tráfico constante.

¿Funciona el Caché de Prompts con Streaming?

Sí. El caché de prompts y el streaming son independientes -- el caché opera en tokens de entrada, el streaming afecta la entrega de salidas. Resuelven problemas diferentes en distintas etapas del ciclo de vida de la solicitud.

El caché maneja la fase de prefill (procesamiento de tu prompt de entrada). El streaming maneja la fase de decodificación (generación y envío incremental de tokens de salida). Obtienes ambos beneficios simultáneamente: prefill más rápido gracias al acierto de caché, más entrega progresiva de salidas gracias al streaming.

Aquí hay un ejemplo de streaming con caché habilitado:

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)

    # Después del streaming, verificar métricas de caché
    usage = stream.get_final_message().usage
    print(f"\nCache read: {usage.cache_read_input_tokens} tokens")

La mejora del TTFT por el caché es en realidad la más notable con streaming. Sin caché, esperas el prefill completo antes de que el primer token vuelva en streaming. Con caché, el prefill es casi instantáneo, por lo que los tokens comienzan a fluir casi de inmediato.

Cómo Monitorear las Tasas de Aciertos de Caché en Producción

Configurar el caché es la mitad de la batalla. Saber si realmente está funcionando es la otra mitad. Si tu tasa de aciertos de caché cae por debajo del 50%, algo cambió en la estructura de tu prompt y estás dejando dinero sobre la mesa.

Métricas de Caché Específicas por Proveedor

Un Registrador Simple de Tasa de Aciertos de Caché

Aquí hay una función de utilidad que puedes incluir en cualquier proyecto para rastrear las tasas de aciertos de caché mediante campos de respuesta de la API:

import logging

logger = logging.getLogger("cache_monitor")

def log_cache_metrics(provider: str, usage: dict) -> float:
    """Extrae y registra métricas de caché desde la respuesta de cualquier proveedor. Devuelve la tasa de aciertos."""

    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 de producción saludable debería mantener tasas de aciertos de caché del 70-90%. Si estás por debajo del 50%, revisa la sección de antipatrones. También puedes integrar esto con métricas de evaluación automatizadas para detectar regresiones en tu pipeline de prompts.

Caché de Prompts en Casos de Uso del Mundo Real

Los ejemplos de chatbot anteriores ilustran la mecánica, pero el caché de prompts realmente brilla en patrones arquitectónicos específicos.

Pipelines RAG

En un setup RAG, tu prompt de sistema y tus ejemplos few-shot son estáticos para todas las consultas. Los documentos recuperados cambian cada vez. Estructura tu prompt para maximizar el prefijo en caché:

1. Prompt de sistema (en caché)
2. Ejemplos few-shot (en caché)
3. Documentos recuperados (dinámico -- va al final)
4. Consulta del usuario (siempre única)

Con un prompt de sistema de 5.000 tokens y 3.000 tokens de ejemplos few-shot, eso son 8.000 tokens en caché en cada solicitud. Con 1.000 solicitudes/día en Anthropic, ahorrarías aproximadamente $6,50/día solo en el prefijo en caché. Cuando recuperas y almacenas en caché bloques de contexto, asegúrate de que la salida de recuperación venga después del prefijo estático.

Chatbots Multi-Turno

Las conversaciones multi-turno son un punto fuerte para el caché de prompts. Cada turno se añade al historial de conversación, pero toda la conversación previa ya está en caché de turnos anteriores. El beneficio del caché se acumula -- en el turno 10, podrías tener 15.000 tokens de historial en caché con solo 200 tokens frescos del último mensaje del usuario.

Sistemas Agentivos y Definiciones de Herramientas MCP

Si estás construyendo agentes con uso de herramientas, tus definiciones de herramientas son esquemas JSON estáticos repetidos en cada llamada a la API. Un agente típico podría tener 20+ herramientas totalizando 3.000-5.000 tokens de definiciones. Eso es material primo para el caché.

Esto es especialmente relevante para arquitecturas basadas en MCP donde las definiciones de herramientas del servidor se envían en cada llamada. Con el cache_control explícito de Anthropic, puedes marcar el array tools para el caché y garantizar que esos tokens se reutilicen.

¿Qué Proveedor Deberías Elegir?

Si ya estás usando un proveedor, comienza allí -- el caché de prompts no requiere cambiar. LiteLLM actúa como capa proxy que normaliza los parámetros de caché entre proveedores, lo que es útil si estás enrutando solicitudes a múltiples modelos.

FAQ -- Caché de Prompts LLM

¿Qué es el caché de prompts en LLMs?

El caché de prompts almacena los estados de atención calculados (caché KV) a partir de prefijos de prompts procesados previamente. Cuando una solicitud posterior comienza con la misma secuencia de tokens, el proveedor reutiliza esos estados almacenados en lugar de recalcularlos -- reduciendo tanto el costo como la latencia sin impacto en la calidad de la salida.

¿Cuánto ahorra el caché de prompts en costos de API?

Los ahorros van del 50% al 90% dependiendo del proveedor. OpenAI ofrece un 50% de descuento en tokens de entrada en caché. Anthropic ofrece hasta un 90% de descuento (lecturas en caché a 0,1x el precio base). Gemini ofrece aproximadamente un 90% de descuento en lecturas en caché. Los ahorros reales dependen de tu tasa de aciertos de caché, la longitud del prompt y la frecuencia de las solicitudes.

¿El caché de prompts de OpenAI ocurre automáticamente?

Sí, desde octubre de 2024. Cualquier llamada a la API con 1.024+ tokens de entrada se beneficia automáticamente del caché. Sin opt-in, sin encabezados, sin cambios de código necesarios. El caché coincide con los prefijos de tokens desde el inicio del prompt.

¿Cuál es la diferencia entre el caché de prompts y el caché semántico?

El caché de prompts coincide con prefijos de tokens exactos a nivel GPU -- no hay pérdida de precisión, y las salidas son idénticas a las solicitudes sin caché. El caché semántico usa similitud de embeddings para encontrar consultas previas "suficientemente cercanas" y devolver respuestas en caché -- es más rápido pero puede devolver respuestas incorrectas u obsoletas. Resuelven problemas fundamentalmente diferentes.

¿Cuánto tiempo dura el caché de prompts?

Varía según el proveedor. OpenAI: 5-10 minutos (hasta 24 horas con retención extendida). Anthropic: 5 minutos (predeterminado) o 1 hora (disponible en modelos Claude 4.5+, cuesta 2x en escritura). Gemini: configurable, 1 hora por defecto para cachés explícitos. Google gestiona automáticamente el TTL del caché implícito.

¿Cuál es la longitud mínima de tokens para el caché de prompts?

OpenAI: 1.024 tokens. Anthropic: 1.024 tokens para la mayoría de los modelos actuales. Gemini: 1.024 tokens para modelos Flash, 4.096 para modelos Pro. Los prompts por debajo de estos umbrales no activarán el caché -- este es el problema más común de "no funciona".

¿Funciona el caché de prompts con respuestas en streaming?

Sí. El caché y el streaming operan en diferentes fases de la solicitud. El caché acelera la fase de prefill de entrada; el streaming entrega tokens de salida de forma incremental. Ambos funcionan simultáneamente, y notarás la mejora del TTFT más con el streaming habilitado.

¿Cuándo NO debería usar el caché de prompts?

Evita depender del caché cuando tus prompts estén por debajo del umbral mínimo de tokens, cuando incluyas marcas de tiempo o IDs de sesión en el prompt de sistema, cuando rotes ejemplos few-shot entre llamadas, o cuando las solicitudes sean demasiado poco frecuentes para alcanzar el caché antes de que expire (ventana de 5-10 minutos para OpenAI/Anthropic).

¿Puedo usar el caché de prompts con LangChain o LiteLLM?

Sí. LangChain pasa los parámetros de caché específicos del proveedor a través de sus envoltorios de API. LiteLLM proporciona una sintaxis de caché unificada que normaliza cache_control para Anthropic, OpenAI, Gemini, Vertex AI y Bedrock -- especialmente útil para configuraciones multi-proveedor.

¿Qué es un acierto de caché vs un fallo de caché?

Un acierto de caché significa que el proveedor encontró un prefijo coincidente en memoria y reutilizó los estados KV almacenados -- pagas la tarifa reducida de tokens en caché y obtienes un TTFT más rápido. Un fallo de caché significa que no se encontró ninguna coincidencia, por lo que el prompt completo se procesa desde cero al precio estándar. Revisa los campos cached_tokens (OpenAI), cache_read_input_tokens (Anthropic) o cachedContentTokenCount (Gemini) en la respuesta de la API para ver cuál ocurrió.

Veredicto Final

El caché de prompts es la optimización de menor esfuerzo y mayor retorno en la pila de API LLM. No cambias tu modelo, no sacrificas calidad, y la implementación va desde "no hacer nada" (OpenAI) hasta "añadir un campo" (Anthropic) hasta "crear un objeto de caché" (Gemini).

Empieza con el caché automático de tu proveedor actual. Mide tu tasa de aciertos de caché con el utilitario de registro anterior. Si estás por debajo del 70%, reestructura tus prompts (estático primero, dinámico al final) y elimina los antipatrones. La mayoría de los equipos ven una reducción de costos del 50-80% en el día después de implementar estos cambios.

Fuentes

• 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