---
title: "Caché de respuestas de LLM para ahorrar (Python, SQLite)"
description: "Caché de coincidencia exacta probada para respuestas de APIs de LLM en Python: qué va en la clave, qué no cachear, TTL, privacidad y cómo medir la tasa de aciertos."
url: https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (actualizado el 2026-11-15).

# Caché de respuestas de APIs de LLM para reducir costos en Python

Por el equipo de BroadNet Inference · 8 min de lectura · Publicado 2026-11-15

Calcule un hash de la solicitud completa (modelo, mensajes, temperature, max\_tokens, response\_format, herramientas, ajustes de razonamiento y su versión del prompt) como clave, y guarde la respuesta bajo ella con una expiración. Sirva una respuesta guardada solo para solicitudes deterministas y sin efectos secundarios. Mida primero en sus logs con qué frecuencia se repiten solicitudes idénticas: esa proporción es lo máximo que puede ahorrar una caché exacta.

## Puntos clave

-   Una caché exacta ahorra la llamada completa, tokens de salida y de razonamiento incluidos, pero solo para solicitudes idénticas byte a byte. Las preguntas parafraseadas siempre fallan.
-   Ponga en la clave todos los parámetros que cambian la respuesta, más una versión del prompt. Si omite uno, servirá respuestas incorrectas; si añade ruido como una marca de tiempo, todas las solicitudes fallarán.
-   No cachee respuestas muestreadas (temperature mayor que 0), respuestas en streaming, llamadas a herramientas ni respuestas cortadas en max\_tokens.
-   Mida primero: calcule el hash de cada solicitud en sus logs de uso y cuente las repeticiones. Las cifras de ahorro publicadas no dicen nada de su tráfico.
-   Una caché guarda prompts y respuestas. Si su proveedor no conserva contenido de inferencia, la caché pasa a ser el lugar donde vive ese contenido, así que asígnele un TTL y reglas de acceso.

**En esta página**

