SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

Ollama में NUM_PARALLEL और MAX_QUEUE कैसे काम करते हैं

दूसरी request क्यों प्रतीक्षा करती है या HTTP 503 पाती है? OLLAMA_NUM_PARALLEL और OLLAMA_MAX_QUEUE के साथ हर parallel slot की memory लागत समझें।

पहली request generate होने के दौरान दूसरी Ollama request के साथ क्या होता है

Ollama में concurrency का निर्णय तीन environment variables से होता है। डिफ़ॉल्ट रूप से, एक loaded model एक समय में एक request serve करता है। दूसरी request अस्वीकार नहीं होती और उसे partial answer भी नहीं मिलता। वह queue में तब तक प्रतीक्षा करती है, जब तक कोई slot खाली न हो जाए। इसके बाद वह normal speed पर चलती है।

आने वाली request के तीन संभावित परिणाम होते हैं। वह free slot में तुरंत शुरू हो जाती है। वह queue में प्रतीक्षा करती है। या queue पहले से full होती है और server उसे HTTP 503 के साथ अस्वीकार कर देता है। इनमें से कौन-सा परिणाम होगा, यह OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE और OLLAMA_MAX_LOADED_MODELS से तय होता है। Current releases में October 2026 तक एक महत्वपूर्ण बात है। FAQ queue का सामान्य विवरण देता है, लेकिन scheduler का source code अधिक स्पष्ट है। 503 केवल उन requests पर लागू होता है जो उस समय आती हैं जब उनका model अभी load होना बाकी हो, या अलग settings के साथ reload होना हो। पहले से loaded model जिस request को मौजूदा स्थिति में serve कर सकता है, Ollama उसे अस्वीकार नहीं करता। वह request slot मिलने तक जितनी देर आवश्यक हो, प्रतीक्षा करती है।

डिफ़ॉल्ट सुरक्षित है। यही कारण है कि कुछ न बिगड़ने पर भी दूसरा user server के "hung" होने की शिकायत कर सकता है। Slots जोड़ने के लिए दो lines बदलनी होती हैं। समस्या memory की होती है। प्रत्येक parallel slot को अपना key/value cache (KV cache) चाहिए। यह memory का वह block है जिसमें model पहले से process किए गए tokens रखता है। VRAM (GPU की video memory) बढ़ाए बिना slots जोड़ने पर धीमा answer failed load में बदल सकता है। केवल CPU वाले server पर यही cache system RAM से लिया जाता है।

OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE और OLLAMA_MAX_LOADED_MODELS क्या नियंत्रित करते हैं

