Ver todos los artículos
OllamaMemoriaBenchmarksAutoalojadoIA local

Ollama num_ctx y memoria: de 4k a 128k, medido

JG
Jacobo González Jaspe
|
Ilustración abstracta: una balanza mínima con un cubo azul marino y una esfera ámbar. Desde la spark
Ilustración generada con IA en nuestra máquina.
Este artículo también está en inglés:Ollama num_ctx Memory Usage: 4k to 128k, Measured

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, y sudo solo para el paso 4.
  • Opcional: la misma tabla para tu máquina. Nuestro script scripts/bench/ollama_num_ctx.py está en nuestro repositorio interno y todavía no es público; si cargas cada tamaño y lees ollama ps (paso 1), sacas los mismos números a mano.

Paso 1: mira qué contexto estás pagando

bash
ollama ps
# NAME           SIZE      PROCESSOR    CONTEXT
# llama3.1:8b    9.2 GB    100% GPU     32768

ollama show llama3.1:8b --parameters
# num_ctx    32768

SIZE 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ó:

bash
systemctl show ollama --property=Environment
journalctl -u ollama | grep -i num_ctx | tail -3

Paso 2: fíjalo en cada petición

Cualquier llamada a la API propia de Ollama puede llevar el tamaño:

bash
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:

bash
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_ctx

Cualquier 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:

bash
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:

bash
sudo systemctl edit ollama
# [Service]
# Environment="OLLAMA_CONTEXT_LENGTH=16384"
# Environment="OLLAMA_NUM_PARALLEL=4"
sudo systemctl restart ollama

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

bash
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.json

Un slot (primera máquina, OLLAMA_NUM_PARALLEL=1):

num_ctxllama3.1:8b (fichero de 4,9 GB)gemma4:26b (fichero de 18,0 GB)
4.0965,27 GB17,20 GB
32.7689,21 GB17,47 GB
131.07222,79 GB18,36 GB

llama3.1:8b con distintos slots (tokens reservados = slots × num_ctx):

Máquina, slotsnum_ctxTokens reservadosTamaño cargado
primera, 14.0964.0965,27 GB
primera, 44.09616.3847,00 GB
segunda, 84.09632.7689,15 GB
primera, 132.76832.7689,21 GB
segunda, 816.384131.07222,32 GB
primera, 432.768131.07222,38 GB
primera, 1131.072131.07222,79 GB
segunda, 832.768262.14439,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=32768 y 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_ctx a 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

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.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes