Caché KV vs caché de prompts: diferencias clave
La caché KV consume RAM o VRAM por solicitud y puede impedir cargar el modelo. La caché de prompts sólo reduce coste y latencia si coincide el prefijo.
Caché KV frente a caché de prompts: respuesta breve
La caché KV de un proveedor y la caché de prompts comparten una palabra, pero casi nada más. La caché KV es memoria de trabajo por solicitud. Se mantiene en la RAM o la VRAM de su servidor durante toda la vida de una solicitud y crece con la longitud del contexto y con el número de solicitudes simultáneas. La caché de prompts del proveedor es una función de facturación y latencia. El proveedor almacena un prefijo estable de su prompt en sus servidores y cobra una tarifa reducida cuando vuelve a enviarlo.
Una es memoria que compra como hardware. La otra es memoria que mantiene otra entidad y por la que le cobra un alquiler.
La diferencia práctica es más importante que la definición. Puede quedarse sin caché KV. Cuando ocurre, el modelo no se carga o se rechaza la solicitud. No puede quedarse sin caché de prompts. Sólo puede no obtener una coincidencia con ella y, en ese caso, paga silenciosamente el precio completo.
Qué contiene la caché KV y por qué existe
Un transformer que genera el token número 500 debe atender a los 499 tokens anteriores. Para cada uno de esos tokens, cada capa necesita un vector de clave y un vector de valor. Recalcularlos todos para cada token nuevo haría que la generación creciera con el cuadrado de la longitud, por lo que el runtime los conserva. Ese almacenamiento es la caché KV (caché de clave/valor).
Es un estado por solicitud porque se construye a partir de la secuencia exacta de tokens de esa solicitud. Dos usuarios que envíen prompts diferentes no pueden compartirla, salvo que el runtime use el almacenamiento en caché de prefijos, una función independiente que se describe más adelante.
El servicio se ejecuta en dos fases. Prefill lee el prompt completo y llena la caché, y está limitado por la capacidad de cómputo. Decode produce un token cada vez y lo añade a la caché, y está limitado por el ancho de banda de memoria. Por eso el procesamiento del prompt y la generación de tokens muestran velocidades diferentes cuando mide tokens por segundo en tu propio equipo.
¿Cuánta memoria usa la caché KV?
No busque una tabla del proveedor. El tamaño se calcula mediante una operación que puede repetir para cualquier modelo:
bytes per token = 2 * layers * kv_heads * head_dim * bytes per elementEl 2 corresponde a la clave y al valor. Todos los demás números proceden de la config.json del modelo, publicada en su página de Hugging Face.
Tomemos Llama 3.1 8B. Su configuración indica num_hidden_layers 32 y num_key_value_heads 8. La hidden_size de 4096, distribuida entre 32 cabezas de atención, da una dimensión de cabeza de 128. En f16, cada elemento ocupa 2 bytes:
2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per tokenMultiplique este valor por el contexto solicitado y después por el número de solicitudes que ejecuta simultáneamente.
Los datos de este gráfico
[
{
"label": "2k context",
"one_request_gib": 0.25,
"four_requests_gib": 1
},
{
"label": "8k context",
"one_request_gib": 1,
"four_requests_gib": 4
},
{
"label": "32k context",
"one_request_gib": 4,
"four_requests_gib": 16
},
{
"label": "128k context",
"one_request_gib": 16,
"four_requests_gib": 64
}
]Con un contexto de 8k, la caché ocupa 1 GiB para una solicitud. Con 32k ocupa 4 GiB, un valor del mismo orden que los propios pesos de 4 bits. Con el contexto máximo de 128k del modelo, ocupa 16 GiB para una solicitud y 64 GiB si cuatro solicitudes lo llenan por completo. Los pesos no cambiaron. Sólo cambió la caché.
La atención de consultas agrupadas (GQA) influye mucho en ese valor. Llama 3.1 8B tiene 8 cabezas de clave/valor que atienden a 32 cabezas de consulta, por lo que cuatro cabezas de consulta comparten un par de clave/valor almacenado. Un modelo cuyo num_key_value_heads es igual a su num_attention_heads usa cuatro veces más caché con el mismo número de parámetros. Compruebe ese campo antes de asumir que servir dos modelos 8B tiene el mismo coste.
Por qué un modelo que se ejecutaba con 2k se niega a cargarse con 32k
El runtime reserva la caché KV cuando carga el modelo. El tamaño se basa en la longitud de contexto configurada, no en el prompt que realmente se envía. El valor predeterminado de Ollama ya no es un número único. Desde octubre de 2026, su documentación de longitud de contexto lo establece según la VRAM: 4k en máquinas con menos de 24 GiB, 32k entre 24 y 48 GiB, y 256k con 48 GiB o más. En los modelos en la nube, el valor predeterminado es su máximo. Una VPS sólo con CPU o una GPU pequeña comienza con 4k. Si lo aumenta a 32k, está solicitando 4 GiB de asignación adicional antes de que llegue un solo token. En una tarjeta de 24 GiB, 32k ya es el valor predeterminado. Por tanto, esa reserva se hace tanto si la solicita como si no.
OLLAMA_CONTEXT_LENGTH=32768 ollama serveEl mismo ajuste por sesión, desde el prompt interactivo:
ollama run llama3.1:8b
/set parameter num_ctx 32768El fallo tiene un aspecto diferente en cada stack. vLLM comprueba los cálculos durante el inicio y se niega a ejecutarse:
ValueError: To serve at least one request with the model's max seq len (131072), (16.0 GiB KV cache is needed, which is larger than the available KV cache memory (9.56 GiB). Based on the available memory, the estimated maximum model length is 78336. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.En una VPS sólo con CPU que ejecuta Ollama o llama.cpp, la asignación usa la RAM normal del sistema y es posible que la falta de memoria no se detecte durante el inicio. En su lugar, el kernel termina el proceso mediante el asesino de procesos por falta de memoria. La evidencia queda en el búfer circular del kernel:
dmesg -T | grep -i "killed process"Una línea que menciona el proceso que presta el servicio significa que el sistema prometió más memoria de la disponible. La solución es usar un contexto más pequeño, no un archivo de swap más grande. Una caché KV paginada en disco se lee con cada token generado, por lo que la generación se ralentiza hasta resultar inútil. La elección de un valor razonable se explica en nuestra guía sobre num_ctx y la longitud de contexto en Ollama.
Qué efecto tiene la concurrencia en la cifra
Cada solicitud en curso lleva su propia caché KV. Este es el aspecto que más se omite en los planes de capacidad. Cuatro usuarios, cada uno con 32k de contexto, necesitan 16 GiB entre todos, además de los pesos.
Los runtimes difieren en lo estrictos que son con este aspecto. Ollama y llama.cpp reservan el contexto solicitado al cargar el modelo, por lo que la memoria queda comprometida aunque nadie la utilice. vLLM divide el pool en bloques de tamaño fijo y los asigna a medida que crece cada solicitud, por lo que una solicitud de 500 tokens ocupa sólo el espacio correspondiente a 500 tokens. En ambos casos, el pool es finito. Cuando se llena, las solicitudes nuevas quedan en cola en lugar de ejecutarse. El efecto de esa espera en los tiempos de respuesta se explica en cuántos usuarios simultáneos puede atender un LLM autoalojado.
Cuatro formas de reducir el tamaño de la caché KV
- Reduzca la longitud del contexto. Es el factor con mayor impacto y normalmente el más económico. La mayoría de las cargas de trabajo de chat no se acercan nunca a 32k.
- Cuantice la propia caché. El valor predeterminado de
OLLAMA_KV_CACHE_TYPEen Ollama esf16y aceptaq8_0, que usa aproximadamente la mitad de memoria, yq4_0, que usa aproximadamente una cuarta parte. Los equivalentes en llama.cpp son-ctk q8_0y-ctv q8_0. - Elija un modelo con menos cabezas key/value o menos capas. Consulte
config.jsonantes de descargar 40 GB de pesos. - Atienda menos solicitudes a la vez y ponga el resto en cola.
En q4_0, la cifra de Llama 3.1 8B baja de 128 KiB por token a aproximadamente 32 KiB, por lo que un contexto de 32k cuesta cerca de 1 GiB en lugar de 4 GiB. Este ahorro tiene un coste. Las claves y los valores se almacenan con menor precisión, así que compare la salida con sus propios prompts antes de mantener esta configuración.
Qué ofrece realmente la caché de prompts del proveedor
La caché de prompts del proveedor es un producto diferente, con una unidad de facturación distinta. Se marca un prefijo estable, el proveedor lo almacena y las llamadas posteriores que repiten exactamente ese prefijo se facturan a una tarifa reducida en lugar del precio completo de entrada.
Los multiplicadores publicados por Anthropic, a octubre de 2026, son los siguientes: escribir en una caché de 5 minutos cuesta 1.25 veces el precio base de los tokens de entrada. Escribir en una caché de 1 hora cuesta 2 veces ese precio, y leer de la caché cuesta 0.1 veces en la mayoría de los modelos. Los modelos más recientes tienen un coste de lectura aún menor: 0.05 veces en Claude Opus 5.5 y Sonnet 5.5, y 0.025 veces en Claude Fable 5.1 y Mythos 5.1. Si se coloca un prompt de sistema de 20,000 tokens detrás de los valores estándar, la diferencia resulta evidente.
Los datos de este gráfico
[
{
"label": "No caching, every call",
"billed_token_equivalents": "20,000"
},
{
"label": "First call, 5 minute cache write",
"billed_token_equivalents": "25,000"
},
{
"label": "First call, 1 hour cache write",
"billed_token_equivalents": "40,000"
},
{
"label": "Every later call, cache hit",
"billed_token_equivalents": "2,000"
}
]Considérelo como una operación aritmética. La prima de escritura de 5 minutos equivale a 5,000 tokens en la primera llamada: 25,000, frente a 20,000 por enviarlo sin caché. Cada llamada posterior dentro de la ventana factura 2,000 en lugar de 20,000, lo que supone un ahorro de 18,000. Por tanto, la caché de 5 minutos resulta rentable a partir de la segunda llamada.
La caché de 1 hora implica una decisión diferente. La escritura factura 40,000, una prima de 20,000 tokens equivalentes, por lo que necesita dos aciertos dentro de esa hora para resultar rentable. Esto depende del patrón de tráfico, no del modelo. El cálculo completo, incluido cómo elegir la ventana, se encuentra en el cálculo del punto de equilibrio de la caché de prompts de Claude.
Dos detalles determinan si se utiliza la caché. Primero, un prefijo que no alcance la longitud mínima del modelo no se almacena en caché de forma silenciosa: a octubre de 2026, el mínimo documentado es de 512 tokens para Claude Opus 5, Opus 5.5 y Sonnet 5.5, y de 1,024 tokens para Claude Sonnet 5. Una solicitud más corta se procesa normalmente y no devuelve ningún error. Segundo, la duración se mide desde el inicio de la solicitud que escribe o lee la entrada, y cada lectura la renueva sin coste adicional. Por tanto, un endpoint con mucha actividad puede mantener una caché de 5 minutos activa indefinidamente. Un endpoint al que se llama una vez cada diez minutos paga la prima de escritura en cada ocasión y nunca obtiene un ahorro.
Compruebe la respuesta en lugar de darlo por supuesto. El objeto usage informa de cache_creation_input_tokens y cache_read_input_tokens. Un recuento de lecturas igual a cero en todas las llamadas significa que está pagando escrituras sin recuperar ningún beneficio.
Cuando se encuentran las dos cachés
Un prompt de sistema largo es el punto de encuentro y se cobra en ambos lados al mismo tiempo.
En local, un prompt de sistema de 20,000 tokens ocupa aproximadamente 2.4 GiB de caché KV en un servidor Llama 3.1 8B con f16. Además, ocupa ese espacio por separado para cada solicitud simultánea que lo incluya. En remoto, ese mismo prefijo requiere una escritura de caché inicial y después cuesta 0.1 veces la entrada en cada llamada posterior, o menos en los modelos más recientes. El coste local aumenta con el número de usuarios. El coste remoto aumenta con el tráfico y se restablece durante los periodos de inactividad.
Existe una función local que se parece al almacenamiento en caché de prompts del proveedor y que se confunde constantemente con él: el almacenamiento en caché de prefijos. La documentación de vLLM describe el almacenamiento automático en caché de prefijos como el almacenamiento en caché de «la caché KV de las consultas existentes, para que una consulta nueva pueda reutilizarla directamente si comparte el mismo prefijo con una de las consultas existentes». Las versiones actuales de vLLM lo activan de forma predeterminada. El servidor llama.cpp mantiene una caché de prompt por slot de forma predeterminada, y --cache-reuse N establece el tamaño mínimo del bloque que intentará reutilizar.
El almacenamiento en caché de prefijos ahorra trabajo de prefill. El prompt de sistema de 20,000 tokens se procesa una vez en lugar de hacerlo en cada solicitud, lo que reduce considerablemente el tiempo hasta el primer token. En vLLM, los bloques compartidos se reutilizan en lugar de duplicarse, por lo que el uso de memoria también mejora. Lo que nunca hace es reducir la caché que debe mantenerse para los tokens activos en ese momento. Mantener los pesos residentes entre solicitudes es un mecanismo relacionado, pero independiente, que se explica en mantener un modelo de Ollama cargado entre solicitudes.
Qué medir en tu propio equipo
Carga el modelo con el contexto objetivo y lee los valores reales en lugar de confiar en la estimación.
ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -gollama ps muestra el modelo cargado, su tamaño, el contexto con el que se cargó y si se ejecuta en la GPU o en la CPU. Comprueba primero la columna del contexto, porque el valor predeterminado ahora depende de la VRAM disponible. Si un modelo que esperabas mantener completamente en la GPU muestra una parte asignada a la CPU, significa que la caché KV expulsó parte del modelo y la velocidad de generación disminuirá en consecuencia. nvidia-smi muestra la cantidad real de VRAM y free -g cumple la misma función en un VPS que sólo usa la CPU. Aumenta el contexto por pasos, vuelve a cargar el modelo y observa cómo cambia el valor. El cálculo y el valor mostrado deberían ser muy parecidos. Cuando no lo son, la diferencia suele deberse a los búferes de cálculo propios del runtime y no a un error en la fórmula.
Si esos valores te llevan a elegir un hardware que preferirías no alquilar, la comparación con pagar por token se desarrolla en GPU VPS frente a tokens de API.
FAQ
¿La caché KV es lo mismo que la caché de prompts?
No. La caché KV es memoria por solicitud dentro del proceso que sirve el modelo y contiene los vectores key y value de cada token del contexto actual. Se almacena en la RAM o la VRAM y se libera cuando termina la solicitud. La caché de prompts del proveedor es una función de facturación que almacena un prefijo estable del prompt en la infraestructura del proveedor y aplica una tarifa reducida cuando se vuelve a enviar. Agotar la caché KV impide cargar un modelo. No disponer de la caché de prompts sólo aumenta la factura y el tiempo hasta el primer token.
¿Por qué mi modelo se carga con un contexto de 2k, pero falla con 32k?
Porque el runtime asigna toda la caché KV durante la carga. La dimensiona según la longitud de contexto configurada, no según el prompt que se envía. En Llama 3.1 8B con f16, la caché ocupa 128 KiB por token. Por tanto, 2k de contexto consumen 0.25 GiB y 32k consumen 4 GiB. Los pesos caben en ambos casos. Lo que falla es la reserva. vLLM lo informa mediante ValueError, que indica cuánta memoria necesita para la caché KV frente a la disponible, junto con una longitud máxima estimada del modelo. También sugiere aumentar gpu_memory_utilization o reducir max_model_len. En un sistema sólo con CPU que ejecute Ollama o llama.cpp, el kernel puede terminar el proceso mediante el mecanismo de falta de memoria. Puede confirmarlo con dmesg -T | grep -i "killed process".
¿Cómo calculo el tamaño de la caché KV de mi modelo?
Multiplique 2 por el número de capas, el número de cabezas key/value, la dimensión de cada cabeza y los bytes por elemento. El resultado son los bytes por token. Después, multiplique ese valor por la longitud de contexto y por el número de solicitudes simultáneas. Consulte el número de capas y de cabezas en el config.json del modelo. Use 2 bytes por elemento para f16 o bf16. Una caché q8_0 ocupa aproximadamente la mitad, y una q4_0 aproximadamente una cuarta parte.
¿La caché de prompts reduce la memoria que necesita mi propio servidor?
La caché de prompts del proveedor no afecta al hardware propio, porque el almacenamiento está en el lado del proveedor. El equivalente local es la caché de prefijos, que ofrecen tanto vLLM como el servidor de llama.cpp. Reutiliza los vectores key y value ya calculados para un prefijo compartido. Esto ahorra cómputo de prefill y reduce el tiempo hasta el primer token. En vLLM, los bloques compartidos se reutilizan en lugar de duplicarse, por lo que también mejora el uso de memoria. Ninguna de las dos funciones reduce la caché necesaria para los tokens que están actualmente en proceso. Por tanto, el contexto y la concurrencia siguen determinando el mínimo de memoria.
¿Merece la pena almacenar en caché un prompt que sólo envío una vez?
No. Escribir en la caché cuesta más que enviar una entrada normal: 1.25 veces la tarifa base para la opción de 5 minutos en octubre de 2026. Por tanto, un prefijo que no vuelva a enviar durante ese intervalo supone una pérdida directa. La caché resulta útil cuando se repite el mismo prefijo, por ejemplo, un prompt de sistema largo o un documento sobre el que se harán varias preguntas. Compruebe cache_read_input_tokens en la respuesta de la API para confirmar que se están produciendo aciertos de caché en lugar de pagar por escrituras.