अक्टूबर 2026 तक के वर्तमान Ollama releases में ये defaults हैं। यहां दिए गए number पर भरोसा करने के बजाय नीचे दिखाए गए log line से अपने values जाँचें।

  • OLLAMA_NUM_PARALLEL यह बताता है कि एक loaded model एक ही समय में कितनी requests संभालता है। Default 1 है, इसलिए requests एक-एक करके serve होती हैं।
  • OLLAMA_MAX_LOADED_MODELS यह बताता है कि एक ही समय में कितने अलग-अलग models resident रहते हैं। Default 0 है, जिसका अर्थ है कि Ollama स्वयं चुनता है: प्रत्येक GPU के लिए तीन models और GPU के बिना machine पर तीन models।
  • OLLAMA_MAX_QUEUE FAQ के अनुसार, यह busy होने पर additional requests को reject करने से पहले Ollama द्वारा queue की जाने वाली requests की maximum संख्या है। Default 512 है। Queue full होने पर आने वाली request तुरंत reject कर दी जाती है। हालांकि, वर्तमान scheduler code में केवल वे requests इस queue में जाती हैं जिनके model को पहले load या reload करना पड़ता है। जो model पहले से loaded है, उसकी requests इस queue को छोड़कर free slot का इंतजार करती हैं, और उस इंतजार की कोई limit नहीं है। Maintainer ने इसे scheduler के implementation के तरीके का side effect बताया है। Ollama के maintainers इस fix को feature request के रूप में track कर रहे हैं (issue #7758), जो अक्टूबर 2026 में भी open थी।

Worst-case memory पहले दो values का product होती है। चार slots वाले दो loaded models का अर्थ है KV cache के आठ slot allocations, जो एक साथ resident रहते हैं, और Ollama इन्हें पूरा करने का प्रयास करेगा। Single GPU box पर आम तौर पर एक model को hold करके उसे अधिक slots देना बेहतर होता है, क्योंकि इसका arithmetic आप आसानी से स्वयं कर सकते हैं।

हर parallel slot की लागत VRAM में क्यों आती है

जब Ollama कोई model load करता है, तो वह एक अलग runner process शुरू करता है। इसके पास भेजे जाने वाले दो arguments यहां महत्वपूर्ण हैं: -c वह कुल context है जिसके लिए runner KV cache allocate करता है, और -np parallel sequences की संख्या है। Ollama -c को आपके per-request context length और slot count के गुणनफल पर सेट करता है। इसके बाद runner उस कुल राशि को slots के बीच समान रूप से बांटता है, इसलिए प्रत्येक request को वही context length मिलती है जो आपने मांगी थी।

यही पूरी constraint है और इसी कारण parallelism मुफ्त नहीं होता। समान per-request context पर एक slot से चार slots करने पर KV cache की जरूरत चार गुना हो जाती है। Slots के बीच कुछ भी share नहीं होता। किसी idle slot का हिस्सा busy slot को नहीं दिया जाता, क्योंकि runner शुरू होते समय यह विभाजन fixed हो जाता है। GPU पर यह memory VRAM होती है। केवल CPU वाले server पर यह system RAM होती है और यही multiplication लागू होता है।

आप उन वास्तविक numbers को देख सकते हैं जिन्हें आपने set करने का इरादा रखा था:

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

इस line में पूरी runner command line होती है, जिसमें -c और -np शामिल हैं। Variable set करने के बाद यदि -np 1 है, तो पहले model type जांचें। Ollama v0.40.15 ने recurrent और vision GGUF models के लिए parallel requests जोड़ीं, इसलिए उन models पर पहले लागू one-slot restriction अब लागू नहीं होती। Embedding models को scheduler में अभी भी one slot मिलता है। GGUF completion model के लिए जांचें कि setting server तक पहुंच रही है, जैसा कि अगला section समझाता है।

यदि model weights और वह KV cache VRAM में fit नहीं होते, तो Ollama कुछ layers को system RAM में ले जाता है और वे layers CPU पर चलती हैं। CPU layers, GPU layers की तुलना में काफी धीमी होती हैं। इसलिए आपके द्वारा शुरू की गई single request सहित हर request धीमी हो जाती है। इस कारण parallelism बढ़ाने से throughput बढ़ने के बजाय घट सकता है। पर्याप्त बड़े model में किसी भी slot arithmetic से पहले ही weights यह तय कर देते हैं कि model fit होगा या नहीं। इसी वजह से Kimi K3 के आकार की किसी चीज़ को self-host करने की चर्चा आपके द्वारा set किए गए slots की संख्या के बजाय आपके पास मौजूद cards की संख्या पर होती है।

ollama ps

पूरी चीज़ fit होने पर PROCESSOR column में 100% GPU दिखता है। 35%/65% CPU/GPU जैसा split बताता है कि model का कुछ हिस्सा CPU पर चल रहा है। SIZE column में KV cache भी शामिल होता है, इसलिए slot count बढ़ाने और model reload करने पर यह बढ़ता है। OLLAMA_NUM_PARALLEL बढ़ाएँ, restart करें, एक request भेजें और फिर ollama ps चलाएँ। इससे आपके बदलाव की memory cost अनुमान के बजाय measurement के रूप में मिलेगी। यदि measurement बताती है कि model अब fit नहीं होता, तो याद रखें कि weights इसी budget का दूसरा आधा हिस्सा हैं। fp16 से q8 या q4 build पर जाना अक्सर उस slot की लागत से अधिक VRAM खाली करता है जिसे आप जोड़ना चाहते थे।

Context length और slot count का गुणन होता है, इसलिए इन्हें साथ में चुनना पड़ता है। चार slots वाला बड़ा context, चार बड़े contexts के बराबर है। यदि आप अपने model के लिए num_ctx context window को भी tune कर रहे हैं, तो एक समय में इन दोनों में से केवल एक बदलें। अन्यथा आपको पता नहीं चलेगा कि card किस setting से भर गया।

रिबूट के बाद ये variables कैसे बनाए रखें

Linux पर Ollama एक systemd service के रूप में चलता है। अपने shell में export OLLAMA_NUM_PARALLEL=4 चलाने से कुछ नहीं बदलता, क्योंकि systemd service को अपने environment के साथ शुरू करता है और आपके shell को कभी नहीं देखता। इसके लिए drop-in file का उपयोग करें।

sudo systemctl edit ollama.service

खुलने वाले editor में यह जोड़ें:

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

इसके बाद reload और restart करें:

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

systemctl show दिखाता है कि systemd process को कौन-से variables देगा। यदि वहां आपका variable नहीं है, तो drop-in save नहीं हुआ है या daemon-reload नहीं चलाया गया। Server की अपनी तरफ से भी पुष्टि करें:

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

Ollama startup के समय अपनी server configuration को उस line पर log करता है जिसका message server config है। उस map में Ollama द्वारा report किए गए configured environment values दिखते हैं। यह पुष्टि करने का सबसे तेज तरीका है कि variable प्रभावी हुआ या नहीं। इसमें आपके द्वारा set किया गया value दिखता है, न कि किसी particular model को वास्तव में मिले slots की संख्या। उसके लिए ऊपर वाली runner line में -np value पढ़ें।

जो model पहले से loaded है, वह उसी slot count को बनाए रखता है जिसके साथ उसे start किया गया था, क्योंकि यह value launch के समय runner process में fixed हो जाती है। ऊपर किया गया restart सब कुछ unload कर देता है। इसलिए अगली request model को नई setting के साथ reload करती है और load time केवल एक बार लगता है। इसके बाद model कितनी देर resident रहता है, यह अलग control है। इसकी जानकारी requests के बीच Ollama model को loaded रखना में दी गई है।

क्लाइंट की ओर से served, queued और refused स्थितियाँ कैसी दिखती हैं

एक साथ कई requests भेजें और उनका समय मापें। यह parallel में आठ streaming requests चलाता है और प्रत्येक का status तथा timing दिखाता है:

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 stream के पहले byte तक का समय है। यह first token तक के समय (TTFT) के करीब होता है, क्योंकि stream का पहला chunk पहला token लेकर आता है।

Parallel में served। प्रत्येक request लगभग समान ttfb report करती है और सभी के लिए total एक साथ बढ़ता है। चल रहे slots के बीच GPU साझा होता है। इसलिए प्रत्येक answer अकेले चलने की तुलना में धीमा होता है, लेकिन प्रति minute अधिक answers पूरे होते हैं। OLLAMA_NUM_PARALLEL बढ़ाने पर आपको यही व्यवहार मिलता है।

Queued। शुरुआती requests जल्दी answer देती हैं। बाद वाली requests में पहले बड़ा ttfb दिखता है और उसके बाद generation सामान्य गति से होती है। यह प्रतीक्षा queue की है, model की नहीं। Chat window देखने वाले user को पहले लंबे समय तक खाली स्क्रीन दिखती है और फिर text पूरी speed से आने लगता है। पहले धीमा और फिर तेज़ होना overloaded GPU के बजाय queue का संकेत है।

Refused। Client को लगभग तुरंत http=503 मिलता है और body यह होती है:

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

इस message का अर्थ है कि request आने के समय scheduling queue पूरी भरी हुई थी। इससे VRAM या model के बारे में कोई जानकारी नहीं मिलती। वर्तमान releases में यह queue केवल उन requests को रखती है जिनका model अभी load नहीं हुआ है या जिन्हें अलग settings के साथ फिर से load करना है। यदि ऊपर दिया गया loop चलाते समय model पहले से resident है, तो OLLAMA_MAX_QUEUE को कितना भी कम सेट करने पर प्रत्येक request से 200 मिलने की अपेक्षा रखें। Overflow इसके बजाय लंबे ttfb के रूप में दिखाई देगा।

एक स्पष्ट सीमा है: Ollama queue depth प्रकाशित नहीं करता। ollama ps और /api/ps endpoint उन models की report करते हैं जो load हैं, waiting requests की नहीं। इसलिए queue को client side से मापें: first byte तक का समय monitor करें या सामने मौजूद component पर 503 responses गिनें।

छोटा MAX_QUEUE अक्सर बेहतर setting क्यों होता है

512 की queue पर्याप्त बड़ी लगती है, लेकिन single slot पर यह लगभग बेकार होती है। Request 300 को 299 पूरी हो चुकी generations के पीछे प्रतीक्षा करनी पड़ती है। इसमें कम से कम कई मिनट लगते हैं। हर HTTP client इससे बहुत पहले हार मान लेता है। इसलिए caller को client side timeout दिखाई देता है। इससे उन्हें कारण का पता नहीं चलता और आपके monitoring system को alert करने के लिए कुछ नहीं मिलता।

छोटी queue इस overflow को तुरंत 503 में बदल देती है। यह केवल उन requests पर लागू होता है जो model के load या reload होने की प्रतीक्षा कर रही हों, जैसे restart के बाद आने वाला burst या models swap किए जा रहे हों। October 2026 तक, जो requests पहले से loaded model के लिए होती हैं वे OLLAMA_MAX_QUEUE को bypass करती हैं और किसी free slot के लिए बिना किसी limit के प्रतीक्षा करती हैं। इसलिए queue कम करने से one resident model वाले busy server पर प्रतीक्षा का समय कम नहीं होगा। वहाँ fast refusal पाने के लिए Ollama के सामने concurrency cap करें, जैसा कि अगला section बताता है। 503 उपयोगी है: reverse proxy इसे retry कर सकता है, client back off कर सकता है, dashboard इसकी गिनती कर सकता है और व्यक्ति इसे पढ़ सकता है। यह cap अपनी measurements के आधार पर तय करें। यदि एक generation में लगभग ten seconds लगते हैं और आपका client sixty seconds तक प्रतीक्षा करता है, तो उस window में प्रति slot लगभग six requests पूरी हो सकती हैं। इससे अधिक requests को प्रतीक्षा करने देना केवल timeouts उत्पन्न करता है।

Ollama के सामने queue कब रखें

Built-in queue first in, first out (FIFO) होती है और उसे यह जानकारी नहीं होती कि request कौन भेज रहा है। एक application के एक server से बात करने के लिए यह पर्याप्त है। Infrastructure जोड़ने से केवल failure modes बढ़ेंगे। निम्न में से कोई स्थिति हो, तभी सामने कुछ जोड़ें।

  • आपको priority चाहिए। Interactive chat को batch summarisation job के पीछे इंतजार नहीं करना चाहिए। Ollama की queue में priority नहीं होती, इसलिए batch work को बाहर रोककर धीरे-धीरे भेजना पड़ता है।
  • आपको fairness चाहिए। एक client सभी slots घेर सकता है और अपने requests की लंबी waiting queue बना सकता है। इसके बाद बाकी सभी requests उसी client के पीछे इंतजार करते हैं, या यदि उनके request के लिए कोई model load करना पड़े तो उन्हें 503 मिलता है।
  • आपको bounded wait चाहिए। Ollama ऐसे model के लिए requests को अनिश्चित समय तक रोक सकता है जो पहले से loaded है। इसलिए विश्वसनीय limit वही होगी जो आप सामने लगाएँगे।
  • आपको work को restart के बाद भी सुरक्षित रखना है। Queue server की memory में रहती है। Ollama को restart करने पर सभी waiting requests समाप्त हो जाती हैं।
  • आपको वास्तविक retries और backoff चाहिए, जिन्हें बाद में जाँचने के लिए कहीं record किया जा सके।

हल्का विकल्प reverse proxy है। nginx में limit_conn simultaneous connections की सीमा लगाता है और limit_req प्रत्येक client की arrival rate सीमित करता है। इसलिए अतिरिक्त requests proxy पर ही refuse हो जाती हैं और Ollama तक नहीं पहुँचतीं। भारी विकल्प यह है कि database वाला job queue उस worker के सामने रखें जो Ollama को call करता है। जब requests को process restart के बाद भी जारी रहना हो, तब यही चाहिए। वास्तविक traffic के लिए इसका sizing अलग exercise है: एक साथ कई users के लिए self hosted LLM की planning में arithmetic समझाया गया है, और VPS पर Ollama चलाना में उन variables के लिए आवश्यक base install बताया गया है।

ईमानदार उत्तर एक अलग server हो सकता है

एक सीमा है, जिसे आप tuning से पार नहीं कर सकते। Model load होने पर Ollama KV cache को समान आकार वाले fixed slots में विभाजित करता है। Idle slot की memory का उपयोग busy slot नहीं कर सकता, और model unload किए बिना slots की संख्या बदली नहीं जा सकती। यह design एक व्यक्ति, छोटी team या coding agent के लिए उपयुक्त है।

कई simultaneous users के लिए बनाए गए servers अलग तरीके से काम करते हैं। वे आवश्यकता के अनुसार छोटे pages में KV cache allocate करते हैं और आने वाली requests को पहले से चल रहे batch में जोड़ते हैं। इसलिए memory fixed division के बजाय वास्तविक demand के अनुसार उपयोग होती है। यदि आपका लक्ष्य एक GPU पर बड़ी संख्या में concurrent users चलाना है, तो यह architectural अंतर OLLAMA_NUM_PARALLEL की किसी भी value से अधिक महत्वपूर्ण है। Ollama और vLLM की तुलना में यह निर्णय लेने का तरीका बताया गया है। फिर भी केवल सिद्धांत के आधार पर switch न करें। अलग server को operate करना अधिक कठिन होता है, और यदि आपका traffic कुछ लोगों तक सीमित है, तो built-in behaviour ही सही विकल्प है। यदि वास्तविक प्रश्न यह है कि model server स्वयं चलाना भी चाहिए या नहीं, तो केवल quote देने वाले private AI server की तुलना rented GPU पर वही stack बनाने से इस निर्णय के विभिन्न पहलुओं को समझाता है। इसमें यह भी बताया गया है कि API खरीदना कब बेहतर विकल्प होता है।

अपने थ्रूपुट और 'टाइम टू फर्स्ट टोकन' को मापें

टोकन प्रति सेकंड (tokens per second) के प्रकाशित आंकड़े किसी और के GPU, मॉडल, क्वांटाइजेशन, कॉन्टेक्स्ट लेंथ और प्रॉम्प्ट पर आधारित होते हैं। इनमें से कोई भी आपके सेटअप से मेल नहीं खाता, इसलिए किसी भी आंकड़े को केवल एक अनुमान मानें और अपने सामने मौजूद मशीन पर स्वयं मापें।

Ollama हर रिस्पॉन्स के अंतिम JSON ऑब्जेक्ट में टाइमिंग की जानकारी देता है। eval_count उत्पन्न किए गए टोकन की संख्या है और eval_duration उन्हें उत्पन्न करने में लगा समय है, जो नैनोसेकंड में होता है।

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))}'

