SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor

Ollama: NUM_PARALLEL y MAX_QUEUE explicados

La segunda solicitud puede esperar o devolver HTTP 503. Aprende qué controlan OLLAMA_NUM_PARALLEL y OLLAMA_MAX_QUEUE y por qué cada espacio consume memoria.

Qué ocurre con la segunda petición a Ollama mientras la primera está generando

La concurrencia de Ollama se determina mediante tres variables de entorno y, por defecto, un modelo cargado atiende una petición a la vez. La segunda petición no se rechaza y no recibe una respuesta parcial. Espera en una cola hasta que un espacio queda libre y, entonces, se ejecuta a velocidad normal.

Una petición entrante tiene tres destinos posibles. Comienza inmediatamente en un espacio libre. Espera en la cola. O la cola ya está llena y el servidor la rechaza con un HTTP 503. Cuál de ellos se aplica lo deciden OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE y OLLAMA_MAX_LOADED_MODELS. Existe un detalle en las versiones actuales a fecha de octubre de 2026. El FAQ describe la cola en términos generales, pero el código fuente del planificador es más específico. El 503 solo se aplica a las peticiones que llegan mientras su modelo aún debe cargarse, o recargarse con ajustes diferentes. Ollama no rechaza una petición que un modelo ya cargado puede servir tal cual. Esa petición espera un espacio el tiempo que sea necesario.

La configuración por defecto es segura, y es también la razón por la que un segundo usuario informa de que el servidor se ha "colgado" cuando no hay nada roto. Añadir espacios es un cambio de dos líneas. La parte que causa problemas es la memoria. Cada espacio paralelo necesita su propia caché de clave/valor (KV cache), el bloque de memoria que un modelo mantiene para los tokens que ya ha procesado. Si añade espacios sin añadir VRAM (memoria de vídeo en la GPU), convertirá una respuesta lenta en un fallo de carga. En un servidor solo con CPU, esa misma caché se extrae de la RAM del sistema.

Qué controlan OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE y OLLAMA_MAX_LOADED_MODELS

