Cada solicitud idéntica a un LLM que envía dos veces la paga dos veces. Una caché de respuestas guarda la respuesta la primera vez y la devuelve la siguiente, sin tokens facturados y sin espera. La idea es sencilla. Lo difícil es decidir qué hace que dos solicitudes sean “idénticas”, qué solicitudes nunca deben servirse desde el almacenamiento y si su tráfico se repite lo suficiente como para que valga la pena.
Este artículo construye una pequeña caché de coincidencia exacta en Python sobre SQLite, probada contra un servidor simulado compatible con OpenAI, y muestra cómo medir la tasa de aciertos a partir de sus logs antes de escribir una sola línea.
¿La caché de respuestas es lo mismo que el prompt caching?
No. Ahorran cosas distintas y puede usar ambas.
| Prompt caching (proveedor) | Caché de respuestas (usted) | |
|---|---|---|
| Qué se reutiliza | El inicio repetido del prompt | La respuesta completa |
| Quién la ejecuta | El proveedor de la API | Su código |
| ¿El modelo sigue ejecutándose? | Sí, escribe una respuesta nueva | No |
| Qué ahorra | Parte del costo de entrada | Tokens de entrada, salida y razonamiento, además de latencia |
| Cuándo acierta | Prefijo compartido, preguntas distintas | Exactamente la misma solicitud |
Tokens de entrada en caché explica el lado del proveedor, y estructura del prompt para la caché muestra cómo organizar un prompt para que se reutilice el prefijo. La calculadora de prompt caching le pone precio. Una caché de respuestas se sitúa delante de todo eso: cuando acierta, ninguna solicitud sale de su servidor.
¿Una caché le ahorrará dinero de verdad?
Mida antes de construir. Los porcentajes de ahorro de muchos tutoriales sobre caché salen del tráfico de otra persona. Su cifra depende de una sola cosa: con qué frecuencia vuelve a llegar la misma solicitud dentro de su ventana de expiración.
Si ya registra cada llamada, como en registro de uso de APIs de LLM, añada un campo: request_hash, la clave de caché que se describe más abajo. No guarda texto del prompt, así que encaja en un log que deja fuera el contenido. Después cuente las repeticiones:
import json
from collections import Counter
def potential_hit_rate(log_path: str) -> float:
"""Share of calls whose request_hash was already seen: an upper bound for an exact cache."""
hashes = [json.loads(line)["request_hash"] for line in open(log_path)]
seen, repeats = set(), 0
for h in hashes:
repeats += h in seen
seen.add(h)
print("top repeated requests:", Counter(hashes).most_common(3))
return repeats / len(hashes) if hashes else 0.0
print(f"potential hit rate: {potential_hit_rate('calls.jsonl'):.1%}")
Con un log sintético de 20 llamadas (una solicitud cinco veces, otra tres veces y doce únicas) imprimió una tasa potencial de aciertos del 30.0 %. Es un límite superior: ignora la expiración y supone que es seguro servir desde el almacenamiento cada repetición.
Luego convierta la tasa en dinero:
monthly saving = hit rate × requests per month
× (input tokens × input price + output tokens × output price) ÷ 1,000,000
Los tokens de salida incluyen el razonamiento. La documentación de BroadNet indica que DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder y que el razonamiento cuenta para max_tokens, así que un acierto ahorra tokens que nunca ve en la respuesta. Tome completion_tokens del usage registrado, no de la longitud de la respuesta.
Un ejemplo en tokens: 100,000 solicitudes al mes de 1,200 tokens de entrada y 150 de salida cada una, con una tasa de aciertos del 30 %, evitan 36 millones de tokens de entrada y 4.5 millones de tokens de salida. En DeepSeek V4.1 Flash se facturan a $0.175 y $0.52 por 1M, respectivamente; ingrese sus propias cifras en la calculadora de costos de API de LLM. Si la mayor parte de esa entrada ya era un acierto de la caché del proveedor, el ahorro en entrada es a la tarifa de caché, más baja ($0.0055 por 1M en el mismo modelo), así que lo que suele importar es la salida.
¿Qué va en la clave de caché?
Todo lo que puede cambiar la respuesta, y nada más.
- Incluya:
model, la lista completa demessages(con el prompt del sistema),temperature,top_p,max_tokens,seed,response_format,tools,tool_choiceyreasoning_effort. - Añada una versión del prompt que usted controle, como
faq-v3. Súbala cuando cambie plantillas de prompts, datos de recuperación o el posprocesamiento, cosas que el cuerpo de la solicitud no muestra. - Deje fuera todo lo que varía en cada llamada sin cambiar la respuesta: IDs de solicitud, marcas de tiempo, encabezados de trazas, un campo
userque solo envía para rastrear abusos.
Serialice el material de la clave siempre de la misma manera. json.dumps de Python con sort_keys=True y separators=(",", ":") produce una única cadena canónica sin importar el orden del diccionario; ensure_ascii=False mantiene el árabe y otros textos no latinos en UTF-8 en lugar de secuencias de escape. Calcule su hash con SHA-256.
El error peligroso es un campo que falta. Si max_tokens no está en la clave, una respuesta cortada por un límite pequeño se servirá a una solicitud que permitía una respuesta larga.
La caché: SQLite, TTL y una política de omisión
import hashlib, json, sqlite3, time
# Every field that changes the answer belongs in the key.
KEY_FIELDS = ("model", "messages", "temperature", "top_p", "max_tokens", "seed",
"response_format", "tools", "tool_choice", "reasoning_effort")
def cache_key(params: dict, prompt_version: str) -> str:
material = {k: params[k] for k in KEY_FIELDS if k in params}
material["prompt_version"] = prompt_version
canon = json.dumps(material, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(canon.encode("utf-8")).hexdigest()
class ResponseCache:
def __init__(self, path="llm_cache.sqlite", ttl_s=7 * 86400):
self.db, self.ttl = sqlite3.connect(path), ttl_s
self.db.execute("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, created REAL,"
" body TEXT, prompt_tokens INT, completion_tokens INT)")
self.hits = self.misses = self.skips = self.saved_in = self.saved_out = 0
def create(self, client, prompt_version: str, **params):
if params.get("stream") or params.get("temperature", 1) > 0:
self.skips += 1 # not cacheable: call the model directly
return client.chat.completions.create(**params)
k = cache_key(params, prompt_version)
row = self.db.execute("SELECT body, created, prompt_tokens, completion_tokens"
" FROM cache WHERE k = ?", (k,)).fetchone()
if row and time.time() - row[1] < self.ttl:
self.hits += 1; self.saved_in += row[2]; self.saved_out += row[3]
return json.loads(row[0]) # a plain dict, not an SDK object
self.misses += 1
r = client.chat.completions.create(**params)
choice = r.choices[0]
if choice.finish_reason == "stop" and not choice.message.tool_calls:
self.db.execute("INSERT OR REPLACE INTO cache VALUES (?, ?, ?, ?, ?)",
(k, time.time(), r.model_dump_json(),
r.usage.prompt_tokens, r.usage.completion_tokens))
self.db.commit()
return r.model_dump()
Y una ejecución con ella:
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
cache = ResponseCache("demo.sqlite", ttl_s=86400)
SYSTEM = {"role": "system", "content": "Answer questions about our refund policy in one sentence."}
questions = ["How long do refunds take?", "Can I refund a gift card?",
"How long do refunds take?", "How long do refunds take?", "Can I refund a gift card?"]
for q in questions:
r = cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": q}])
print(r["choices"][0]["message"]["content"])
# a personalised, sampled request is never cached
cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0.7,
messages=[SYSTEM, {"role": "user", "content": "Write me a friendly reminder"}])
# a new prompt version is a new key
cache.create(client, "faq-v4", model="broadnet/deepseek-v4.1-flash", temperature=0,
max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": "How long do refunds take?"}])
print(f"hits={cache.hits} misses={cache.misses} skipped={cache.skips} "
f"saved_input={cache.saved_in} saved_output={cache.saved_out}")
Lo ejecutamos con el SDK de Python de OpenAI 3.51.0 contra un servidor simulado local que contaba las llamadas salientes y reportaba 1,200 tokens de prompt y 150 de completion por respuesta (sin llamadas a una API real). Siete solicitudes generaron cuatro llamadas salientes. El script imprimió hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450. Al ejecutarlo de nuevo sobre el mismo archivo de base de datos, las seis solicitudes cacheables fueron aciertos (hits=6 misses=0): SQLite conserva la caché entre reinicios. Las claves construidas con los mismos campos en otro orden coincidieron.
Notas sobre el código:
max_tokens=1200deja espacio para el razonamiento antes de la respuesta. Con un límite pequeño, un modelo de razonamiento puede devolver una respuesta vacía (por qué). Esas respuestas no se guardan, porquefinish_reasoneslength, nostop.- Los aciertos devuelven un dict. Los fallos también devuelven
model_dump(), así que quien llama ve una sola forma. Si su código espera objetos del SDK, envuelva ambos. - Si falta
temperature, se considera muestreo. En ese caso el servidor aplica su propio valor por defecto, que puede ser mayor que 0, así que el envoltorio no cachea salvo que usted fije 0 explícitamente. - SQLite sirve para uno o pocos procesos. Con varios servidores, lleve la misma lógica de clave y TTL a Redis o a su base de datos.
¿Qué nunca debe servirse desde una caché?
- Respuestas muestreadas (temperature mayor que 0). Usted eligió variedad. La caché la elimina, y un usuario que pulsa “regenerar” obtiene el mismo texto.
- Respuestas personalizadas, salvo que el ID del usuario esté en la clave. Dos usuarios que envían “resuma mi cuenta” tienen cuentas distintas. Mejor: cachee solo solicitudes cuyos mensajes no contengan datos de cada usuario.
- Llamadas a herramientas. Una llamada a herramienta es una instrucción para actuar. Reproducir “refund order 1182” (es decir, «reembolsar el pedido 1182») desde el almacenamiento puede repetir un efecto secundario, y el siguiente paso correcto depende del estado actual. El envoltorio se niega a guardar cualquier respuesta con
tool_calls. - Respuestas en streaming. El envoltorio omite la caché con
stream=True. Cachear un stream implica acumularlo, comprobar que terminó y reproducirlo, lo que rara vez compensa en interfaces de chat. - Respuestas truncadas o fallidas. Guarde solo
finish_reason == "stop". Una respuesta cortada o un error cacheado durante una semana es un bug que parece un problema del modelo. - Respuestas que dependen del momento. “¿Cuál es el tipo de cambio de hoy?” necesita un TTL corto o ninguna caché.
Lo que sí se cachea bien: la clasificación de un conjunto fijo de entradas, la extracción de documentos que se vuelven a procesar, las respuestas de preguntas frecuentes a partir de un prompt fijo, las suites de pruebas y evaluaciones que se repiten, y los ciclos de desarrollo en los que se envía la misma solicitud una y otra vez.
¿Cuándo deben expirar las respuestas en caché?
Use tres tipos de invalidación:
- TTL. Un límite de tiempo por entrada: días para respuestas estables de preguntas frecuentes, minutos para cualquier cosa que lea datos en vivo.
- Versión en la clave. Cambie la versión del prompt cuando cambien el prompt del sistema, el índice de recuperación o el esquema de salida. Las entradas antiguas dejan de coincidir y caducan.
- Modelo en la clave. Ya está incluido, así que pasar de un modelo a otro inicia una caché nueva, que es lo que quiere mientras evalúa un cambio.
Borre periódicamente las filas caducadas (DELETE FROM cache WHERE created < ?). Si no, el archivo solo crece.
Hay un beneficio adicional. Los motores de inferencia no prometen una salida idéntica ante una entrada idéntica: la documentación de vLLM dice que “does not guarantee the reproducibility of the results by default” (Traducción: «no garantiza por defecto la reproducibilidad de los resultados»). Una caché da a todos los usuarios la misma respuesta a la misma pregunta durante la vida de la entrada.
¿Y la caché semántica?
Una caché semántica convierte cada pregunta en un embedding y devuelve una respuesta guardada cuando una pregunta nueva está lo bastante cerca, así que “¿cuánto tarda un reembolso?” puede acertar con “¿cuánto tardan los reembolsos?”. GPTCache es el ejemplo de código abierto más conocido. Su README dice que usa un almacén vectorial para la búsqueda por similitud y un evaluador de similitud para decidir un acierto, advierte que “you may encounter false positives during cache hits and false negatives during cache misses” (Traducción: «puede encontrar falsos positivos en los aciertos de caché y falsos negativos en los fallos de caché») y señala que, si se desactivan los embeddings, se convierte en una caché de coincidencia por palabras clave.
Dos puntos prácticos. Primero, necesita un modelo de embeddings y un almacén vectorial. BroadNet Inference no ofrece embeddings, así que tendría que usar otro proveedor o un modelo local para esa capa; la calculadora de costos de embeddings compara las opciones. Segundo, un acierto falso devuelve una respuesta segura a una pregunta distinta. Use un umbral de similitud estricto, pruébelo con pares reales de preguntas casi iguales y reserve la caché semántica para respuestas de bajo riesgo. En cualquier caso, ponga delante la caché exacta: consultarla no cuesta nada y nunca se equivoca sobre lo que se preguntó.
¿Qué implica una caché para la privacidad?
Una caché es un almacén de prompts y respuestas. Eso cambia el lugar donde viven sus datos.
La declaración de privacidad de inferencia de BroadNet, consultada el 2026-11-15, indica que su gateway no conserva prompts, mensajes, respuestas ni transcripciones, mientras que sí conserva registros de tráfico y uso sin contenido (conteos de tokens, costo, tiempos). El contenido de inferencia no se conserva. Los metadatos necesarios de cuenta, facturación y seguridad se conservan según describe esa declaración. Cuando añade una caché de respuestas, su sistema guarda el contenido que el proveedor no guarda. Trátela como cualquier otro almacén de datos de usuarios:
- Cachee solo solicitudes sin datos personales siempre que pueda, lo que además sube la tasa de aciertos.
- Fije un TTL lo bastante corto para su política de retención y borre de forma programada.
- Cifre el archivo o la tabla en reposo y limite quién puede leerlo.
- Incluya la caché en las solicitudes de eliminación de datos si puede contener texto de usuarios.
Enviar datos sensibles a una API de LLM cubre el resto de esa lista de verificación.
¿Cómo encaja la caché con otros controles de costos?
La caché elimina llamadas repetidas. No hace nada con las únicas, así que convive con los demás controles en lugar de sustituirlos: prompts más cortos, el prompt caching del proveedor, un tope de max_tokens por solicitud, y los presupuestos y límites de bucles de control de gasto en APIs de LLM. Para tareas grandes que se ejecutan una sola vez, elimine los duplicados de las entradas antes de enviarlas; es la misma idea que una caché, hecha una vez. Procesar una tarea grande sin una Batch API muestra el lado de la tarea.
Con un plan de tarifa plana, las cuentas cambian. Las sesiones de DeepSeek de BroadNet no tienen medidor de tokens, así que ahí un acierto de caché no ahorra dinero. Pero sí ahorra tiempo: una sesión ejecuta una solicitud a la vez, así que cada repetición que se salta libera la sesión para trabajo nuevo.
Dónde encaja BroadNet Inference
BroadRouter es el propio sitio de BroadNet. BroadNet Inference ofrece DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B y Gemma 4 VL 26B detrás de un endpoint /v1/chat/completions compatible con OpenAI, así que el envoltorio de arriba funciona con el SDK de Python de OpenAI cambiando la URL base. No tiene una función propia de caché de respuestas; la caché de este artículo es suya. Los aciertos de la caché del proveedor se reportan en usage.prompt_tokens_details.cached_tokens y se facturan al precio de entrada en caché, según su referencia de la API. Los precios por modelo están en la página de precios.