इसे एक स्लॉट के साथ चलाएं, फिर उस कॉन्करेंसी (concurrency) पर दोबारा चलाएं जिसकी आप वास्तव में अपेक्षा करते हैं। इसके बाद उन दो आंकड़ों की तुलना करें जो यह तय करते हैं कि उपयोगकर्ता संतुष्ट हैं या नहीं: 'टाइम टू फर्स्ट टोकन' और प्रति रिक्वेस्ट 'टोकन प्रति सेकंड'। जैसे-जैसे स्लॉट बढ़ाए जाते हैं, प्रति रिक्वेस्ट थ्रूपुट हमेशा गिरता है। मुख्य प्रश्न यह है कि क्या यह गिरावट उस स्तर से अधिक है जिसे आपके उपयोगकर्ता स्वीकार करेंगे। लोकल LLM पर टोकन प्रति सेकंड मापना इस विधि को अधिक विस्तार से कवर करता है, जिसमें यह भी शामिल है कि रन के बीच प्रॉम्प्ट को स्थिर कैसे रखा जाए।

एक उदार कतार (queue) वाला सार्वजनिक एंडपॉइंट डिनायल ऑफ सर्विस (DoS) का लक्ष्य होता है

OLLAMA_HOST=0.0.0.0:11434 सेट करने से API हर इंटरफ़ेस पर उपलब्ध हो जाता है, और लोकल API के लिए किसी प्रमाणीकरण (authentication) की आवश्यकता नहीं होती। Ollama में क्लाउड मॉडल, पब्लिशिंग और प्राइवेट डाउनलोड के लिए इन-बिल्ट साइन-इन सुविधा है। https://ollama.com/api और https://ollama.com/v1 पर सीधे क्लाउड इन्फरेंस के लिए एक API key की आवश्यकता होती है। डिफ़ॉल्ट कतार के साथ, एक खुला एंडपॉइंट किसी भी व्यक्ति से 512 अनुरोधों तक स्वीकार करेगा जो मॉडल के लोड होने की प्रतीक्षा कर रहे हैं। जो मॉडल पहले से लोड है, उसके लिए यह कनेक्ट होने वाले प्रत्येक अनुरोध को बिना किसी सीमा के तब तक रोके रखेगा जब तक क्लाइंट कनेक्टेड रहता है। इस तरह सर्वर को व्यस्त रखने में हमलावर का लगभग कुछ भी खर्च नहीं होता: लंबे प्रॉम्प्ट, कोई लॉगिन नहीं, कोई रेट लिमिट नहीं, और कोई बिल नहीं। इसके बाद आपके अपने उपयोगकर्ताओं को 503 रिस्पॉन्स मिलते हैं या लंबा इंतजार करना पड़ता है, और मशीन हर समय व्यस्त रहती है।

