Caché avanzado de prompts
En esta página
Más allá del caché automático
Viste los fundamentos del caché de prompts en la Lección 3. Allí, el caché aparecía como un mecanismo automático que te beneficia sin esfuerzo especial, y eso es cierto siempre que tu aplicación envíe solicitudes bien ordenadas. La realidad de producción es más caótica: múltiples usuarios golpean la misma API simultáneamente, cada uno con su propia carpeta, documentos y preguntas. El prefijo común se reduce entonces a casi nada, y la tasa de aciertos del caché se desploma sin que nadie lo note, ya que nada se rompe; simplemente sube la factura.
Entornos multiusuario, multidocumento y tuberías de procesamiento: abordaremos estos escenarios complejos uno por uno para maximizar la tasa de aciertos del caché. El principio rector cabe en una frase: el caché no es algo que te ocurre; es algo que diseñas.
Arquitectura de prompts para maximizar el caché
El caché se aplica al prefijo común más largo entre tus solicitudes. Cuanto más largo y estable sea este prefijo, más ahorrarás. La consecuencia práctica es que un prompt debe organizarse de lo más estable a lo más variable, como un libro cuyas primeras páginas nunca cambian y solo el capítulo final se reescribe con cada edición.
El ejemplo siguiente aplica este principio a un asistente de análisis documental para un bufete de abogados. Tres capas se suceden: instrucciones globales, que están congeladas; la base de conocimientos, revisada una vez al mes; y el expediente del caso y la pregunta, que cambian en cada llamada.
import openai
client = openai.OpenAI()
# Arquitectura por capas: de lo más estable a lo más variable
# Capa 1: Instrucciones globales (nunca cambian)
GLOBAL_INSTRUCTIONS = """
Eres un asistente de análisis documental para un bufete de abogados.
Reglas:
- Responde siempre en francés
- Cita los artículos legales relevantes
- Estructura como: Análisis / Riesgos / Recomendaciones
- Sé factual y preciso
"""
# Capa 2: Base de conocimientos (cambia raramente)
KNOWLEDGE_BASE = """
[Inserta aquí más de 5.000 tokens de jurisprudencia, artículos legales,
plantillas de análisis; este contenido cambia como máximo una vez al mes]
"""
# Capa 3: Contexto del caso (cambia por cliente)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Caso actual ---
{case_context}
--- Pregunta ---
{question}"""
El error clásico es colocar el nombre del cliente o la fecha de hoy al inicio del prompt del sistema para «personalizarlo». Un solo carácter variable en la posición inicial basta para hacer único el prefijo, reduciendo a cero la tasa de aciertos del caché para todas las capas posteriores. Todo lo que varíe debe ir al final.
Por supuesto, necesitas verificar que la teoría se traduzca en números. El siguiente monitor lee input_tokens_details.cached_tokens en cada respuesta y acumula las mediciones, ofreciéndote una tasa media utilizable en lugar de una corazonada.
class CacheMonitor:
"""Monitoriza la eficiencia del caché de prompts."""
def __init__(self):
self.calls: list[dict] = []
def record(self, usage) -> dict:
total_input = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
rate = cached_tokens / total_input if total_input > 0 else 0
entry = {
"total_input": total_input,
"cached_tokens": cached_tokens,
"cache_rate": rate,
}
self.calls.append(entry)
return entry
@property
def average_rate(self) -> float:
if not self.calls:
return 0.0
return sum(a["cache_rate"] for a in self.calls) / len(self.calls)
def report(self) -> str:
if not self.calls:
return "Sin llamadas."
return (
f"Llamadas: {len(self.calls)} | "
f"Tasa media de caché: {self.average_rate:.1%} | "
f"Tokens ahorrados: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Tres patrones que marcan la diferencia
El primer patrón concierne al orden de procesamiento. Cuando procesas un lote de solicitudes heterogéneas, ejecutarlas en orden de llegada alterna los prefijos e impide que el caché se mantenga caliente. Agrupar por contexto compartido resuelve el problema: reúne primero, ejecuta después, para que cada grupo se beneficie del prefijo preparado por su primera solicitud.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Agrupa solicitudes por prefijo común."""
groups = defaultdict(list)
for request in requests:
# Clave = hash del contexto compartido
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Procesa solicitudes agrupadas para maximizar el caché."""
groups = group_by_context(requests)
for key, group in groups.items():
# Todas las solicitudes del grupo comparten el mismo prefijo
for request in group:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=request["shared_context"],
input=request["question"],
)
monitor.record(response.usage)
El segundo patrón gestiona los arranques en frío. La primera solicitud de una serie paga el precio completo, ya que aún no hay nada en caché; si esa primera solicitud proviene de un usuario real un lunes por la mañana a las 9:00, ese usuario asume la latencia. Una solicitud de calentamiento enviada antes de que el servicio se abra traslada ese coste a donde no molesta a nadie. Observa la guarda al inicio de la función: por debajo de 1.024 tokens, el caché no se aplica, y el precalentamiento sería un gasto puro.
def warm_up_cache(system_prompt: str):
"""Envía una solicitud mínima para preparar el caché."""
if len(system_prompt) // 4 < 1024:
print("Prompt demasiado corto para el caché (< 1.024 tokens)")
return
response = client.responses.create(
model="gpt-5.6-terra",
instructions=system_prompt,
input="Confirma que estás listo.",
max_output_tokens=10,
)
usage = response.usage
print(
f"Caché preparado: {usage.input_tokens} tokens de entrada, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} en caché"
)
El tercer patrón hace visible la invalidación del caché. Corregir una coma en un prompt del sistema de 5.000 tokens parece trivial, sin embargo, esa coma vacía el caché para todos. Al adjuntar una huella digital al contenido, detectas el cambio en el despliegue en lugar de al día siguiente en la factura, y puedes proceder inmediatamente con el precalentamiento.
import hashlib
class VersionedPrompt:
"""Gestiona versiones de prompts para controlar el caché."""
def __init__(self, content: str):
self.content = content
self.version = hashlib.md5(content.encode()).hexdigest()[:8]
def is_same_version(self, other: "VersionedPrompt") -> bool:
return self.version == other.version
# Si la versión cambia, el caché se invalidará
prompt_v1 = VersionedPrompt("Instrucciones v1...")
prompt_v2 = VersionedPrompt("Instrucciones v2 modificadas...")
if not prompt_v1.is_same_version(prompt_v2):
print("Advertencia: prompt cambiado, el caché se invalidará")
warm_up_cache(prompt_v2.content)
Qué significa esto en volumen
Tomemos un caso real de 10.000 llamadas al día con un prompt del sistema de 3.000 tokens. Sin caché, facturas 10.000 × 3.000, es decir, 30 millones de tokens de entrada cada día. Con una tasa de aciertos del 80 %, 6 millones de tokens permanecen a precio completo y 24 millones bajan a la mitad de precio, lo que lleva los ahorros a aproximadamente un 40 % en tokens de entrada. La cifra parece modesta respecto a una sola llamada; a lo largo de un año de producción, cambia la estructura de costes de la aplicación.
Puntos clave
- Estructura tus prompts en capas, de lo más estable a lo más variable
- Agrupa las solicitudes por contexto compartido para mantener el caché caliente
- Calienta el caché antes de los picos de tráfico
- Monitoriza la tasa de caché con
input_tokens_details.cached_tokens - Versiona tus prompts para anticipar las invalidaciones del caché