Estos son los valores predeterminados en las versiones actuales de Ollama a fecha de octubre de 2026. Compruebe los suyos en lugar de confiar en las cifras aquí expuestas, utilizando la línea de registro que se muestra más abajo.

  • OLLAMA_NUM_PARALLEL es cuántas peticiones gestiona simultáneamente un modelo cargado. El valor predeterminado es 1, por lo que las peticiones se sirven una tras otra.
  • OLLAMA_MAX_LOADED_MODELS es cuántos modelos diferentes permanecen residentes a la vez. El valor predeterminado es 0, lo que significa que Ollama elige: tres modelos por GPU, y tres en una máquina sin GPU.
  • OLLAMA_MAX_QUEUE es, en palabras del FAQ, el número máximo de peticiones que Ollama pondrá en cola cuando esté ocupado antes de rechazar peticiones adicionales. El valor predeterminado es 512. La petición que llega cuando esa cola está llena es rechazada inmediatamente. Sin embargo, en el código actual del planificador, solo entran en esta cola las peticiones cuyo modelo debe ser cargado o recargado primero. Las peticiones para un modelo que ya está cargado omiten esta cola y esperan a que haya un espacio libre, y esa espera no tiene límite. Un mantenedor ha descrito esto como un efecto secundario de cómo está implementado el planificador, y los mantenedores de Ollama realizan el seguimiento de una corrección como una solicitud de funcionalidad (issue #7758), la cual seguía abierta en octubre de 2026.

El peor escenario de memoria es el producto de los dos primeros. Dos modelos cargados con cuatro espacios cada uno suponen ocho asignaciones de espacio de caché KV, todas residentes a la vez, y Ollama intentará satisfacer esa demanda. En un equipo con una sola GPU suele ser mejor mantener un modelo y asignarle espacios, ya que el cálculo sigue siendo algo que puede hacer mentalmente.

Por qué cada slot paralelo consume VRAM

Cuando Ollama carga un modelo, inicia un proceso runner independiente. Aquí importan dos de los argumentos que le pasa: -c es el contexto total para el que el runner reserva una caché KV, y -np es el número de secuencias paralelas. Ollama establece -c multiplicando la longitud de contexto por solicitud por el número de slots. Después, el runner divide ese total de forma uniforme entre los slots, de modo que cada solicitud sigue recibiendo la longitud de contexto solicitada.

Esa es toda la restricción y explica por qué el paralelismo no es gratuito. Pasar de un slot a cuatro requiere cuatro veces más caché KV con la misma longitud de contexto por solicitud. Los slots no comparten nada. La parte de un slot inactivo tampoco se presta a uno ocupado, porque la división queda fijada cuando se inicia el runner. En una GPU, esa memoria es VRAM. En un servidor que sólo usa CPU, es RAM del sistema, y se aplica la misma multiplicación.

Puede leer los valores reales en lugar de los que pretendía configurar:

journalctl -u ollama --no-pager -n 500 | grep "starting llama-server"

Esa línea contiene la línea de comandos completa del runner, incluidos -c y -np. Si -np vale 1 después de configurar la variable, compruebe primero el tipo de modelo. Ollama v0.40.15 añadió solicitudes paralelas para modelos GGUF recurrentes y de visión, por lo que la restricción anterior de un solo slot ya no se aplica a esos modelos. Los modelos de embeddings siguen teniendo un slot en el planificador. En un modelo GGUF de generación, compruebe que la configuración llegue al servidor, como se explica en la sección siguiente.

Si los pesos del modelo más esa caché KV no caben en la VRAM, Ollama mueve algunas capas a la RAM del sistema y esas capas se ejecutan en la CPU. Las capas de CPU son mucho más lentas que las de GPU, por lo que todas las solicitudes se vuelven más lentas, incluida la solicitud única con la que empezó. Por tanto, aumentar el paralelismo puede reducir el rendimiento en lugar de aumentarlo. Con un modelo suficientemente grande, los pesos por sí solos determinan el resultado antes de cualquier cálculo de slots. Por eso alojar por cuenta propia algo del tamaño de Kimi K3 es una cuestión de cuántas tarjetas tiene, no de cuántos slots configura.

ollama ps

La columna PROCESSOR muestra 100% GPU cuando todo el modelo cabe. Una división como 35%/65% CPU/GPU significa que parte del modelo se ejecuta en la CPU. La columna SIZE incluye la caché KV, por lo que aumenta al elevar el número de slots y volver a cargar el modelo. Aumente OLLAMA_NUM_PARALLEL, reinicie, envíe una solicitud y vuelva a ejecutar ollama ps: ese es el coste de memoria de su cambio, medido en lugar de estimado. Si la medición indica que el modelo ya no cabe, recuerde que los pesos son la otra mitad del mismo presupuesto. Pasar de una compilación fp16 a una q8 o q4 suele liberar más VRAM que la que consume el slot adicional.

La longitud de contexto y el número de slots se multiplican, por lo que deben elegirse conjuntamente. Un contexto grande con cuatro slots equivale a cuatro contextos grandes. Si también está ajustando la ventana de contexto num_ctx del modelo, cambie sólo uno de los dos valores cada vez. De lo contrario, no sabrá cuál de ellos llenó la tarjeta.

Cómo configurar estas variables para que sobrevivan a un reinicio

En Linux, Ollama se ejecuta como un servicio de systemd. Ejecutar export OLLAMA_NUM_PARALLEL=4 en el shell no cambia nada, porque systemd inicia el servicio con su propio entorno y nunca ve el shell. Use un archivo drop-in.

sudo systemctl edit ollama.service

Añada esto en el editor que se abre:

[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_MAX_QUEUE=32"

Después, vuelva a cargar la configuración y reinicie el servicio:

sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

systemctl show muestra lo que systemd entregará al proceso. Si la variable no aparece ahí, el drop-in no se guardó o se omitió daemon-reload. Confírmelo también desde el propio servidor:

journalctl -u ollama --no-pager | grep "server config" | tail -1

Ollama registra su configuración del servidor al iniciar, en una línea cuyo mensaje es server config. Ese mapa muestra los valores de entorno configurados que informa Ollama y es la forma más rápida de determinar si una variable surtió efecto. Muestra el valor que configuró, no el número de slots que obtuvo realmente un modelo concreto. Para eso, consulte el valor -np en la línea del runner anterior.

Un modelo que ya está cargado conserva el número de slots con el que se inició, porque ese valor queda fijado en el proceso del runner durante el arranque. El reinicio anterior descarga todo, por lo que la siguiente solicitud vuelve a cargar el modelo con la nueva configuración y asume el tiempo de carga una sola vez. El tiempo que el modelo permanece cargado después es un control independiente, explicado en mantener un modelo de Ollama cargado entre solicitudes.

Cómo se ven los estados served, queued y refused desde el cliente

Envíe varias peticiones a la vez y mida su tiempo de respuesta. Esto ejecuta ocho peticiones de streaming en paralelo e imprime el estado y los tiempos de cada una:

for i in $(seq 1 8); do
  curl -s -o /dev/null \
    -w "req$i http=%{http_code} ttfb=%{time_starttransfer}s total=%{time_total}s\n" \
    http://127.0.0.1:11434/api/generate \
    -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":true}' &
done
wait

ttfb es el tiempo hasta el primer byte del stream, el cual es cercano al tiempo hasta el primer token (TTFT) porque el primer fragmento transmitido contiene el primer token.

Served (servido) en paralelo. Cada petición reporta un ttfb similar, y el total aumenta para todas ellas al mismo tiempo. La GPU se comparte entre las ranuras activas, por lo que cada respuesta es más lenta de lo que sería por sí sola, aunque se completan más peticiones por minuto. Este es el régimen que usted adquiere al aumentar OLLAMA_NUM_PARALLEL.

Queued (en cola). Las primeras peticiones responden rápidamente y las posteriores muestran un ttfb elevado seguido de una generación normal. La espera corresponde a la cola, no al modelo. Un usuario que observa una ventana de chat ve una pausa larga en blanco y luego el texto a velocidad completa. Esa forma, lenta al inicio y rápida después, es la firma de una cola en lugar de una GPU sobrecargada.

Refused (rechazado). El cliente recibe http=503 casi instantáneamente, y el cuerpo es:

{"error":"server busy, please try again.  maximum pending requests exceeded"}

Ese mensaje significa que la cola de planificación estaba llena en el momento en que llegó la petición. No indica nada sobre la VRAM ni sobre el modelo. En las versiones actuales, esa cola solo contiene peticiones cuyo modelo aún no se ha cargado, o que debe recargarse con configuraciones diferentes. Si el modelo ya está residente cuando ejecuta el bucle anterior, espere que cada petición devuelva 200, sin importar cuán bajo establezca OLLAMA_MAX_QUEUE. El desbordamiento se manifiesta como un ttfb más largo.

Un límite honesto: Ollama no publica la profundidad de la cola. ollama ps y el endpoint /api/ps reportan los modelos que están cargados, no las peticiones que están esperando. Por lo tanto, usted mide la cola desde el lado del cliente, observando el tiempo hasta el primer byte, o cuenta las respuestas 503 en lo que sea que esté situado por delante.

Por qué un MAX_QUEUE más pequeño suele ser la mejor configuración

Una cola de 512 parece generosa, pero en una sola ranura es prácticamente inútil. La petición 300 espera detrás de 299 generaciones completas. Eso supone minutos en el mejor de los casos. Cualquier cliente HTTP abandona mucho antes, por lo que el emisor recibe un tiempo de espera agotado (timeout) del lado del cliente, lo cual no indica la causa y no proporciona nada a su monitorización para generar alertas.

Una cola más pequeña convierte ese desbordamiento en un 503 inmediato, pero solo para las peticiones que esperan a que un modelo se cargue o recargue, como el pico que llega tras un reinicio o mientras se intercambian modelos. A fecha de octubre de 2026, las peticiones a un modelo que ya está cargado omiten OLLAMA_MAX_QUEUE y esperan una ranura libre sin límite. Por tanto, reducir la cola no acortará la espera en un servidor ocupado con un modelo residente. Para obtener un rechazo rápido en ese caso, limite la concurrencia delante de Ollama, como describe la siguiente sección. Un 503 es útil: un proxy inverso puede reintentarlo, un cliente puede esperar (back off), un panel de control puede contabilizarlo y un administrador puede leerlo. Calcule el límite a partir de sus propias mediciones. Si una generación tarda unos diez segundos y su cliente espera sesenta, entonces unas seis peticiones por ranura pueden completarse dentro de ese intervalo, y permitir que esperen más solo produce tiempos de espera agotados.

Cuándo poner una cola delante de Ollama

La cola integrada funciona en orden de llegada (FIFO) y no sabe quién realiza cada solicitud. Para una aplicación que se comunica con un solo servidor, esto es suficiente. Añadir infraestructura sólo introduciría más puntos de fallo. Considere colocar un componente delante cuando se cumpla una de estas condiciones.

  • Necesita prioridades. Un chat interactivo no debería esperar detrás de un trabajo de resumen por lotes. La cola de Ollama no admite prioridades, por lo que el trabajo por lotes debe mantenerse fuera y enviarse lentamente.
  • Necesita equidad. Un cliente puede ocupar todos los slots y acumular solicitudes pendientes por su cuenta. Los demás clientes tendrán que esperar detrás de él o recibirán un 503 si su solicitud necesita cargar un modelo.
  • Necesita limitar el tiempo de espera. Ollama conserva indefinidamente las solicitudes de un modelo que ya está cargado. Por tanto, el único límite fiable es el que se establezca delante.
  • Necesita que el trabajo sobreviva a un reinicio. La cola reside en la memoria del servidor. Si reinicia Ollama, se pierden todas las solicitudes pendientes.
  • Necesita reintentos reales con backoff, registrados en un lugar que pueda consultar después.

La opción ligera es un reverse proxy. En nginx, limit_conn limita las conexiones simultáneas y limit_req limita la tasa de llegada por cliente, de modo que el exceso se rechaza en el proxy y nunca llega a Ollama. La opción más completa es una cola de trabajos con una base de datos delante de un worker que llama a Ollama. Esto es lo que necesita cuando las solicitudes deben sobrevivir al reinicio de un proceso. Dimensionarla para tráfico real requiere un análisis independiente: planificar un LLM autohospedado para usuarios simultáneos explica los cálculos, y ejecutar Ollama en un VPS cubre la instalación base que dan por supuestas estas variables.

Cuando la respuesta correcta es usar otro servidor

Hay un límite que no se puede superar ajustando parámetros. Ollama divide la caché KV en slots iguales y fijos cuando carga el modelo. La memoria de un slot inactivo no puede utilizarla otro slot ocupado, y el número de slots no puede cambiar sin descargar el modelo. Este diseño es adecuado para una persona, un equipo pequeño o un agente de programación.

Los servidores diseñados para muchos usuarios simultáneos funcionan de otra forma. Asignan la caché KV en páginas pequeñas según la demanda y añaden las solicitudes entrantes a un batch que ya está en ejecución. Así, la memoria sigue la demanda real en lugar de una división fija. Si el objetivo es admitir muchos usuarios simultáneos en una sola GPU, esta diferencia de arquitectura importa más que cualquier valor de OLLAMA_NUM_PARALLEL. La comparación entre Ollama y vLLM es el lugar donde se debe tomar esa decisión. No cambie por principio. Otro servidor requiere más tareas de operación y, si el tráfico procede de unas pocas personas, el comportamiento integrado es la opción correcta. Si la pregunta real es si conviene ejecutar un servidor de modelos por cuenta propia, la comparación entre un servidor privado de IA con presupuesto bajo solicitud y la construcción de la misma pila en una GPU alquilada explica esa decisión, incluido cuándo una API es una opción de compra más conveniente.

Mida su propio rendimiento y el tiempo hasta el primer token

Las cifras publicadas de tokens por segundo proceden de otra GPU, otro modelo, otra cuantización, otra longitud de contexto y otro prompt. Ninguno de esos factores coincide necesariamente con los suyos. Considere cualquier cifra que lea como una referencia aproximada y mida el equipo que tiene delante.

Ollama devuelve los tiempos en el objeto JSON final de cada respuesta. eval_count es el número de tokens generados y eval_duration es el tiempo empleado en generarlos, expresado en nanosegundos.

sudo apt install -y jq
curl -s http://127.0.0.1:11434/api/generate \
  -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":false}' \
  | jq '{prompt_eval_count, eval_count, eval_duration, tokens_per_second: (.eval_count / (.eval_duration / 1000000000))}'

Ejecute esto con un slot y repítalo con la concurrencia que espera utilizar realmente. Compare las dos cifras que determinan si los usuarios estarán satisfechos: el tiempo hasta el primer token y los tokens por segundo por solicitud. El rendimiento por solicitud siempre disminuye al añadir slots. La cuestión es si disminuye más de lo que sus usuarios aceptarán. Medición de tokens por segundo en un LLM local explica el método con más detalle, incluido cómo mantener constante el prompt entre ejecuciones.

Un endpoint público con una cola amplia es un objetivo de denegación de servicio

Configurar OLLAMA_HOST=0.0.0.0:11434 hace que la API escuche en todas las interfaces, y la API local no requiere autenticación. Ollama incluye inicio de sesión integrado para modelos en la nube, publicación y descargas privadas. La inferencia directa en la nube en https://ollama.com/api y https://ollama.com/v1 requiere una clave de API. Con la cola predeterminada, un endpoint abierto acepta hasta 512 solicitudes en espera de que se cargue un modelo, de cualquier persona que lo encuentre. Si el modelo ya está cargado, mantendrá todas las solicitudes que se conecten, sin límite, durante todo el tiempo que cada cliente permanezca conectado. Mantener el servidor ocupado de esta forma cuesta casi nada al atacante: solicitudes largas, sin inicio de sesión, sin límite de velocidad y sin facturación. Tus propios usuarios recibirán respuestas 503 o tendrán que esperar mucho, y la máquina permanecerá ocupada todo el tiempo.

Mantén el listener en loopback y accede a él mediante un túnel SSH o una red privada, o coloca autenticación y limitación de velocidad delante del endpoint. Protección de un endpoint de la API de Ollama cubre ambas opciones. Ajusta la cola después de hacer esto, porque la longitud de la cola es un ajuste de capacidad y no protege nada.

FAQ

¿Por qué mi segunda solicitud a Ollama espera a que termine la primera?

Porque OLLAMA_NUM_PARALLEL tiene el valor predeterminado 1, por lo que un modelo cargado procesa una solicitud cada vez y las demás esperan en orden. La solicitud en espera mantiene abierta su conexión HTTP y no envía bytes hasta que se libera un slot. Desde el cliente, esto parece que el modelo responde lentamente. La diferencia se observa en el patrón temporal: una pausa larga seguida de texto a velocidad máxima indica una cola, mientras que un flujo lento desde el primer token indica un modelo lento. Aumente el número de slots mediante un drop-in de systemd y reinicie el servicio. Después, compruebe el valor de -np en la línea del runner, porque los modelos de embeddings siguen teniendo un solo slot en el planificador.

¿Qué significa "server busy, please try again. maximum pending requests exceeded"?

Es el error de desbordamiento de la cola de Ollama, que se devuelve con el estado HTTP 503. El número de solicitudes que esperaban ser planificadas, es decir, que esperaban a que su modelo se cargara o recargara, alcanzó OLLAMA_MAX_QUEUE. Su valor predeterminado es 512, por lo que la solicitud más reciente se rechazó en lugar de añadirse a la cola. Las solicitudes a un modelo que ya está cargado no cuentan para ese límite. Este error aparece sobre todo durante ráfagas al iniciar el servicio o mientras se cambian los modelos. No es un error de memoria ni un error del modelo. Aumentar la cola sólo hace que los clientes esperen más antes de recibir el mismo rechazo. Las soluciones reales son aumentar el número de slots si dispone de VRAM suficiente, reducir la carga entrante o colocar delante una cola que pueda reintentar y establecer prioridades.

¿Aumentar OLLAMA_NUM_PARALLEL hace que Ollama sea más rápido?

No. Permite procesar más solicitudes al mismo tiempo, pero cada una tarda más que si se ejecutara sola porque comparten una GPU. También multiplica la caché KV, ya que Ollama inicia el runner con un contexto total igual a la longitud de contexto multiplicada por el número de slots. Si el resultado ya no cabe en la VRAM, Ollama mueve capas a la CPU y todas las solicitudes se ralentizan, incluida una solicitud única sin competencia. Compruebe ollama ps después del cambio y confirme que la columna PROCESSOR sigue mostrando 100% GPU.

¿Es necesario reiniciar Ollama después de cambiar estas variables?

Sí. El servidor las lee al iniciarse, y un modelo en ejecución conserva el número de slots que se fijó en su proceso runner cuando se inició. Edite el drop-in con sudo systemctl edit ollama.service y ejecute sudo systemctl daemon-reload y sudo systemctl restart ollama. Confirme el resultado con systemctl show ollama --property=Environment y compruebe después la línea server config en journalctl -u ollama, que muestra los valores de entorno configurados que Ollama comunica.

¿Cuántos slots paralelos debo configurar?

Empiece con 1 y aumente el valor un paso cada vez. Después de cada paso, reinicie Ollama, envíe una solicitud para cargar el modelo y ejecute ollama ps. Deténgase en el último valor en el que PROCESSOR siga mostrando 100% GPU y la columna SIZE conserve margen para el contexto más largo que atienda. Después, mida el tiempo hasta el primer token y los tokens por segundo con ese valor y bajo la concurrencia real. Reduzca un paso si la velocidad por solicitud ha bajado por debajo de lo que sus usuarios toleran.

¿Te resultó útil este artículo?

#ollama#concurrency#vram#queueing#self-hosted-llm