लिसनर को लूपबैक पर रखें और SSH टनल या प्राइवेट नेटवर्क के माध्यम से उस तक पहुँचें, या इसके सामने प्रमाणीकरण और रेट लिमिटिंग लगाएँ। Ollama API एंडपॉइंट को सुरक्षित करना इन दोनों को कवर करता है। यह सब पूरा होने के बाद कतार को ट्यून करें, क्योंकि कतार की लंबाई एक क्षमता सेटिंग है, और यह किसी भी चीज़ की सुरक्षा नहीं करती है।

FAQ

मेरे दूसरे Ollama अनुरोध को पहले अनुरोध के पूरा होने तक प्रतीक्षा क्यों करनी पड़ती है?

क्योंकि OLLAMA_NUM_PARALLEL का डिफ़ॉल्ट मान 1 है। इसलिए लोड किया गया model एक समय में एक अनुरोध चलाता है और बाकी अनुरोध क्रम से प्रतीक्षा करते हैं। प्रतीक्षा कर रहा अनुरोध अपना HTTP connection खुला रखता है और slot उपलब्ध होने तक कोई byte नहीं भेजता। Client की ओर से यह धीमे model जैसा दिखाई देता है। समय के स्वरूप से अंतर पता चलता है: लंबा विराम और उसके बाद पूरी गति से text आना queue का संकेत है। पहले token से ही धीमे-धीमे text आना धीमे model का संकेत है। systemd drop-in से slot की संख्या बढ़ाएँ और service restart करें। इसके बाद runner line में -np का मान जाँचें, क्योंकि embedding models को scheduler में अब भी एक ही slot मिलता है।

