---
title: "Estructura del prompt para la caché: un prefijo estable"
description: "Cómo organizar prompts de LLM para que el prefijo en caché no cambie: prompt del sistema, esquemas de tools, documentos, historial solo de adición y una prueba."
url: https://broadrouter.com/es/blog/prompt-structure-for-caching/
lang: es
updated: 2026-11-14
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/prompt-structure-for-caching/) (actualizado el 2026-11-16).

# Cómo estructurar los prompts para que el prefijo quede en caché

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado 2026-11-14 · Actualizado 2026-11-16

Ordene cada solicitud de lo más estable a lo menos estable: prompt del sistema, definiciones de herramientas, documentos de referencia, historial de la conversación y, al final, el mensaje nuevo. Haga que cada capa sea idéntica byte a byte entre llamadas: sin marcas de tiempo ni IDs arriba, herramientas ordenadas, JSON serializado de forma determinista e historial al que solo se agrega. Luego mida cached\_tokens para confirmar que el prefijo realmente se reutiliza.

## Puntos clave

-   Las cachés coinciden con un prefijo exacto. Un solo byte distinto invalida todo lo que sigue, así que el orden de las capas importa más que su tamaño.
-   Cuatro capas, la más estable primero: prompt del sistema, herramientas, documentos, historial. El nuevo turno del usuario va al final.
-   Serialice las herramientas y los documentos JSON con claves ordenadas y separadores fijos; el orden de los diccionarios rompe la caché sin avisar.
-   Restrinja las herramientas por llamada con tool\_choice en lugar de quitar definiciones de herramientas.
-   Pruébelo: envíe el mismo prefijo dos veces y compruebe que prompt\_tokens\_details.cached\_tokens sube en la segunda llamada.

**En esta página**

1.  ¿Por qué el orden del prompt decide la tasa de aciertos de caché?
2.  ¿Cuál es el orden correcto de las capas?
3.  ¿Qué rompe el prefijo sin que usted lo note?
4.  ¿Cómo construir en código una solicitud amigable con la caché?
5.  ¿Cómo demostrar que el prefijo está en caché?
6.  ¿Qué cambia con agentes y contexto largo?
7.  Dónde encaja BroadNet Inference

