Cómo mantener un modelo de Ollama en memoria
Ollama descarga el modelo tras 5 minutos sin uso. Configura OLLAMA_KEEP_ALIVE en un override de systemd y precárgalo después de reiniciar.
¿Por qué Ollama descarga el modelo después de unos minutos?
Ollama mantiene un modelo cargado en memoria durante cinco minutos después de la última solicitud y, a continuación, libera esa memoria. La siguiente solicitud debe volver a cargar los pesos en la RAM o la VRAM, por lo que se produce una pausa antes de que llegue el primer token. Por eso una interfaz de chat o un agente de programación parece rápido, permanece inactivo durante un tiempo y vuelve a parecer lento con el siguiente mensaje. No hay ningún problema. El temporizador de inactividad ha expirado.
El temporizador se denomina keep_alive. Se aplica a cada modelo y se reinicia cada vez que finaliza una solicitud. Un modelo que está respondiendo a una solicitud nunca se descarga, porque el servidor sólo expira un modelo sin solicitudes activas. En octubre de 2026, el valor predeterminado es de cinco minutos y se aplica a todos los modelos que carga este servidor.
Hay dos lugares donde se puede configurar el tiempo de espera de inactividad: el campo keep_alive de la solicitud individual o OLLAMA_KEEP_ALIVE como valor predeterminado del servidor. Un drop-in de systemd hace que el valor predeterminado del servidor se conserve después de un reinicio. En esta guía se presupone que Ollama ya se está ejecutando como servicio. Si no es así, empiece por instalar Ollama en un VPS y vuelva después.
¿Qué modelos están cargados ahora y cuándo caducan?
ollama psNAME ID SIZE PROCESSOR CONTEXT UNTIL
qwen3:8b 500a1f067a9f 6.6 GB 100% GPU 4096 4 minutes from nowUna salida vacía significa que no hay ningún modelo cargado, por lo que la siguiente solicitud debe cargarlo primero. PROCESSOR indica dónde se cargaron los pesos. 100% GPU y 100% CPU son los casos claros. Una división como 25%/75% CPU/GPU significa que sólo parte del modelo está en la VRAM, por lo que el resto se ejecuta en el procesador y la generación es más lenta. Normalmente esto ocurre porque el modelo no cabe, pero una configuración num_gpu que limita cuántas capas se envían a la GPU produce el mismo tipo de división.
UNTIL es la cuenta atrás y muestra un tiempo relativo como 4 minutes from now. Muestra Forever cuando el modelo se cargó con un valor negativo para keep_alive. Muestra Stopping... después de la caducidad, incluso mientras las solicitudes activas retrasan la descarga.
El conjunto de columnas ha cambiado entre versiones, por lo que debe leer la cabecera en lugar de contar los campos en un script. Ollama v0.40.5, comprobado el 2026-10-30, también muestra una columna RUNNER entre CONTEXT y UNTIL. Esta columna indica el runner que sirve el modelo, por lo que la cabecera puede tener una columna más que la del ejemplo anterior. Para cualquier tarea automatizada, consulte la API:
curl -s http://localhost:11434/api/psCada entrada incluye expires_at, una marca de tiempo absoluta como 2026-08-09T14:38:31.83753Z, y size_vram, la parte de ese modelo que está en la memoria de la GPU. Un size_vram de 0 significa que el modelo se ejecuta en la CPU.
Qué coste tiene realmente la recarga
No lo suponga. Ollama informa del tiempo de carga en cada respuesta mediante load_duration, expresado en nanosegundos.
sudo apt install -y jq
ollama stop qwen3:8b
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'Espere hasta que ollama ps deje de mostrar el modelo después de ollama stop antes de ejecutar las dos llamadas a la API. La primera llamada carga el modelo, por lo que su valor de load_duration es alto. Divídalo entre 1000000000 para leerlo en segundos. La segunda llamada se ejecuta mientras el modelo permanece en memoria y muestra un valor mucho menor. La diferencia entre esas dos cifras es el coste que asume cada usuario cuando expira el temporizador. Esta es la razón completa para cambiar keep_alive. Después de descargar el modelo, la caché de páginas del kernel suele conservar el archivo del modelo. Por eso, en un equipo con RAM disponible, una recarga puede ser más rápida que la primera carga después del arranque. Cuando esa caché se recupera, los pesos se leen del disco. Si ha movido el directorio del modelo a un segundo volumen, la velocidad de ese volumen determina el tiempo mínimo de cada carga en frío. Para conocer la velocidad de generación antes y después de esa pausa, consulte cómo medir los tokens por segundo en su propio equipo.
Mantener un modelo de Ollama cargado en memoria durante una solicitud
Envíe keep_alive con la solicitud. Se aplica a ese modelo desde el momento en que finaliza la solicitud.
curl -s http://localhost:11434/api/chat -d '{
"model": "qwen3:8b",
"messages": [{"role": "user", "content": "hello"}],
"keep_alive": "30m"
}'Se aceptan cuatro formatos de valor:
- una cadena de duración:
"30m","24h","90s" - un número simple, interpretado como segundos:
3600 - un valor negativo,
-1o"-1m", que significa que no hay tiempo de espera por inactividad 0, que significa descargar el modelo cuando no tenga solicitudes activas
Un valor incluido en la solicitud reemplaza el valor predeterminado del servidor en ambos sentidos. Esto es importante: un cliente que envía su propio keep_alive tiene prioridad sobre cualquier valor configurado en el servidor.
También puede cargar un modelo sin generar nada. Envíe sólo el nombre del modelo. El servidor lo carga y devuelve una respuesta vacía con "done": true.
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'Este es el comando que debe ejecutar después de reiniciar el sistema o de descargar un modelo nuevo. Así, la primera solicitud real de un usuario no espera a que se cargue el modelo. La CLI hace lo mismo con una opción:
ollama run --keepalive 30m qwen3:8b "hello"Manténgalo cargado de forma predeterminada con OLLAMA_KEEP_ALIVE
El servidor lee OLLAMA_KEEP_ALIVE al iniciarse y lo usa para todos los modelos que no tengan un valor propio. Admite los mismos formatos que el campo de la solicitud, por lo que funcionan 30m, 3600 y -1.
El punto importante es en qué entorno debe definirse. Ejecutar export OLLAMA_KEEP_ALIVE=30m en la sesión SSH no tiene ningún efecto, porque la instalación empaquetada ejecuta el servidor como un servicio de systemd, con su propio usuario y su propio entorno. El shell de inicio de sesión y ese servicio no comparten el entorno. Esta es la causa más habitual de que el ajuste parezca ignorarse.
Haz que persista tras un reinicio con un drop-in de systemd
sudo systemctl edit ollama.serviceEl editor se abre con dos marcadores de comentario. Escriba entre ellos: systemd descarta todo lo que escriba debajo del segundo marcador.
[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"Al guardar se escribe /etc/systemd/system/ollama.service.d/override.conf. Es un drop-in, no una modificación de la unidad distribuida con el paquete, por lo que una actualización del paquete de Ollama que sustituya ollama.service no modificará este ajuste. Si los drop-ins y los archivos de unidad son conceptos nuevos para usted, la guía de servicios y temporizadores de systemd explica su funcionamiento.
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=EnvironmentEl último comando muestra el entorno real con el que se ejecutará el servicio. Si OLLAMA_KEEP_ALIVE=30m no aparece en esa línea, el drop-in no se aplicó. La causa casi siempre es la falta de la cabecera [Service] o que se hayan escrito líneas debajo del marcador. El reinicio descarga todos los modelos cargados, por lo que la siguiente petición tendrá que cargarlos en frío. Precargue el modelo con la llamada de precarga anterior. El drop-in conserva el ajuste después de un reinicio del sistema, pero no el modelo: el servicio se inicia ollama serve sin ningún modelo cargado, por lo que debe ejecutar la misma llamada de precarga después de cada arranque.
El coste de mantener un modelo residente
La columna SIZE en ollama ps representa la memoria ocupada durante toda la ventana de inactividad, no solo durante una petición. Un modelo de 8B con cuantización de 4 bits ocupa entre 5 y 6 GB. Un modelo de 27B es otro asunto, y el cálculo de memoria para ejecutar uno en un VPS solo con CPU debe realizarse antes de decidir mantenerlo residente. Si establece keep_alive en -1, desactiva la expiración por inactividad; las peticiones posteriores para el mismo modelo pueden reemplazar su tiempo de espera o forzar una recarga cuando cambian las opciones del ejecutor. En un VPS pequeño, esto supone un intercambio directo con su base de datos, su aplicación web y sus tareas de compilación.
Observe los números reales en lugar de confiar en una estimación. Ejecute esto mientras un modelo está cargado y, de nuevo, después de ollama stop:
free -hLa columna available es la memoria que el kernel aún podría asignar a un nuevo proceso. En un servidor con GPU NVIDIA, nvidia-smi muestra la misma situación en la VRAM. Si el servidor se queda sin memoria, el kernel elimina un proceso para recuperarla:
sudo dmesg -T | grep -i "out of memory"Una línea que mencione ollama significa que el servidor de modelos fue la víctima. Una línea que mencione su base de datos significa que el modelo ganó y algo que le interesaba perdió. Ambos resultados provienen de la misma decisión: una ventana de keep-alive larga en un servidor sin margen de maniobra.
Hay dos costes que son fáciles de pasar por alto. Una longitud de contexto mayor reserva una caché KV más grande (caché de clave-valor, el estado de atención por token que el modelo mantiene mientras genera), y esa caché es parte del tamaño residente. Su tamaño depende de num_ctx, por lo que aumentar la ventana de contexto incrementa la memoria que un modelo residente ocupa durante todo el periodo de inactividad, no solo mientras responde. Un valor de OLLAMA_NUM_PARALLEL superior a 1 reserva esa caché una vez por cada ranura paralela cuando el modelo admite dicha paralelización. Ollama v0.40.16 fuerza la paralelización a 1 para modelos sin capacidad de completado, incluidos los modelos de embedding; su planificador ya no distingue a mllama o qwen3next. Si planea atender a varias personas con un solo modelo, dimensione la memoria para las ranuras, no solo para los pesos.
Un valor predeterminado razonable: un modelo en un servidor con margen de maniobra puede usar -1. Un servidor compartido debería usar una ventana que cubra los intervalos entre sus peticiones, como 30m, para que la memoria se libere cuando deje de trabajar.
Descargar un modelo inmediatamente
ollama stop qwen3:8bDevuelve una respuesta sin contenido después de solicitar la expiración. La descarga espera a que terminen las solicitudes activas, por lo que el comando puede devolver el control antes de liberar la memoria. También devuelve una respuesta sin contenido si has descargado un modelo, pero no está cargado en ese momento. El comando nunca comprueba qué modelos están residentes: envía la solicitud de descarga y el servidor responde correctamente, tanto si había algo en memoria como si no. El error couldn't find model "qwen3:8b" to stop sólo aparece cuando no hay ningún modelo con ese nombre instalado en este servidor. Normalmente, esto indica un error tipográfico en el nombre o la etiqueta. Por tanto, un ollama stop silencioso no demuestra que se haya liberado memoria. ollama ps sí lo demuestra. La forma de la API es una solicitud sin indicador y con keep_alive establecido en 0:
curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'La respuesta contiene "done_reason": "unload". Usa esta opción en lugar de reiniciar el servicio. systemctl restart ollama también libera la memoria, pero descarga todos los demás modelos cargados y termina cualquier solicitud que estuviera en ejecución.
Ejecutar más de un modelo en un servidor
OLLAMA_MAX_LOADED_MODELS limita cuántos modelos pueden permanecer cargados a la vez. Desde octubre de 2026, el valor predeterminado es tres por GPU o tres en un equipo que sólo usa CPU. El límite cuenta modelos, pero la memoria es la limitación real. Por eso, un segundo modelo grande puede quedarse sin espacio mucho antes de llegar a tres.
Cuando se solicita un modelo nuevo y no hay memoria suficiente, o se ha alcanzado el límite, el planificador descarga uno de los modelos residentes para liberar espacio. Prefiere uno que no tenga ninguna solicitud activa. También puede expulsar un modelo cuyo temporizador no haya expirado, incluido uno cargado con -1, aunque primero intenta con los modelos que tienen ventanas más cortas. Por tanto, un valor negativo de keep_alive significa que no hay tiempo de espera de inactividad. El planificador no fija los pesos para impedir la solicitud de otro modelo.
Estas decisiones aparecen en el registro del servicio. El caso del límite sólo se registra en el nivel de depuración. Añada una segunda línea Environment="OLLAMA_DEBUG=1" al mismo drop-in, reinicie el servicio y supervise el registro:
sudo journalctl -u ollama -fLea el motivo que aparece junto a la solicitud que provocó la descarga. max runners achieved, unloading one to make room significa que se alcanzó el límite de OLLAMA_MAX_LOADED_MODELS. Esto puede ocurrir aunque ambos modelos quepan en la memoria, por lo que debe aumentar el límite si free -h muestra margen disponible. Si aparece una línea que indica que se prevé que el modelo nuevo supere la memoria disponible, seguida de una expulsión, significa que la comprobación de ajuste del planificador rechazó cargar ambos modelos juntos debido al margen de memoria. En ese caso, la solución es usar menos modelos en este equipo, o asignar una ventana larga al modelo que debe responder con rapidez y 0 al que se consulta con poca frecuencia.
Orientación válida más allá de la próxima versión
Ollama publica versiones con frecuencia y sus valores predeterminados cambian, así que compruebe la compilación que tiene delante en lugar de memorizar números:
ollama --version
ollama serve --helpollama serve --help muestra las variables de entorno que esa compilación lee realmente, incluida OLLAMA_KEEP_ALIVE. Dos reglas se han mantenido entre versiones y son una base segura. Un valor incluido en la solicitud tiene prioridad sobre el valor predeterminado del servidor. Además, ollama ps refleja qué está cargado realmente, independientemente de lo que indique un archivo de configuración.
Si un editor o un agente controla el servidor, compruebe qué envía ese cliente antes de atribuir el problema al servidor. Configurar un agente de programación para usar su propio servidor Ollama explica dónde se encuentran esos valores de la solicitud.
FAQ
¿Por qué Ollama descarga mi modelo después de 5 minutos?
Cinco minutos es el valor predeterminado de keep_alive, el temporizador de inactividad que Ollama inicia cuando termina una solicitud. Cuando expira, el servidor libera los pesos. Por eso, la siguiente solicitud debe cargarlos de nuevo y esa recarga provoca la pausa que se percibe. Auméntelo para una solicitud enviando "keep_alive": "30m" en el cuerpo JSON, o para todo el servidor mediante la variable de entorno OLLAMA_KEEP_ALIVE.
¿Cómo mantengo un modelo de Ollama cargado permanentemente en memoria?
Use un valor negativo: "keep_alive": -1 en la solicitud o OLLAMA_KEEP_ALIVE=-1 para el servidor. ollama ps muestra entonces Forever en la columna UNTIL. Esto elimina el temporizador de inactividad y nada más. Si se solicita otro modelo y queda poca memoria, el planificador aún descarga este modelo para liberar espacio. Las solicitudes posteriores para el mismo modelo también pueden cambiar su tiempo de espera o provocar una recarga si cambian las opciones del runner. Un reinicio o arranque también lo elimina de la memoria, por lo que debe precargar el modelo de nuevo después.
¿Por qué se ignora OLLAMA_KEEP_ALIVE?
Compruebe dónde la configuró. Ejecute systemctl show ollama --property=Environment. Si la variable no aparece en esa salida, el servidor nunca la recibió, porque una variable exportada en el shell no llega a un servicio de systemd. Configúrela mediante sudo systemctl edit ollama.service y ejecute después sudo systemctl daemon-reload y sudo systemctl restart ollama. La otra causa es un cliente que envía su propio keep_alive en la solicitud, lo que sobrescribe el valor predeterminado del servidor.
¿Cómo libero la memoria sin reiniciar Ollama?
ollama stop qwen3:8b solicita la expiración de ese modelo y mantiene en ejecución el servidor y todos los demás modelos cargados. Las solicitudes activas deben terminar antes de que se descargue. Mediante la API, envíe una solicitud sin prompt y con "keep_alive": 0. La respuesta incluirá "done_reason": "unload". Confírmelo con ollama ps, que ya no debería mostrar el modelo cuando termine la descarga.