"server busy, please try again. maximum pending requests exceeded" का क्या अर्थ है?

यह Ollama की queue overflow error है, जो HTTP status 503 के साथ लौटती है। schedule किए जाने की प्रतीक्षा कर रहे अनुरोधों की संख्या, यानी वे अनुरोध जो अपने model के load या reload होने की प्रतीक्षा कर रहे हैं, OLLAMA_MAX_QUEUE तक पहुँच गई। इसका डिफ़ॉल्ट मान 512 है। इसलिए सबसे नए अनुरोध को queue में जोड़ने के बजाय अस्वीकार कर दिया गया। जो अनुरोध पहले से loaded model को भेजे जाते हैं, वे इस सीमा में शामिल नहीं होते। यह error आम तौर पर startup के दौरान अचानक बढ़े load या models बदलते समय दिखाई देती है। यह memory error नहीं है और model error भी नहीं है। Queue बढ़ाने से callers को उसी rejection से पहले अधिक समय तक प्रतीक्षा करनी पड़ेगी। इसलिए वास्तविक समाधान अधिक slots देना है, यदि आपके पास उनके लिए पर्याप्त VRAM हो; incoming load घटाना है; या सामने ऐसी queue रखना है जो retry और prioritise कर सके।

क्या OLLAMA_NUM_PARALLEL बढ़ाने से Ollama तेज हो जाता है?

