Al terminar este artículo sabrás cuánta memoria cuesta cada tamaño de contexto, por qué el mismo modelo ocupa 5 GB en un servidor y 39 GB en otro, y dónde fijar num_ctx para que una carga no falle. Sirve en cualquier máquina con Ollama, también en un portátil. Lo aprendimos en una máquina de 128 GB, que resultó no ser suficiente.
El día que los modelos dejaron de cargar
El 2026-10-11, todas las cargas de modelos en nuestra segunda DGX Spark se colgaron o murieron por falta de memoria, salvo las de modelos con su propio tamaño de contexto. La máquina tiene 128 GB de memoria.
El registro decía por qué. Ollama 0.34 elige un contexto por defecto según la memoria que ve, y en esa máquina eligió 262.144 tokens (default_num_ctx=262144). El servidor además tiene 8 slots paralelos, y cada slot reserva su propio contexto. llama3.1:8b, un fichero de 4,9 GB, llevaba 36 GB de memoria residente cuando lo paramos.
Dos modelos siguieron funcionando. Uno tenía 32k escritos en su Modelfile; el otro era el juez de nuestra sección de noticias, que envía num_ctx en cada petición. Eso nos dio el arreglo antes de abrir la documentación. Ese mismo día escribimos un num_ctx propio en todos los modelos de esa máquina (16384 en casi todos), y después fijamos OLLAMA_CONTEXT_LENGTH=32768 en la unidad del servidor.
Luego medimos cuánto cuesta cada opción, para que tú te ahorres la tarde.
Qué necesitas
- Ollama en cualquier máquina. Nuestra guía de instalación te lleva hasta ahí en un portátil.
- Un modelo que ya uses.
curl, ysudosolo para el paso 4.- Opcional: la misma tabla para tu máquina. Nuestro script
scripts/bench/ollama_num_ctx.pyestá en nuestro repositorio interno y todavía no es público; si cargas cada tamaño y leesollama ps(paso 1), sacas los mismos números a mano.
Paso 1: mira qué contexto estás pagando
ollama ps
# NAME SIZE PROCESSOR CONTEXT
# llama3.1:8b 9.2 GB 100% GPU 32768
ollama show llama3.1:8b --parameters
# num_ctx 32768SIZE es lo que ocupa el modelo cargado. CONTEXT es el contexto de un slot, mientras que SIZE paga todos. Si show no lista num_ctx, el modelo usa el valor por defecto del servidor, que depende de tu versión y de tu memoria. En una instalación Linux, mira la configuración del servidor y lo que decidió:
systemctl show ollama --property=Environment
journalctl -u ollama | grep -i num_ctx | tail -3Paso 2: fíjalo en cada petición
Cualquier llamada a la API propia de Ollama puede llevar el tamaño:
curl http://localhost:11434/api/chat -d '{
"model": "llama3.1:8b",
"messages": [{"role": "user", "content": "Resume este correo: ..."}],
"options": {"num_ctx": 8192}
}'Usa siempre el mismo valor desde un mismo cliente. Una petición con otro tamaño obliga a Ollama a cargar el modelo de nuevo.
El endpoint de estilo OpenAI (/v1/chat/completions) no tiene campo para esto. La página de compatibilidad de Ollama indica usar un Modelfile, que es el paso 3.
Paso 3: escríbelo en el modelo
Este es el arreglo que nos funcionó. Un Modelfile de dos líneas le da al modelo un contexto propio:
cat > Modelfile <<'EOF'
FROM qwen3.6:35b
PARAMETER num_ctx 16384
EOF
ollama create qwen3.6-16k -f Modelfile
ollama show qwen3.6-16k --parameters | grep num_ctxCualquier cliente que pida qwen3.6-16k recibe ahora 16k, también los del endpoint /v1. En nuestra segunda máquina sobrescribimos los nombres originales, para que ningún cliente tuviera que cambiar:
curl http://localhost:11434/api/create -d '{"model": "qwen3.6:35b", "from": "qwen3.6:35b", "parameters": {"num_ctx": 16384}}'Un modelo que descargues más adelante llega sin esa línea. Añádesela el mismo día.
Paso 4: fija un valor por defecto en el servidor
El valor por defecto recoge cualquier modelo que se te olvide. En una instalación con systemd:
sudo systemctl edit ollama
# [Service]
# Environment="OLLAMA_CONTEXT_LENGTH=16384"
# Environment="OLLAMA_NUM_PARALLEL=4"
sudo systemctl restart ollamaEl orden es: primero el num_ctx de la petición, luego el del modelo, luego el del servidor.
Qué medimos
Medido el 2026-11-02 en dos NVIDIA DGX Spark (GB10, 128 GB de memoria unificada cada una). Primera máquina: Ollama 0.30.10, dos instancias temporales con 1 y con 4 slots paralelos. Segunda máquina: nuestro Ollama 0.34.0 de producción, 8 slots, con otro modelo cargado todo el tiempo. En cada fila el script descarga el modelo, lo carga con una petición de 8 tokens que lleva num_ctx, lee size en /api/ps y lo vuelve a descargar. Todos los modelos son Q4_K_M. Fichero de resultados: ollama-num-ctx-2026-11-02.json.
python3 scripts/bench/ollama_num_ctx.py --ollama http://127.0.0.1:11437 --num-parallel 1 \
--models llama3.1:8b,gemma4:26b --ctx 4096,32768,131072 --append \
--out docs/measurements/ollama-num-ctx-2026-11-02.json
python3 scripts/bench/ollama_num_ctx.py --ollama http://127.0.0.1:11438 --num-parallel 4 \
--models llama3.1:8b,gemma4:26b --ctx 4096,32768 --append \
--out docs/measurements/ollama-num-ctx-2026-11-02.json
python3 scripts/bench/ollama_num_ctx.py --ollama http://<second-box>:11434 --num-parallel 8 \
--mem-host <second-box> --models llama3.1:8b,qwen3.6:35b --ctx 4096,16384,32768 --append \
--out docs/measurements/ollama-num-ctx-2026-11-02.jsonUn slot (primera máquina, OLLAMA_NUM_PARALLEL=1):
| num_ctx | llama3.1:8b (fichero de 4,9 GB) | gemma4:26b (fichero de 18,0 GB) |
|---|---|---|
| 4.096 | 5,27 GB | 17,20 GB |
| 32.768 | 9,21 GB | 17,47 GB |
| 131.072 | 22,79 GB | 18,36 GB |
llama3.1:8b con distintos slots (tokens reservados = slots × num_ctx):
| Máquina, slots | num_ctx | Tokens reservados | Tamaño cargado |
|---|---|---|---|
| primera, 1 | 4.096 | 4.096 | 5,27 GB |
| primera, 4 | 4.096 | 16.384 | 7,00 GB |
| segunda, 8 | 4.096 | 32.768 | 9,15 GB |
| primera, 1 | 32.768 | 32.768 | 9,21 GB |
| segunda, 8 | 16.384 | 131.072 | 22,32 GB |
| primera, 4 | 32.768 | 131.072 | 22,38 GB |
| primera, 1 | 131.072 | 131.072 | 22,79 GB |
| segunda, 8 | 32.768 | 262.144 | 39,27 GB |
Los dos que apenas crecen: gemma4:26b con 4 slots cargó 18,67 GB (4k) y 19,84 GB (32k). qwen3.6:35b (fichero de 23,9 GB) con 8 slots cargó 22,72 GB (4k), 23,10 GB (16k) y 23,47 GB (32k).
Tres cosas que dicen las tablas.
Lo que cuenta es slots por contexto. 32.768 tokens reservados cuestan unos 9,2 GB, sea un slot de 32k u ocho de 4k. 131.072 cuestan entre 22,3 y 22,8 GB en tres combinaciones, en dos máquinas y dos versiones de Ollama. Las preguntas frecuentes de Ollama dicen que la memoria escala con OLLAMA_NUM_PARALLEL × OLLAMA_CONTEXT_LENGTH (leído el 2026-11-02). Ahora tienes los números.
En un modelo clásico, cada token reservado cuesta unos 0,14 MB. De 32.768 a 131.072 tokens, llama3.1:8b creció 13,58 GB: 0,138 MB por token. La fórmula de ¿Cuánta VRAM necesito? da 0,131 MB para este modelo, suficiente para planificar.
No todos los modelos pagan igual. gemma4:26b ganó 1,16 GB de 4k a 128k; Llama ganó 17,52 GB en el mismo tramo. No medimos por qué. Nuestra lectura es que las dos familias más nuevas guardan la caché de casi todas sus capas con un tamaño fijo, así que solo unas pocas capas pagan por token. Tómalo como hipótesis y mide tu propio modelo.
Lo que no te dicen
- El tamaño se reserva al cargar, no al usarlo. Nuestras cargas eran peticiones de 8 tokens y ya mostraban el tamaño completo. Un contexto largo que nunca llenas cuesta memoria desde el primer mensaje.
- La documentación y tu versión pueden no coincidir. Las preguntas frecuentes dicen que el contexto por defecto es de 4.096 tokens (leído el 2026-11-02). Nuestro 0.34.0 eligió 262.144 en una máquina de 128 GB. Fíate de la línea del registro del paso 1.
- El valor por defecto del servidor es una red, no una talla. Con
OLLAMA_CONTEXT_LENGTH=32768y 8 slots, un Llama 3.1 de 8B sin valor propio carga 39,27 GB. Por eso cada modelo de nuestra segunda máquina lleva además 16k (22,32 GB). - No repetimos el caso de 262.144. Sabemos qué cargas fallaron, no qué búfer reventó primero en cada una. Romper una máquina de producción una vez ya fue bastante.
Veredicto
- Escríbelo en cada modelo.
PARAMETER num_ctxa la medida de la tarea real más larga, no del número de la ficha del modelo. - Después, un valor por defecto en el servidor, más bajo de lo que te parezca cómodo, para el modelo que se te olvide.
- Menos slots antes que más memoria. Cuatro slots a 32k cuestan lo mismo que uno a 128k. Elige lo que necesitan tus usuarios. Lo que compra cada slot en velocidad: num_parallel y keep_alive, medido.
Cuándo no hacerlo
Si una persona usa un modelo en un portátil, mira ollama ps una vez; puede que tu valor por defecto ya sirva. Si tu tarea necesita el contexto largo (un contrato entero, una transcripción larga), un num_ctx pequeño es peor que una carga lenta, porque Ollama corta el principio del prompt y solo lo avisa en su registro. Y si ese trabajo largo ocurre dos veces al mes, un modelo en la nube con una ventana grande puede costarte menos que la memoria.
Siguientes pasos
- Convierte estos tamaños en una decisión de compra: ¿Cuánta VRAM necesito para un LLM local?.
- Antes de fijar
num_ctx, cuenta cuántos tokens ocupa tu tarea más larga con el tokenizador. - Cuando preguntan varias personas a la vez, los slots pesan más: Ollama o vLLM para 1 a 10 usuarios.
- Pon el modelo detrás de cuentas para la oficina: Open WebUI para una oficina de 10.
- Entérate de que una carga falla antes de que te lo diga un compañero: tu servidor de IA local, vigilado.
Trabaja con nosotros
Podemos hacer este análisis con tus datos reales antes de recomendar hardware. Una llamada gratuita de 15 minutos basta para saber si tiene sentido en tu caso: reserva la llamada o mira cómo trabajamos en consultoría.