Ollama concurrency: OLLAMA_NUM_PARALLEL en MAX_QUEUE
Begrijp hoe Ollama verzoeken in de wachtrij plaatst. Ontdek waarom OLLAMA_NUM_PARALLEL direct invloed heeft op uw VRAM-gebruik en wanneer u een HTTP 503 foutmelding krijgt.
Wat gebeurt er met het tweede Ollama-verzoek terwijl het eerste wordt gegenereerd
De gelijktijdigheid van Ollama wordt bepaald door drie omgevingsvariabelen, en standaard bedient één geladen model één verzoek tegelijk. Het tweede verzoek wordt niet geweigerd en ontvangt geen gedeeltelijk antwoord. Het wacht in een wachtrij totdat er een plek vrijkomt, waarna het op normale snelheid wordt uitgevoerd.
Een inkomend verzoek heeft drie mogelijke uitkomsten. Het start direct in een vrije plek. Het wacht in de wachtrij. Of de wachtrij is al vol en de server weigert het verzoek met een HTTP 503-foutmelding. Welke uitkomst u krijgt, wordt bepaald door OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE en OLLAMA_MAX_LOADED_MODELS. Er is één addertje onder het gras in de huidige releases van oktober 2026. De FAQ beschrijft de wachtrij in algemene termen, maar de broncode van de scheduler is specifieker. De 503-fout is alleen van toepassing op verzoeken die binnenkomen terwijl het model nog moet worden geladen, of opnieuw moet worden geladen met andere instellingen. Ollama weigert geen verzoek dat een reeds geladen model in zijn huidige staat kan verwerken. Dat verzoek wacht net zo lang op een plek als nodig is.
De standaardinstelling is veilig, en dit is ook de reden waarom een tweede gebruiker meldt dat de server "vastloopt" terwijl er niets kapot is. Het toevoegen van plekken is een wijziging van twee regels. Het lastige punt is het geheugen. Elke parallelle plek heeft zijn eigen key/value cache (KV cache) nodig, het geheugenblok dat een model bijhoudt voor de tokens die het al heeft verwerkt. Voeg plekken toe zonder extra VRAM (videogeheugen op de GPU) toe te voegen, en u verandert een traag antwoord in een mislukte laadactie. Op een server die alleen op CPU draait, wordt hetzelfde cachegeheugen uit het systeem-RAM gehaald.
Wat OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE en OLLAMA_MAX_LOADED_MODELS elk aansturen
Dit zijn de standaardwaarden in huidige Ollama-releases per oktober 2026. Controleer uw eigen instellingen in plaats van op deze getallen te vertrouwen, door gebruik te maken van de logregel die verderop wordt getoond.
OLLAMA_NUM_PARALLELbepaalt hoeveel verzoeken één geladen model tegelijkertijd afhandelt. De standaardwaarde is 1, waardoor verzoeken na elkaar worden verwerkt.OLLAMA_MAX_LOADED_MODELSbepaalt hoeveel verschillende modellen tegelijkertijd in het geheugen blijven. De standaardwaarde is 0, wat betekent dat Ollama zelf kiest: drie modellen per GPU, en drie op een machine zonder GPU.OLLAMA_MAX_QUEUEis, in de woorden van de FAQ, het maximale aantal verzoeken dat Ollama in de wachtrij plaatst wanneer het systeem bezet is, voordat verdere verzoeken worden geweigerd. De standaardwaarde is 512. Het verzoek dat binnenkomt wanneer die wachtrij vol is, wordt direct geweigerd. In de huidige scheduler-code komen echter alleen verzoeken in deze wachtrij terecht waarvan het model eerst moet worden geladen of opnieuw moet worden geladen. Verzoeken voor een model dat al geladen is, slaan deze wachtrij over en wachten in plaats daarvan op een vrije plek; voor dat wachten geldt geen limiet. Een beheerder heeft dit omschreven als een bijwerking van de implementatie van de scheduler, en de beheerders van Ollama houden een oplossing bij als een feature request (issue #7758), dat in oktober 2026 nog openstond.
Het worst-case geheugengebruik is het product van de eerste twee. Twee geladen modellen met elk vier slots betekent acht slot-toewijzingen van KV-cache die tegelijkertijd in het geheugen staan, en Ollama zal proberen daaraan te voldoen. Op een systeem met één GPU is het meestal beter om één model vast te houden en dat model de slots te geven, omdat de berekening dan eenvoudig blijft.
Waarom elk parallel slot VRAM kost
Wanneer Ollama een model laadt, start het een afzonderlijk runner-proces. Twee argumenten die het doorgeeft zijn hierbij belangrijk: -c is de totale context waarvoor de runner een KV-cache reserveert, en -np is het aantal parallelle reeksen. Ollama stelt -c in op uw contextlengte per aanvraag, vermenigvuldigd met het aantal slots. De runner verdeelt dat totaal vervolgens gelijkmatig over de slots, zodat elke aanvraag nog steeds de contextlengte krijgt die u hebt opgegeven.
Dat is de volledige beperking en daarom is parallellisme niet gratis. Als u van één slot naar vier slots gaat, is bij dezelfde context per aanvraag vier keer zoveel KV-cache nodig. Slots delen niets met elkaar. Het aandeel van een inactief slot wordt niet uitgeleend aan een actief slot, omdat de verdeling wordt vastgelegd wanneer de runner start. Op een GPU is dit VRAM. Op een server die alleen een CPU gebruikt, is dit systeem-RAM. Dezelfde vermenigvuldiging blijft van toepassing.
U kunt de werkelijke waarden uitlezen in plaats van de waarden die u wilde instellen:
journalctl -u ollama --no-pager -n 500 | grep "starting llama-server"Die regel bevat de volledige opdrachtregel van de runner, inclusief -c en -np. Als -np na het instellen van de variabele 1 is, controleert u eerst het modeltype. Ollama v0.40.15 voegde ondersteuning toe voor parallelle aanvragen voor recurrente GGUF-modellen en GGUF-modellen met vision-functionaliteit. De eerdere beperking tot één slot voor deze modellen geldt daarom niet meer. Embedding-modellen krijgen nog steeds één slot in de scheduler. Controleer voor een GGUF-completionmodel of de instelling de server bereikt, zoals in de volgende sectie wordt uitgelegd.
Als de modelgewichten plus die KV-cache niet in het VRAM passen, verplaatst Ollama enkele lagen naar het systeem-RAM. Die lagen worden dan op de CPU uitgevoerd. CPU-lagen zijn veel trager dan GPU-lagen. Daardoor wordt elke aanvraag trager, ook de enkele aanvraag waarmee u begon. Meer parallellisme kan de doorvoer daarom verlagen in plaats van verhogen. Bij een model dat groot genoeg is, bepalen de gewichten alleen al de uitkomst voordat u de slots gaat berekenen. Daarom gaat zelf iets hosten ter grootte van Kimi K3 eerder over het aantal kaarten dat u hebt dan over het aantal slots dat u instelt.
ollama psDe kolom PROCESSOR geeft 100% GPU weer wanneer alles past. Een verdeling zoals 35%/65% CPU/GPU betekent dat een deel van het model op de CPU wordt uitgevoerd. De kolom SIZE bevat de KV-cache. Deze wordt groter wanneer u het aantal slots verhoogt en het model opnieuw laadt. Verhoog OLLAMA_NUM_PARALLEL, start opnieuw op, verstuur één aanvraag en voer ollama ps opnieuw uit. Zo meet u de geheugenkosten van uw wijziging in plaats van deze te schatten. Als uit die meting blijkt dat het model niet meer past, houd er dan rekening mee dat de gewichten de andere helft van hetzelfde budget vormen. Overstappen van een fp16-build naar een q8- of q4-build maakt vaak meer VRAM vrij dan het extra slot kost dat u probeert toe te voegen.
De contextlengte en het aantal slots worden met elkaar vermenigvuldigd. U moet ze daarom samen kiezen. Een grote context met vier slots is hetzelfde als vier grote contexten. Als u ook het num_ctx-contextvenster voor uw model afstemt, wijzig dan steeds maar één van beide waarden. Anders weet u niet welke waarde de kaart heeft gevuld.
Deze variabelen instellen zodat ze een reboot overleven
Op Linux draait Ollama als een systemd-service. Als u export OLLAMA_NUM_PARALLEL=4 in uw shell uitvoert, verandert dat niets. systemd start de service met een eigen omgeving en ziet uw shell niet. Gebruik daarom een drop-in-bestand.
sudo systemctl edit ollama.serviceVoeg dit toe in de editor die wordt geopend:
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_MAX_QUEUE=32"Laad de configuratie opnieuw en start de service opnieuw:
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environmentsystemctl show toont wat systemd aan het proces doorgeeft. Ontbreekt uw variabele daar, dan is het drop-in-bestand niet opgeslagen of is daemon-reload overgeslagen. Controleer dit ook aan de kant van de server zelf:
journalctl -u ollama --no-pager | grep "server config" | tail -1Ollama logt de serverconfiguratie bij het opstarten op een regel met het bericht server config. Deze map toont de geconfigureerde omgevingswaarden die Ollama rapporteert. Dit is de snelste manier om vast te stellen of een variabele effect heeft gehad. De map toont de waarde die u hebt ingesteld, niet het aantal slots dat een bepaald model daadwerkelijk heeft gekregen. Lees daarvoor de waarde -np op de runner-regel erboven.
Een model dat al is geladen, behoudt het aantal slots waarmee het is gestart. Deze waarde wordt namelijk bij het starten vastgelegd in het runner-proces. Met de bovenstaande herstart wordt alles uit het geheugen verwijderd. Bij het volgende verzoek wordt het model daarom met de nieuwe instelling geladen. De laadtijd wordt dan eenmalig betaald. Hoe lang een model daarna geladen blijft, is een afzonderlijke instelling. Zie hiervoor een Ollama-model geladen houden tussen verzoeken.
Hoe served, queued en refused eruitzien vanaf de client
Verstuur meerdere verzoeken tegelijk en meet de tijd. Dit voert acht streaming-verzoeken parallel uit en toont de status en de tijden voor elk verzoek:
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 is de tijd tot de eerste byte van de stream. Dit komt dicht in de buurt van de time to first token (TTFT), omdat het eerste gestreamde fragment het eerste token bevat.
Served in parallel. Elk verzoek rapporteert een vergelijkbare ttfb, en total stijgt voor alle verzoeken tegelijk. De GPU wordt gedeeld tussen de actieve slots, waardoor elk antwoord langzamer is dan wanneer het alleen zou draaien, terwijl er per minuut meer verzoeken worden voltooid. Dit is het regime waar u voor kiest wanneer u OLLAMA_NUM_PARALLEL verhoogt.
Queued. De eerste verzoeken antwoorden snel en de latere verzoeken tonen een grote ttfb, gevolgd door een normale generatie. De wachttijd is de wachtrij, niet het model. Een gebruiker die naar een chatvenster kijkt, ziet een lange lege pauze en daarna tekst op volledige snelheid. Die vorm, traag bij de start en daarna snel, is het kenmerk van een wachtrij in plaats van een overbelaste GPU.
Refused. De client ontvangt vrijwel direct http=503, en de body bevat:
{"error":"server busy, please try again. maximum pending requests exceeded"}Dat bericht betekent dat de planningswachtrij vol was op het moment dat het verzoek arriveerde. Het zegt niets over VRAM en niets over het model. In huidige releases bevat die wachtrij alleen verzoeken waarvan het model nog niet is geladen, of opnieuw moet worden geladen met andere instellingen. Als het model al in het geheugen staat wanneer u de bovenstaande lus uitvoert, verwacht dan dat elk verzoek 200 teruggeeft, ongeacht hoe laag u OLLAMA_MAX_QUEUE instelt. De overloop uit zich in plaats daarvan als een langere ttfb.
Eén eerlijke beperking: Ollama publiceert geen wachtrijdiepte. ollama ps en het /api/ps-eindpunt rapporteren de modellen die geladen zijn, niet de verzoeken die in de wachtrij staan. U meet de wachtrij dus vanaf de clientzijde door de tijd tot de eerste byte te monitoren, of u telt de 503-antwoorden bij de component die voor de service is geplaatst.
Waarom een kleinere MAX_QUEUE vaak de betere instelling is
Een wachtrij van 512 klinkt ruim, maar op een enkele slot is het nagenoeg nutteloos. Verzoek 300 wacht achter 299 voltooide generaties. Dat duurt in het beste geval minuten. Elke HTTP-client geeft het al lang daarvoor op, waardoor de aanroeper een client-side timeout ziet. Dit vertelt niets over de oorzaak en geeft uw monitoring geen aanleiding voor een waarschuwing.
Een kleinere wachtrij zet die overloop om in een onmiddellijke 503, maar alleen voor verzoeken die wachten tot een model is geladen of opnieuw is geladen, zoals de piek die ontstaat na een herstart of tijdens het wisselen van modellen. Sinds oktober 2026 omzeilen verzoeken aan een model dat al geladen is OLLAMA_MAX_QUEUE en wachten ze zonder limiet op een vrij slot. Het verlagen van de wachtrij verkort daarom de wachttijd op een drukke server met één resident model niet. Om daar een snelle weigering te krijgen, moet u de concurrency vóór Ollama beperken, zoals de volgende sectie beschrijft. Een 503 is nuttig: een reverse proxy kan het verzoek opnieuw proberen, een client kan wachten (back-off), een dashboard kan het tellen en een beheerder kan het aflezen. Bepaal de limiet op basis van uw eigen metingen. Als een generatie ongeveer tien seconden duurt en uw client zestig seconden wacht, kunnen er binnen dat venster ongeveer zes verzoeken per slot worden afgehandeld. Meer verzoeken laten wachten levert dan alleen timeouts op.
Wanneer plaatst u een wachtrij voor Ollama
De ingebouwde wachtrij werkt volgens het first-in, first-out (FIFO) principe en heeft geen inzicht in de herkomst van de aanvragen. Voor één applicatie die met één server communiceert, is dit voldoende; het toevoegen van extra infrastructuur introduceert in dat geval alleen maar extra storingspunten. Overweeg een wachtrij voor Ollama wanneer een van de volgende situaties van toepassing is:
- U heeft prioriteit nodig. Een interactieve chat mag niet wachten op een batch-samenvattingstaak. De wachtrij van Ollama ondersteunt geen prioriteiten, dus batchtaken moeten extern worden vastgehouden en gedoseerd worden aangeboden.
- U heeft behoefte aan eerlijke verdeling (fairness). Eén client kan alle beschikbare slots bezetten en een rij wachtende aanvragen achter zich opbouwen. Andere gebruikers moeten dan wachten of ontvangen een 503-foutmelding als hun aanvraag vereist dat er een model wordt geladen.
- U heeft een begrensde wachttijd nodig. Ollama houdt aanvragen voor een reeds geladen model voor onbepaalde tijd vast; de enige betrouwbare limiet is daarom een limiet die u er vóór plaatst.
- U wilt dat taken een herstart overleven. De wachtrij bevindt zich in het geheugen van de server. Als u Ollama herstart, gaan alle wachtende aanvragen verloren.
- U heeft behoefte aan echte retries met backoff, die ergens worden vastgelegd zodat u ze achteraf kunt controleren.
De lichte variant is een reverse proxy. In nginx beperken limit_conn het aantal gelijktijdige verbindingen en limit_req de aankomstfrequentie per client, waardoor overloop bij de proxy wordt geweigerd en Ollama nooit bereikt. De zware variant is een taakwachtrij met een database voor een worker die Ollama aanroept; dit is de gewenste oplossing wanneer aanvragen een herstart van het proces moeten overleven. Het dimensioneren hiervan voor daadwerkelijk verkeer is een opgave op zich: het plannen van een zelf-gehoste LLM voor gelijktijdige gebruikers doorloopt de berekeningen, en het draaien van Ollama op een VPS behandelt de basisinstallatie waar deze variabelen van uitgaan.
Wanneer het eerlijke antwoord een andere server is
Er is een grens die u niet kunt verleggen door configuratie. Ollama splitst de KV-cache in gelijke, vaste slots wanneer het model wordt geladen. Het geheugen van een inactief slot kan niet worden gebruikt door een actief slot, en het aantal slots kan niet worden gewijzigd zonder het model te ontladen. Dat ontwerp is zeer geschikt voor één persoon, een klein team of een coding agent.
Servers die zijn gebouwd voor veel gelijktijdige gebruikers werken anders. Zij wijzen KV-cache toe in kleine pagina's op aanvraag en voegen binnenkomende verzoeken toe aan een batch die al draait, waardoor het geheugen de werkelijke vraag volgt in plaats van een vaste verdeling. Als uw doel een groot aantal gelijktijdige gebruikers op één GPU is, is dat architecturale verschil belangrijker dan welke waarde van OLLAMA_NUM_PARALLEL dan ook. De vergelijking tussen Ollama en vLLM is de plek om die beslissing te nemen. Stap echter niet uit principe over: een andere server betekent meer beheer, en als uw verkeer uit enkele personen bestaat, is het ingebouwde gedrag het juiste antwoord. Als de werkelijke vraag is of u überhaupt zelf een modelserver moet draaien, helpt het vergelijken van een private AI-server op basis van een offerte met het bouwen van dezelfde stack op een gehuurde GPU u door die beslissing heen, inclusief wanneer een API de betere keuze is.
Meet uw eigen doorvoer en tijd tot het eerste token
Gepubliceerde cijfers over tokens per seconde zijn afkomstig van de GPU, het model, de kwantisatie, de contextlengte en de prompt van iemand anders. Niets daarvan komt overeen met uw situatie. Beschouw elk getal dat u leest daarom slechts als een ruwe indicatie en meet de machine die voor u staat.
Ollama retourneert timinggegevens in het laatste JSON-object van elk antwoord. eval_count is het aantal gegenereerde tokens en eval_duration is de tijd die aan het genereren is besteed, in nanoseconden.
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))}'Voer dit uit met één slot en daarna opnieuw met de gelijktijdigheid die u daadwerkelijk verwacht. Vergelijk de twee getallen die bepalen of gebruikers tevreden zijn: de tijd tot het eerste token en het aantal tokens per seconde per verzoek. De doorvoer per verzoek daalt altijd naarmate er meer slots worden toegevoegd. De vraag is of deze verder daalt dan uw gebruikers accepteren. Tokens per seconde meten op een lokale LLM behandelt de methode in meer detail, inclusief hoe u de prompt constant houdt tussen verschillende runs.
Een openbaar eindpunt met een ruime wachtrij is een doelwit voor denial-of-service
Het instellen van OLLAMA_HOST=0.0.0.0:11434 plaatst de API op elke interface, en Ollama beschikt niet over ingebouwde authenticatie. Met de standaard wachtrij accepteert een open eindpunt tot 512 verzoeken die wachten op het laden van een model, afkomstig van iedereen die het eindpunt vindt. Voor een model dat al geladen is, houdt het elk verbindend verzoek vast, zonder limiet, zolang de client verbonden blijft. Het op deze manier bezet houden van de server kost een aanvaller vrijwel niets: lange prompts, geen inloggegevens, geen rate limiting, geen kosten. Uw eigen gebruikers krijgen vervolgens 503-foutmeldingen of lange wachttijden, terwijl de machine continu belast is.
Houd de listener op loopback en bereik deze via een SSH-tunnel of een privénetwerk, of plaats authenticatie en rate limiting voor de service. Het beveiligen van een Ollama API-eindpunt behandelt beide opties. Pas de wachtrij pas aan nadat dit is geregeld, aangezien een wachtrijlengte een capaciteitsinstelling is en geen enkele vorm van beveiliging biedt.
FAQ
Waarom wacht mijn tweede Ollama-verzoek totdat het eerste is voltooid?
Omdat OLLAMA_NUM_PARALLEL standaard op 1 staat. Een geladen model verwerkt daardoor één verzoek tegelijk en de overige verzoeken wachten in volgorde. Het wachtende verzoek houdt de HTTP-verbinding open en verzendt geen bytes totdat er een slot vrijkomt. Aan de kant van de client lijkt dit hetzelfde als een traag model. Let op het tijdspatroon: een lange pauze gevolgd door tekst op volle snelheid wijst op een wachtrij. Een trage stroom vanaf het eerste token wijst op een traag model. Verhoog het aantal slots met een systemd drop-in en start de service opnieuw. Controleer daarna de waarde van -np op de runner-regel, omdat embeddingmodellen in de scheduler nog steeds één slot krijgen.
Wat betekent "server busy, please try again. maximum pending requests exceeded"?
Dit is de foutmelding van Ollama wanneer de wachtrij overloopt. Ollama retourneert deze melding met HTTP-status 503. Het aantal verzoeken dat op planning wacht, dus wacht totdat het model is geladen of opnieuw is geladen, heeft OLLAMA_MAX_QUEUE bereikt. Deze waarde is standaard 512. Daarom is het nieuwste verzoek geweigerd in plaats van toegevoegd. Verzoeken aan een model dat al is geladen, tellen niet mee voor deze limiet. U ziet deze fout meestal tijdens pieken bij het opstarten of terwijl modellen worden verwisseld. Het is geen geheugenfout en ook geen modelfout. Als u de wachtrij vergroot, wachten aanroepers alleen langer voordat dezelfde afwijzing volgt. De echte oplossingen zijn meer slots als u daarvoor voldoende VRAM hebt, minder inkomende belasting of een wachtrij ervoor die opnieuw kan proberen en prioriteiten kan toepassen.
Maakt het verhogen van OLLAMA_NUM_PARALLEL Ollama sneller?
Nee. Hierdoor kunnen meer verzoeken tegelijk worden uitgevoerd. Elk verzoek is daardoor trager dan wanneer het afzonderlijk wordt uitgevoerd, omdat de verzoeken één GPU delen. Ook wordt de KV-cache groter. Ollama start de runner namelijk met een totale context die gelijk is aan uw contextlengte vermenigvuldigd met het aantal slots. Als het resultaat niet meer in VRAM past, verplaatst Ollama lagen naar de CPU. Daardoor wordt elk verzoek trager, ook één verzoek zonder concurrentie. Controleer ollama ps na de wijziging en bevestig dat de kolom PROCESSOR nog steeds 100% GPU bevat.
Moet ik Ollama opnieuw starten nadat ik deze variabelen heb gewijzigd?
Ja. De server leest deze variabelen bij het opstarten. Een actief model behoudt het aantal slots dat bij het starten in het runner-proces is vastgelegd. Bewerk de drop-in met sudo systemctl edit ollama.service en voer daarna sudo systemctl daemon-reload en sudo systemctl restart ollama uit. Bevestig de wijziging met systemctl show ollama --property=Environment. Controleer vervolgens de regel server config in journalctl -u ollama. Daar staan de geconfigureerde omgevingswaarden die Ollama rapporteert.
Hoeveel parallelle slots moet ik instellen?
Begin met 1 en verhoog de waarde telkens met één stap. Start Ollama na elke stap opnieuw, verstuur één verzoek om het model te laden en voer ollama ps uit. Stop bij de laatste waarde waarbij PROCESSOR nog steeds 100% GPU bevat en de kolom SIZE voldoende ruimte overlaat voor de langste context die u aanbiedt. Meet vervolgens bij die instelling, onder uw werkelijke gelijktijdige belasting, de tijd tot het eerste token en het aantal tokens per seconde. Verlaag de waarde met één stap als de snelheid per verzoek lager is geworden dan uw gebruikers acceptabel vinden.