नहीं। इससे एक ही समय में अधिक अनुरोध चल सकते हैं। लेकिन इनमें से प्रत्येक अनुरोध अकेले चलने की तुलना में धीमा होगा, क्योंकि वे एक ही GPU साझा करते हैं। इससे KV cache भी कई गुना बढ़ जाता है, क्योंकि Ollama runner को context length और slot count के गुणनफल के बराबर कुल context के साथ शुरू करता है। यदि परिणाम VRAM में फिट नहीं होता, तो Ollama layers को CPU पर भेज देता है। इससे सभी अनुरोध धीमे हो जाते हैं, जिसमें बिना किसी competition वाला एकल अनुरोध भी शामिल है। बदलाव के बाद ollama ps जाँचें और पुष्टि करें कि PROCESSOR column में अब भी 100% GPU लिखा है।

इन variables को बदलने के बाद क्या मुझे Ollama restart करना होगा?

हाँ। Server startup के समय इन variables को पढ़ता है। Running model वही slot count रखता है, जो उसके शुरू होने पर runner process में निर्धारित हुआ था। sudo systemctl edit ollama.service से drop-in edit करें। फिर sudo systemctl daemon-reload और sudo systemctl restart ollama चलाएँ। systemctl show ollama --property=Environment से पुष्टि करें। इसके बाद journalctl -u ollama में server config line जाँचें। इसमें Ollama द्वारा report किए गए configured environment values की सूची होती है।

मुझे कितने parallel slots सेट करने चाहिए?

1 से शुरू करें और slot count को एक-एक करके बढ़ाएँ। प्रत्येक बदलाव के बाद Ollama restart करें, model load करने के लिए एक अनुरोध भेजें और ollama ps चलाएँ। उस अंतिम value पर रुकें, जहाँ PROCESSOR अब भी 100% GPU पढ़ता हो और SIZE column आपके द्वारा serve किए जाने वाले सबसे लंबे context के लिए पर्याप्त headroom छोड़ता हो। इसके बाद अपनी वास्तविक concurrency के साथ उस setting पर time to first token और tokens per second मापें। यदि प्रति अनुरोध speed आपके users की स्वीकार्य सीमा से कम हो गई है, तो एक step पीछे जाएँ।

क्या यह लेख उपयोगी था?

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