Los [tokens de entrada en caché](https://broadrouter.com/es/glossary/cached-input-tokens/) son baratos, y en BroadNet Inference DeepSeek V4.1 Flash los factura a $0.0055 por 1M en lugar de $0.175. La [explicación de los tokens en caché](https://broadrouter.com/es/blog/cached-input-tokens-explained/) cubre el precio y cómo leer el campo de uso. Este artículo trata del trabajo de diseño: cómo organizar un prompt para que la caché realmente acierte y cómo demostrarlo.

## ¿Por qué el orden del prompt decide la tasa de aciertos de caché?

Todos los grandes proveedores cachean por **prefijo**. La guía de OpenAI dice que la reutilización exige que coincida todo el prefijo renderizado. La documentación de DeepSeek describe la misma regla: una solicitud acierta solo si coincide por completo con un prefijo almacenado, y una que se desvía a mitad de camino no acierta. Anthropic construye su caché en el orden herramientas, sistema, mensajes.

Por dentro, el servidor reutiliza la [KV cache](https://broadrouter.com/es/glossary/kv-cache/) que construyó para ese prefijo. Así que la caché es una línea recta desde el primer token. El primer byte que difiere de la llamada anterior termina la parte reutilizable. Una marca de tiempo de una línea al principio de un prompt de 50,000 tokens le cuesta los 50,000 tokens a precio completo.

## ¿Cuál es el orden correcto de las capas?

| Capa | Cambia | Ejemplo | Regla |
| --- | --- | --- | --- |
| 1\. Prompt del sistema | Con cada despliegue | Rol, reglas, formato de salida | Sin fechas, IDs ni nombres de usuario |
| 2\. Definiciones de herramientas | Con cada despliegue | Esquemas de funciones | JSON ordenado y determinista |
| 3\. Material de referencia | Por sesión o tarea | Archivos del repositorio, contratos, documentación del producto | Orden fijo, etiquetas estables |
| 4\. Historial de la conversación | Por turno, solo se agrega | Turnos anteriores del usuario y del asistente | Nunca se edita; solo se agrega |
| 5\. Mensaje nuevo | En cada llamada | La pregunta, más la hora actual si hace falta | Aquí van los datos variables |

La capa 5 es el lugar de todo lo variable: la fecha actual, la configuración regional del usuario, un ID de solicitud, fragmentos recuperados que cambian según la pregunta.

## ¿Qué rompe el prefijo sin que usted lo note?

1.  **El orden de los diccionarios.** Los frameworks suelen construir el arreglo `tools` a partir de un dict o un registro. Si los plugins se cargan en otro orden, los bytes cambian.
2.  **El formato del JSON.** `json.dumps(x)` y `json.dumps(x, indent=2)` son prefijos distintos. También lo son dos serializadores con distinto orden de claves.
3.  **Espacios en las plantillas.** Un espacio al final de una línea, o un `\r\n` desde una ruta del código y `\n` desde otra.
4.  **Listas de herramientas dinámicas.** Quitar las herramientas que un usuario no puede usar cambia el prefijo. La guía de OpenAI recomienda mantener estables las definiciones y restringir el uso con `tool_choice` o con una configuración de herramientas permitidas.
5.  **Resumir el historial en el mismo lugar.** Reescribir turnos antiguos como un resumen reinicia todo lo que va después del prompt del sistema. Resuma pocas veces y en saltos grandes.
6.  **Recuperación antes de las instrucciones.** Los fragmentos de RAG colocados entre el prompt del sistema y las herramientas cambian con cada consulta y también rompen la capa de herramientas.

## ¿Cómo construir en código una solicitud amigable con la caché?

Haga que cada capa dependa solo de entradas estables y serialice de forma determinista:

```python
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = open("prompts/system.md").read()  # versioned file, no templating

def stable_tools(registry: dict) -> list:
    # Sort by name, sort keys inside each schema.
    return [json.loads(json.dumps(registry[name], sort_keys=True)) for name in sorted(registry)]

def docs_block(paths: list[str]) -> str:
    parts = [f"=== {p} ===\n{open(p).read()}" for p in sorted(paths)]
    return "\n\n".join(parts)

def build_messages(history: list, user_text: str, now_iso: str, doc_paths: list[str]):
    return (
        [{"role": "system", "content": SYSTEM},
         {"role": "user", "content": docs_block(doc_paths)}]
        + history                                   # append-only
        + [{"role": "user", "content": f"(now: {now_iso})\n{user_text}"}]
    )

resp = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",
    messages=build_messages(history, question, now_iso, files),
    tools=stable_tools(TOOLS),
)
history += [{"role": "user", "content": question}, resp.choices[0].message.model_dump(exclude_none=True)]
```

Dos detalles. La hora actual va en el último mensaje, no en el prompt del sistema. Y el historial guarda el mensaje del asistente exactamente como se devolvió, para que la siguiente llamada reenvíe bytes idénticos.

## ¿Cómo demostrar que el prefijo está en caché?

Ejecute una prueba de dos llamadas en CI o en un notebook:

1.  Construya una solicitud con su prompt del sistema, sus herramientas y sus documentos reales.
2.  Envíela. Anote `usage.prompt_tokens`.
3.  Cambie solo el mensaje final del usuario y envíela de nuevo.
4.  Lea `usage.prompt_tokens_details.cached_tokens` en la segunda llamada. Debería cubrir casi todo el prefijo compartido.
5.  Si es cero o pequeño, compare byte a byte los cuerpos serializados de las solicitudes. La primera diferencia es lo que rompe su caché.

En la mayoría de los proveedores, la caché funciona según disponibilidad, y la documentación de DeepSeek lo dice directamente, así que un fallo aislado no prueba un error. Un fallo constante, sí. Siga la proporción de tokens en caché frente a tokens del prompt por solicitud en sus [logs de uso](https://broadrouter.com/es/blog/llm-api-usage-logging/) y use la [calculadora de prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) para ver cuánto ahorra una tasa de aciertos más alta.

## ¿Qué cambia con agentes y contexto largo?

Los agentes son los más beneficiados, porque reenvían el mismo prefijo grande decenas de veces por tarea. Hay dos hábitos que importan:

-   **Una conversación por tarea.** Empezar una conversación nueva en cada subpaso descarta el prefijo.
-   **Lea los archivos una vez, cerca del principio.** Si el agente vuelve a leer un archivo, agregue la copia nueva en lugar de reemplazar la anterior, salvo que el archivo haya cambiado.

Con una [ventana de contexto de 1M de tokens](https://broadrouter.com/es/blog/million-token-context-window-guide/), la capa 3 puede contener un repositorio entero. Eso solo resulta asequible con una clave de pago por token cuando queda en caché, y por eso el orden de las capas importa más a medida que crecen los prompts. Los prefijos en caché también suelen reducir el tiempo hasta el primer token; consulte [TTFT vs. throughput](https://broadrouter.com/es/blog/llm-latency-ttft-throughput/).

## Dónde encaja BroadNet Inference

En BroadNet Inference, el bloque usage reporta `prompt_tokens_details.cached_tokens` cuando el modelo lo informa, y la entrada en caché de [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) y [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) se factura a la tarifa más baja indicada en la [página de precios](https://broadrouter.com/es/pricing/). La documentación de BroadNet no ofrece puntos de corte de caché explícitos ni un parámetro de clave de caché, así que la organización de arriba es toda la técnica. En un plan ilimitado, la caché no cambia la factura, porque las sesiones no tienen medidor de tokens, pero la misma estructura sigue ayudando a la latencia.

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.

[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.

[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.

[Throughput (rendimiento total)](https://broadrouter.com/es/glossary/throughput/)

El throughput, en el servicio de LLMs, es la cantidad total de trabajo que un sistema completa por unidad de tiempo en todas las solicitudes concurrentes, normalmente medida en tokens de salida por segundo o solicitudes por segundo. Es distinto de la velocidad por stream, que es qué tan rápido recibe sus tokens una sola solicitud.

[Tiempo hasta el primer token (TTFT)](https://broadrouter.com/es/glossary/time-to-first-token/)

El tiempo hasta el primer token (TTFT) es lo que pasa desde que se envía una solicitud a un modelo de lenguaje hasta que llega el primer token de salida. Incluye la red, la cola del servidor y el prefill, cuando el modelo lee todo el prompt, así que crece con el largo del prompt y la carga.

[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.

[Caché KV (KV cache)](https://broadrouter.com/es/glossary/kv-cache/)

La caché KV es la memoria donde un modelo de lenguaje transformer guarda las claves y valores de atención calculados para cada token ya procesado, de modo que cada token nuevo los reutiliza en lugar de recalcular toda la secuencia. Crece con la longitud del contexto y a menudo limita cuántas solicitudes puede atender una GPU.

[Latencia (latency)](https://broadrouter.com/es/glossary/latency/)

La latencia, en una API de modelos de lenguaje, es el tiempo que tarda una solicitud desde que se envía hasta que se recibe el último token de salida. Es la suma del tiempo hasta el primer token y el tiempo de generación, y suele reportarse en percentiles como p50 y p95, no como promedio.

## Preguntas frecuentes

### ¿Por qué es baja la tasa de aciertos de mi prompt caching?

Algo cerca del inicio del prompt cambia en cada llamada. Las causas habituales son una marca de tiempo o un ID de solicitud en el prompt del sistema, herramientas serializadas en otro orden, documentos recuperados colocados antes de las instrucciones o un historial que se resume y se reescribe.

### ¿La pregunta del usuario va antes o después de los documentos largos?

Después. Ponga primero los documentos y al final la pregunta. Así los documentos forman un prefijo reutilizable, y muchos modelos además responden mejor cuando la pregunta va después del material.

### ¿Las definiciones de herramientas rompen el prompt caching?

Solo si cambian. Las herramientas forman parte del prefijo, así que mantenga el mismo conjunto, en el mismo orden y con el mismo JSON. Para limitar las herramientas en una llamada, use tool\_choice en lugar de editar la lista.

### ¿Importa el orden de los ejemplos few-shot para la caché?

Sí. Los ejemplos mezclados producen un prefijo distinto cada vez. Fije el orden o coloque los ejemplos que cambian en cada solicitud después de la parte estable.

## 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/)
-   [Ventana de contexto de 1M de tokens: cuándo compensa y cuándo no](https://broadrouter.com/es/blog/million-token-context-window-guide/)
-   [API de LLM con tarifa plana o pago por token: el punto de equilibrio](https://broadrouter.com/es/blog/flat-rate-vs-pay-per-token-llm-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/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Streaming de chat completions y conexiones interrumpidas](https://broadrouter.com/es/guides/streaming-chat-completions/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)

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-prompt-structure-for-caching&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference, tokens en caché en usage (consultada el 2026-11-16) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-prompt-structure-for-caching&utm_content=sources)
-   [Guía de prompt caching de OpenAI, coincidencia de prefijos y consejos de estructura (consultado el 2026-11-14)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Documentación de prompt caching de Anthropic, orden de la caché herramientas, sistema y mensajes (consultada el 2026-11-16)](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
-   [Documentación de la API de DeepSeek, caché de contexto (consultado el 2026-11-14)](https://api-docs.deepseek.com/guides/kv_cache)
