Gérer la concurrence Ollama : NUM_PARALLEL et MAX_QUEUE
Comprenez le comportement des requêtes avec OLLAMA_NUM_PARALLEL et OLLAMA_MAX_QUEUE. Découvrez pourquoi chaque slot consomme de la VRAM et évitez l'erreur HTTP 503 serveur.
Ce qui arrive à la deuxième requête Ollama pendant la génération de la première
La concurrence d’Ollama est déterminée par trois variables d’environnement. Par défaut, un modèle chargé traite une seule requête à la fois. La deuxième requête n’est pas refusée et ne reçoit pas de réponse partielle. Elle attend dans une file jusqu’à ce qu’un slot soit disponible, puis elle s’exécute à vitesse normale.
Une requête entrante peut avoir trois issues. Elle démarre immédiatement dans un slot libre. Elle attend dans la file. Ou la file est déjà pleine et le serveur la refuse avec HTTP 503. Le résultat dépend de OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE et OLLAMA_MAX_LOADED_MODELS. Une particularité existe dans les versions actuelles, en octobre 2026. La FAQ décrit la file de manière générale, mais le code source du scheduler est plus précis. Le code HTTP 503 concerne uniquement les requêtes qui arrivent alors que leur modèle doit encore être chargé, ou rechargé avec d’autres paramètres. Ollama ne refuse pas une requête qu’un modèle déjà chargé peut traiter tel quel. Cette requête attend un slot aussi longtemps que nécessaire.
Le comportement par défaut est sûr. C’est aussi la raison pour laquelle un deuxième utilisateur peut signaler que le serveur « ne répond plus » alors qu’aucun problème ne s’est produit. Ajouter des slots nécessite de modifier deux lignes. Le point critique est la mémoire. Chaque slot parallèle nécessite son propre cache clé/valeur (cache KV), c’est-à-dire le bloc de mémoire dans lequel un modèle conserve les tokens qu’il a déjà traités. Ajouter des slots sans ajouter de VRAM (mémoire vidéo du GPU) transforme une réponse lente en échec de chargement. Sur un serveur utilisant uniquement le CPU, ce cache est également alloué dans la RAM système.
Ce que contrôlent OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE et OLLAMA_MAX_LOADED_MODELS
Voici les valeurs par défaut des versions actuelles d’Ollama en octobre 2026. Vérifiez les vôtres au lieu de vous fier à ces chiffres, en utilisant la ligne de journal présentée plus bas.
OLLAMA_NUM_PARALLELindique le nombre de requêtes qu’un modèle chargé peut traiter simultanément. La valeur par défaut est 1 : les requêtes sont donc traitées l’une après l’autre.OLLAMA_MAX_LOADED_MODELSindique le nombre de modèles différents qui restent chargés simultanément. La valeur par défaut est 0, ce qui signifie qu’Ollama choisit la valeur suivante : trois modèles par GPU, et trois sur une machine sans GPU.OLLAMA_MAX_QUEUEindique, selon les termes de la FAQ, le nombre maximal de requêtes qu’Ollama met en file d’attente lorsqu’il est occupé avant de rejeter les suivantes. La valeur par défaut est 512. La requête reçue lorsque la file est pleine est rejetée immédiatement. Toutefois, dans le code actuel du scheduler, seules les requêtes dont le modèle doit d’abord être chargé ou rechargé entrent dans cette file. Les requêtes destinées à un modèle déjà chargé ignorent cette file et attendent qu’un slot se libère ; cette attente n’a aucune limite. Un maintainer a décrit ce comportement comme une conséquence de l’implémentation du scheduler. Les maintainers d’Ollama suivent une correction sous la forme d’une demande de fonctionnalité (issue #7758), qui était toujours ouverte en octobre 2026.
Dans le pire des cas, la mémoire utilisée correspond au produit des deux premières valeurs. Deux modèles chargés avec quatre slots chacun représentent huit allocations de slots de cache KV, toutes résidentes simultanément, et Ollama essaiera de les satisfaire. Sur une machine équipée d’un seul GPU, il est généralement préférable de conserver un seul modèle chargé et de lui attribuer plusieurs slots, car le calcul reste facile à faire de tête.
Pourquoi chaque slot parallèle consomme de la VRAM
Lorsqu’Ollama charge un modèle, il lance un processus d’exécution séparé. Deux des arguments transmis sont ici déterminants : -c représente le contexte total pour lequel le processus alloue un cache KV, et -np correspond au nombre de séquences parallèles. Ollama définit -c comme la longueur de votre contexte par requête multipliée par le nombre de slots. Le processus divise ensuite ce total équitablement entre les slots, afin que chaque requête dispose bien de la longueur de contexte demandée.
C’est là toute la contrainte, et c’est pourquoi le parallélisme n’est pas gratuit. Passer d’un slot à quatre demande quatre fois plus de cache KV pour une même longueur de contexte par requête. Rien n’est partagé entre les slots, et la part d’un slot inactif n’est pas prêtée à un slot occupé, car la répartition est figée au démarrage du processus. Sur un GPU, cette mémoire est de la VRAM. Sur un serveur utilisant uniquement le CPU, il s’agit de la RAM système, et la même multiplication s’applique.
Vous pouvez lire les valeurs réelles plutôt que celles que vous pensiez avoir configurées :
journalctl -u ollama --no-pager -n 500 | grep "starting llama-server"Cette ligne contient la ligne de commande complète du processus, incluant -c et -np. Si -np est égal à 1 après avoir défini la variable, il existe deux causes possibles. La première est le modèle. Ollama limite certaines architectures de modèles à un seul slot, peu importe votre configuration, et journalise model architecture does not currently support parallel requests lorsqu’il le fait. En octobre 2026, cette liste inclut les familles Qwen 3.5, Qwen3-VL, Qwen3-Next, LFM2 et Nemotron-H ; les modèles d’embedding sont également toujours limités à un seul slot. Exécutez journalctl -u ollama --no-pager | grep "does not currently support parallel" pour vérifier. Si cet avertissement est absent, le paramètre n’atteint pas le serveur, et la section suivante explique pourquoi.
Si les poids du modèle et le cache KV ne tiennent pas dans la VRAM, Ollama déplace certaines couches vers la RAM système et ces couches s’exécutent sur le CPU. Les couches CPU sont beaucoup plus lentes que les couches GPU, ce qui ralentit chaque requête, y compris la requête unique que vous traitiez initialement. Augmenter le parallélisme peut donc réduire le débit au lieu de l’augmenter. Avec un modèle suffisamment volumineux, les poids seuls tranchent la question avant même tout calcul de slot, ce qui explique pourquoi l'auto-hébergement d'un modèle de la taille de Kimi K3 dépend davantage du nombre de cartes dont vous disposez que du nombre de slots configurés.
ollama psLa colonne PROCESSOR affiche 100% GPU lorsque l’ensemble tient en mémoire. Une répartition telle que 35%/65% CPU/GPU signifie qu’une partie du modèle s’exécute sur le CPU. La colonne SIZE inclut le cache KV ; elle augmente donc lorsque vous élevez le nombre de slots et rechargez le modèle. Augmentez OLLAMA_NUM_PARALLEL, redémarrez, envoyez une requête, puis exécutez ollama ps à nouveau : c’est le coût mémoire de votre modification, mesuré et non estimé. Si cette mesure indique que le modèle ne tient plus, rappelez-vous que les poids constituent l’autre moitié du même budget, et que passer d'un format fp16 à une version q8 ou q4 libère souvent plus de VRAM que le coût du slot que vous tentiez d’ajouter.
La longueur du contexte et le nombre de slots se multiplient, ils doivent donc être choisis conjointement. Un contexte large avec quatre slots équivaut à quatre contextes larges. Si vous ajustez également la fenêtre de contexte num_ctx pour votre modèle, modifiez l’un des deux paramètres à la fois, sinon vous ne saurez pas lequel a saturé la carte.
Comment définir ces variables pour qu'elles persistent après un redémarrage
Sous Linux, Ollama s'exécute en tant que service systemd. Exécuter export OLLAMA_NUM_PARALLEL=4 dans votre shell ne change rien, car systemd démarre le service avec son propre environnement et n'a pas accès à votre shell. Utilisez un fichier de configuration « drop-in ».
sudo systemctl edit ollama.serviceAjoutez ceci dans l'éditeur qui s'ouvre :
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_MAX_QUEUE=32"Ensuite, rechargez et redémarrez :
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environmentsystemctl show affiche ce que systemd transmettra au processus. Si votre variable est absente, le fichier drop-in n'a pas été enregistré ou daemon-reload a été omis. Confirmez également depuis le serveur lui-même :
journalctl -u ollama --no-pager | grep "server config" | tail -1Ollama consigne l'intégralité de son environnement au démarrage sur une ligne dont le message est server config. Ce mappage montre exactement ce que le serveur a lu ; c'est le moyen le plus rapide de vérifier si une variable a été prise en compte. Il affiche la valeur que vous avez définie, et non le nombre d'emplacements qu'un modèle spécifique a réellement obtenus. Pour cela, lisez la valeur -np sur la ligne du runner ci-dessus.
Un modèle déjà chargé conserve le nombre d'emplacements avec lequel il a été démarré, car la valeur est figée dans le processus du runner au lancement. Le redémarrage ci-dessus décharge tout, donc la requête suivante recharge le modèle avec le nouveau paramètre et subit le temps de chargement une seule fois. La durée pendant laquelle un modèle reste en mémoire après cela est un paramètre distinct, traité dans maintenir un modèle Ollama chargé entre les requêtes.
À quoi ressemblent les requêtes servies, mises en file d’attente et refusées côté client
Envoyez plusieurs requêtes simultanément et mesurez leur durée. Cette commande exécute huit requêtes de streaming en parallèle et affiche le statut ainsi que les durées de chacune :
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
waitttfb correspond au délai avant le premier octet du flux. Il est proche du délai avant le premier token (TTFT), car le premier bloc transmis contient le premier token.
Servies en parallèle. Toutes les requêtes affichent un ttfb similaire, et total augmente pour chacune d’elles en même temps. Le GPU est partagé entre les slots actifs. Chaque réponse est donc plus lente que si elle était exécutée seule, mais davantage de réponses se terminent chaque minute. C’est le fonctionnement que vous obtenez lorsque vous augmentez OLLAMA_NUM_PARALLEL.
Mises en file d’attente. Les premières requêtes obtiennent rapidement une réponse, tandis que les suivantes affichent un ttfb élevé, puis une génération normale. L’attente vient de la file, pas du modèle. Dans une fenêtre de chat, l’utilisateur voit une longue pause sans texte, puis le texte s’affiche à pleine vitesse. Ce profil, lent au démarrage puis rapide, caractérise une file d’attente plutôt qu’un GPU surchargé.
Refusées. Le client reçoit http=503 presque instantanément, et le corps de la réponse est :
{"error":"server busy, please try again. maximum pending requests exceeded"}Ce message signifie que la file d’ordonnancement était pleine au moment de l’arrivée de la requête. Il ne fournit aucune information sur la VRAM ni sur le modèle. Dans les versions actuelles, cette file contient uniquement les requêtes dont le modèle n’est pas encore chargé ou doit être rechargé avec d’autres paramètres. Si le modèle est déjà chargé lorsque vous exécutez la boucle ci-dessus, chaque requête renverra 200, quelle que soit la faible valeur définie pour OLLAMA_MAX_QUEUE. Le dépassement se traduira plutôt par un ttfb plus élevé.
Il existe une limite importante : Ollama ne publie pas la profondeur de sa file d’attente. ollama ps et le endpoint /api/ps indiquent les modèles chargés, pas les requêtes en attente. Vous devez donc mesurer la file côté client en surveillant le délai avant le premier octet, ou compter les réponses 503 renvoyées par le composant placé en amont.
Pourquoi une valeur plus faible de MAX_QUEUE est souvent préférable
Une file de 512 paraît généreuse, mais avec un seul slot, elle est presque inutile. La requête 300 attend derrière 299 générations terminées. Au mieux, cela prend plusieurs minutes. Tous les clients HTTP abandonnent bien avant. L’appelant obtient donc un timeout côté client, qui ne lui indique pas la cause et ne fournit rien à surveiller dans votre monitoring.
Une file plus courte transforme ce dépassement en réponse 503 immédiate, mais uniquement pour les requêtes qui attendent le chargement ou le rechargement d’un modèle, par exemple le burst qui survient après un redémarrage ou pendant le remplacement des modèles. En octobre 2026, les requêtes adressées à un modèle déjà chargé contournent OLLAMA_MAX_QUEUE et attendent un slot libre sans limite. Réduire la file ne raccourcit donc pas l’attente sur un serveur occupé avec un seul modèle résident. Pour obtenir un refus rapide dans ce cas, limitez la concurrence en amont d’Ollama, comme indiqué dans la section suivante. Une réponse 503 est utile : un reverse proxy peut effectuer un retry, un client peut appliquer un backoff, un dashboard peut la comptabiliser et une personne peut la lire. Déterminez cette limite à partir de vos propres mesures. Si une génération prend environ dix secondes et que votre client attend soixante secondes, environ six requêtes par slot peuvent être traitées pendant ce délai. Au-delà, les requêtes en attente ne produisent que des timeouts.
Quand placer une file d'attente devant Ollama
La file d'attente intégrée fonctionne en premier entré, premier sorti (FIFO) et ne distingue pas les appelants. Pour une application communiquant avec un serveur unique, cela suffit, et ajouter de l'infrastructure ne ferait qu'introduire des points de défaillance supplémentaires. Envisagez une solution intermédiaire dans les cas suivants :
- Vous avez besoin de gérer des priorités. Un chat interactif ne doit pas attendre derrière une tâche de résumé par lots. La file d'attente d'Ollama ne gère pas les priorités ; les tâches par lots doivent donc être retenues en amont et injectées progressivement.
- Vous avez besoin d'équité. Un seul client peut occuper tous les emplacements et accumuler des requêtes en attente derrière lui. Tous les autres utilisateurs attendent alors derrière ce client ou reçoivent une erreur 503 si leur requête nécessite le chargement d'un modèle.
- Vous avez besoin d'une limite d'attente définie. Ollama conserve indéfiniment les requêtes pour un modèle déjà chargé ; la seule limite fiable est celle que vous imposez en amont.
- Vous avez besoin que les tâches survivent à un redémarrage. La file d'attente réside dans la mémoire vive du serveur. Redémarrez Ollama et toutes les requêtes en attente sont perdues.
- Vous avez besoin de véritables tentatives avec backoff, enregistrées dans un support consultable ultérieurement.
La version légère consiste à utiliser un reverse proxy. Avec nginx, limit_conn limite les connexions simultanées et limit_req limite le taux d'arrivée par client ; ainsi, le surplus est refusé au niveau du proxy et n'atteint jamais Ollama. La version lourde consiste à utiliser une file d'attente de tâches avec une base de données devant un worker qui appelle Ollama ; c'est ce qu'il vous faut dès lors que les requêtes doivent survivre au redémarrage d'un processus. Dimensionner cela pour du trafic réel est un exercice en soi : planifier l'auto-hébergement d'un LLM pour des utilisateurs simultanés détaille les calculs nécessaires, et exécuter Ollama sur un VPS couvre l'installation de base sur laquelle reposent ces variables.
Quand la réponse honnête est un serveur différent
Il existe une limite que vous ne pouvez pas dépasser par le réglage. Ollama divise le KV cache en emplacements fixes et égaux lors du chargement du modèle. La mémoire d'un emplacement inactif ne peut pas être utilisée par un emplacement occupé, et le nombre d'emplacements ne peut pas changer sans décharger le modèle. Cette conception est adaptée à une seule personne, à une petite équipe ou à un agent de développement.
Les serveurs conçus pour de nombreux utilisateurs simultanés fonctionnent différemment. Ils allouent le KV cache par petites pages à la demande et ajoutent les requêtes entrantes dans un lot déjà en cours d'exécution ; la mémoire suit donc la demande réelle au lieu d'une division fixe. Si votre objectif est de gérer un grand nombre d'utilisateurs simultanés sur un seul GPU, cette différence architecturale compte plus que n'importe quelle valeur de OLLAMA_NUM_PARALLEL. La comparaison entre Ollama et vLLM est l'endroit où prendre cette décision. Ne changez pas par principe, cependant : un serveur différent demande plus d'exploitation, et si votre trafic se limite à quelques personnes, le comportement intégré est la réponse appropriée. Si la vraie question est de savoir s'il faut héberger soi-même un serveur de modèle, comparer un serveur d'IA privé sur devis avec la construction de la même pile sur un GPU loué détaille cette décision, y compris les cas où une API est un meilleur choix financier.
Mesurez votre propre débit et le délai avant le premier token
Les valeurs publiées en tokens par seconde proviennent du GPU, du modèle, de la quantification, de la longueur du contexte et du prompt d’une autre personne. Aucun de ces paramètres ne correspond aux vôtres. Considérez donc chaque valeur lue comme une simple indication et mesurez les performances de la machine que vous utilisez.
Ollama renvoie les temps d’exécution dans le dernier objet JSON de chaque réponse. eval_count indique le nombre de tokens générés et eval_duration le temps consacré à leur génération, en nanosecondes.
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))}'Exécutez cette commande avec un seul slot, puis avec le niveau de concurrence réellement attendu, et comparez les deux valeurs qui déterminent la satisfaction des utilisateurs : le délai avant le premier token et le nombre de tokens par seconde et par requête. Le débit par requête diminue toujours lorsque vous ajoutez des slots. La question est de savoir s’il diminue davantage que vos utilisateurs ne peuvent l’accepter. Mesurer le nombre de tokens par seconde avec un LLM local décrit la méthode plus en détail, notamment la façon de conserver le même prompt entre les mesures.
Un endpoint public avec une file d’attente généreuse est une cible pour un déni de service
La définition de OLLAMA_HOST=0.0.0.0:11434 place l’API sur toutes les interfaces, et Ollama n’intègre aucun mécanisme d’authentification. Avec la file d’attente par défaut, un endpoint ouvert accepte jusqu’à 512 requêtes en attente du chargement d’un modèle, de la part de toute personne qui le trouve. Lorsqu’un modèle est déjà chargé, il conserve chaque requête qui se connecte, sans limite, aussi longtemps que chaque client reste connecté. Cette méthode permet à un attaquant de saturer le serveur à presque aucun coût : requêtes longues, aucune connexion requise, aucune limite de débit, aucune facture. Vos utilisateurs reçoivent alors des réponses 503 ou attendent longtemps, et la machine reste occupée en permanence.
Laissez le listener sur la loopback et accédez-y par un tunnel SSH ou un réseau privé, ou placez une authentification et une limitation de débit devant l’endpoint. Sécuriser un endpoint d’API Ollama couvre ces deux méthodes. Configurez ensuite la file d’attente, car sa longueur est un paramètre de capacité et ne protège rien.
FAQ
Pourquoi ma deuxième requête Ollama attend-elle la fin de la première ?
Parce que OLLAMA_NUM_PARALLEL vaut 1 par défaut. Un modèle chargé ne traite donc qu’une requête à la fois et les autres attendent leur tour. La requête en attente garde sa connexion HTTP ouverte et n’envoie aucun octet tant qu’un slot ne se libère pas. Côté client, cela ressemble à un modèle lent. La forme des temps permet de faire la différence : une longue pause suivie d’un texte généré à pleine vitesse indique une file d’attente, tandis qu’un flux lent dès le premier token indique un modèle lent. Augmentez le nombre de slots avec un drop-in systemd, puis redémarrez le service. Vérifiez ensuite la valeur de -np sur la ligne du runner, car certaines architectures de modèles restent limitées à un slot quelle que soit la valeur configurée.
Que signifie « server busy, please try again. maximum pending requests exceeded » ?
Il s’agit de l’erreur de dépassement de la file d’attente d’Ollama, renvoyée avec le statut HTTP 503. Le nombre de requêtes en attente de planification, c’est-à-dire en attente du chargement ou du rechargement de leur modèle, a atteint OLLAMA_MAX_QUEUE. Cette valeur est 512 par défaut. La nouvelle requête a donc été rejetée au lieu d’être ajoutée à la file. Les requêtes destinées à un modèle déjà chargé ne sont pas comptabilisées dans cette limite. Cette erreur apparaît surtout lors de pics au démarrage ou pendant le remplacement des modèles. Il ne s’agit ni d’une erreur de mémoire ni d’une erreur de modèle. Augmenter la taille de la file fait seulement attendre plus longtemps les appelants avant le même rejet. Les vraies solutions sont d’augmenter le nombre de slots si la VRAM le permet, de réduire la charge entrante ou d’ajouter une file en amont capable de réessayer les requêtes et de les prioriser.
Augmenter OLLAMA_NUM_PARALLEL rend-il Ollama plus rapide ?
Non. Cette modification permet de traiter davantage de requêtes simultanément, mais chacune est plus lente que si elle s’exécutait seule, car elles partagent le même GPU. Elle multiplie également le cache KV, car Ollama démarre le runner avec un contexte total égal à la longueur de contexte multipliée par le nombre de slots. Si le résultat ne tient plus dans la VRAM, Ollama déplace des couches vers le CPU. Toutes les requêtes ralentissent alors, y compris une requête unique sans concurrence. Vérifiez ollama ps après la modification et confirmez que la colonne PROCESSOR contient toujours 100% GPU.
Dois-je redémarrer Ollama après avoir modifié ces variables ?
Oui. Le serveur les lit au démarrage. Un modèle en cours d’exécution conserve le nombre de slots défini dans son processus runner lors de son lancement. Modifiez le drop-in avec sudo systemctl edit ollama.service, puis exécutez sudo systemctl daemon-reload et sudo systemctl restart ollama. Confirmez avec systemctl show ollama --property=Environment, puis vérifiez la ligne server config dans journalctl -u ollama. Elle répertorie l’environnement effectivement chargé par le serveur.
Combien de slots parallèles dois-je configurer ?
Commencez par 1 et augmentez la valeur progressivement, une étape à la fois. Après chaque étape, redémarrez Ollama, envoyez une requête pour charger le modèle, puis exécutez ollama ps. Arrêtez-vous à la dernière valeur pour laquelle PROCESSOR contient toujours 100% GPU et où la colonne SIZE conserve une marge suffisante pour le contexte le plus long que vous servez. Mesurez ensuite le délai avant le premier token et le nombre de tokens par seconde avec cette valeur, dans les conditions de concurrence réelles. Revenez à la valeur précédente si la vitesse par requête est devenue inférieure à ce que vos utilisateurs peuvent accepter.