1.  ¿La caché de respuestas es lo mismo que el prompt caching?
2.  ¿Una caché le ahorrará dinero de verdad?
3.  ¿Qué va en la clave de caché?
4.  La caché: SQLite, TTL y una política de omisión
5.  ¿Qué nunca debe servirse desde una caché?
6.  ¿Cuándo deben expirar las respuestas en caché?
7.  ¿Y la caché semántica?
8.  ¿Qué implica una caché para la privacidad?
9.  ¿Cómo encaja la caché con otros controles de costos?
10.  Dónde encaja BroadNet Inference

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é](https://broadrouter.com/es/blog/cached-input-tokens-explained/) explica el lado del proveedor, y [estructura del prompt para la caché](https://broadrouter.com/es/blog/prompt-structure-for-caching/) muestra cómo organizar un prompt para que se reutilice el prefijo. La [calculadora de prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) 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](https://broadrouter.com/es/blog/llm-api-usage-logging/), 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:

```python
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:

```text
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](https://broadrouter.com/es/models/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](https://broadrouter.com/tools/llm-api-cost-calculator/). 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 de `messages` (con el prompt del sistema), `temperature`, `top_p`, `max_tokens`, `seed`, `response_format`, `tools`, `tool_choice` y `reasoning_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 `user` que 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

```python
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:

```python
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=1200`** deja 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é](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)). Esas respuestas no se guardan, porque `finish_reason` es `length`, no `stop`.
-   **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](https://broadrouter.com/es/glossary/tool-calling/) 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:

1.  **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.
2.  **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.
3.  **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](https://broadrouter.com/es/blog/evaluate-llm-before-switching/).

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](https://broadrouter.com/es/glossary/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](https://broadrouter.com/tools/embedding-cost-calculator/) 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](https://www.broadnet.ai/inference-privacy) 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](https://broadrouter.com/es/blog/llm-api-sensitive-data/) 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](https://broadrouter.com/es/blog/reduce-prompt-tokens/), 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](https://broadrouter.com/es/blog/llm-api-spend-control/). 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](https://broadrouter.com/es/blog/llm-batch-processing-without-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](https://broadrouter.com/es/guides/openai-python-sdk/) 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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-cache-llm-responses-cut-cost&utm_content=body). Los precios por modelo están en la [página de precios](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-cache-llm-responses-cut-cost&utm_content=body).

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Embeddings (vectores de texto)](https://broadrouter.com/es/glossary/embeddings/)

Los embeddings son listas de números de punto flotante (vectores) que un modelo produce para representar un texto, una imagen u otra entrada. Las entradas de significado parecido obtienen vectores cercanos, así que la distancia entre vectores sirve para ordenar resultados de búsqueda, agrupar documentos o encontrar elementos relacionados.

[Tokens de entrada en caché (cached input tokens)](https://broadrouter.com/es/glossary/cached-input-tokens/)

Los tokens de entrada en caché son tokens del prompt que un proveedor de LLM procesó recientemente y puede reutilizar desde un caché en lugar de calcularlos de nuevo; normalmente son un prefijo repetido, como un prompt de sistema o un documento. Los proveedores los cobran a una tarifa menor que los tokens de entrada nuevos.

[Tokens de entrada y de salida (input and output tokens)](https://broadrouter.com/es/glossary/input-and-output-tokens/)

Los tokens de entrada son los que un modelo de lenguaje lee en una solicitud, incluidos el prompt de sistema, el historial de la conversación, las definiciones de herramientas y las imágenes. Los tokens de salida son los que genera en la respuesta, incluido el razonamiento. Las APIs de LLM suelen cobrarlos por separado, y la salida suele costar más.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Base de datos vectorial (vector database)](https://broadrouter.com/es/glossary/vector-database/)

Una base de datos vectorial es un almacén de datos que guarda vectores de embeddings, a menudo con su texto de origen y metadatos, y responde consultas de vecinos más cercanos: dado un vector de consulta, devuelve los vectores guardados más parecidos, normalmente por distancia coseno, distancia euclidiana o producto interno.

[Streaming (respuestas en tiempo real)](https://broadrouter.com/es/glossary/streaming/)

El streaming es una forma de devolver la respuesta de un modelo de lenguaje en pequeños fragmentos mientras aún se genera, en lugar de una sola respuesta al final. Las APIs compatibles con OpenAI hacen streaming mediante server-sent events cuando la solicitud define stream como true.

[Temperatura (temperature)](https://broadrouter.com/es/glossary/temperature/)

La temperatura es un parámetro de muestreo que controla qué tan aleatoria es la salida de un modelo de lenguaje. El modelo divide las puntuaciones de los tokens entre la temperatura antes de convertirlas en probabilidades: los valores bajos hacen dominar al token más probable y los altos aplanan la distribución, de modo que los menos probables salen más seguido.

## Preguntas frecuentes

### ¿Qué diferencia hay entre prompt caching y caché de respuestas?

El prompt caching lo hace el proveedor: un prefijo de prompt repetido se factura a un precio menor de entrada en caché, y el modelo sigue escribiendo una respuesta nueva. La caché de respuestas la hace usted: guarda la respuesta completa y la devuelve ante una solicitud idéntica sin llamar al modelo.

### ¿Debo cachear respuestas de LLM con temperature 0?

Sí, si la solicitud no tiene efectos secundarios y la misma respuesta sirve para todos los que la envían. Temperature 0 tampoco garantiza una salida idéntica del motor de inferencia, así que la caché además hace que la respuesta sea consistente. No cachee cuando temperature sea mayor que 0 o no se indique.

### ¿Cuánto ahorra cachear respuestas de LLM?

La proporción de solicitudes que son repeticiones exactas dentro de su ventana de expiración, multiplicada por el costo de esas solicitudes. Cuente los hashes de solicitud repetidos en sus propios logs para obtener esa proporción. Puede ser casi cero en chats abiertos y alta en entradas fijas de preguntas frecuentes o de clasificación.

### ¿Es mejor la caché semántica que la caché de coincidencia exacta?

Acierta más a menudo, porque las preguntas parecidas coinciden, pero puede devolver la respuesta a otra pregunta. También necesita un modelo de embeddings y un almacén vectorial. Empiece con una caché exacta y añada una capa semántica solo donde un acierto equivocado salga barato.

### ¿Puedo cachear respuestas en streaming?

No con el envoltorio sencillo de este artículo. Tendría que recoger el stream completo, comprobar que terminó con normalidad, guardarlo y reproducirlo después como stream. La mayoría de los equipos cachean solo llamadas sin streaming, como clasificación, extracción y respuestas de preguntas frecuentes.

## Siga leyendo

-   [Tokens de entrada en caché: cómo reducir la factura de una API de LLM](https://broadrouter.com/es/blog/cached-input-tokens-explained/)
-   [Cómo estructurar los prompts para que el prefijo quede en caché](https://broadrouter.com/es/blog/prompt-structure-for-caching/)
-   [Control de gasto en APIs de LLM: presupuestos, límites y bucles](https://broadrouter.com/es/blog/llm-api-spend-control/)
-   [Reducir tokens del prompt: recortes medidos en sistema, tools y datos](https://broadrouter.com/es/blog/reduce-prompt-tokens/)
-   [Registro de uso de API de LLM: costo por usuario y función, sin PII](https://broadrouter.com/es/blog/llm-api-usage-logging/)
-   [Procesamiento por lotes con LLM sin Batch API: un runner reanudable](https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Integre la revisión humana en su flujo de IA documental](https://broadrouter.com/es/blog/document-review-queues/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference: el razonamiento cuenta para max\_tokens, campos de uso para razonamiento y tokens en caché, límites de pago por uso (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Declaración de privacidad de inferencia de BroadNet: no se conservan prompts, mensajes, respuestas ni transcripciones; se conservan registros de tráfico y uso sin contenido (consultado el 2026-11-15)](https://www.broadnet.ai/es/inference-privacy)
-   [GPTCache en GitHub: caché semántica con embeddings y un evaluador de similitud, falsos positivos y falsos negativos, modo de coincidencia por palabras clave sin embeddings (consultado el 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [Documentación de vLLM, Reproducibility: "vLLM does not guarantee the reproducibility of the results by default" (Traducción: «vLLM no garantiza por defecto la reproducibilidad de los resultados») (consultado el 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Documentación de Python, módulo json: sort\_keys, separators y ensure\_ascii en json.dumps (consultado el 2026-11-15)](https://docs.python.org/3/library/json.html)
