Ollama मध्ये num_ctx सेट करून लांब prompt वाचवा
Ollama लांब prompt शांतपणे कापते. प्रत्येक request मध्ये किंवा server-wide num_ctx सेट करा आणि वाढवण्यापूर्वी KV cache साठी लागणारी RAM तपासा.
num_ctx काय करते आणि तुमचा लांब prompt का कापला गेला
Ollama context length म्हणजे एकावेळी memory मध्ये loaded model किती tokens ठेवू शकतो ते. num_ctx हा पर्याय ही मर्यादा सेट करतो. Ollama model ने जाहीर केलेल्या कमाल मर्यादेपेक्षा खूप कमी default निवडते. त्यामुळे model तो वाचण्यापूर्वीच लांब prompt कापला जातो. असे घडल्याचे response मध्ये कोणतेही संकेत मिळत नाहीत.
Ollama model library मध्ये Llama 3.1 8B साठी 128k context window दिली आहे. Stock server तुम्हाला ही पूर्ण मर्यादा देणार नाही. Ollama च्या अधिकृत documentation मध्ये वेगवेगळ्या पृष्ठांवर वेगवेगळे defaults दिले आहेत: FAQ मध्ये 4096 tokens, Modelfile reference मध्ये num_ctx चा default 2048, तर context length page मध्ये उपलब्ध VRAM (video RAM) नुसार default निवडला जातो असे सांगितले आहे: 24 GiB पेक्षा कमी असल्यास 4k, 24 GiB ते 48 GiB पर्यंत 32k आणि 48 GiB किंवा त्याहून अधिक असल्यास 256k. यांपैकी प्रत्येक मूल्य एखाद्या build साठी बरोबर होते. यावरून महत्त्वाचा निष्कर्ष असा आहे: कोणत्याही page वर, यासह, विश्वास ठेवण्याऐवजी तुमच्या स्वतःच्या चालू server वरून मूल्य वाचा.
Truncation शांतपणे होते, कारण model तरीही उत्तर देते आणि ते उत्तर वाचायला योग्य वाटते. ते तुमच्या input च्या शेवटच्या भागावर आधारित लिहिलेले असते. एखाद्या document च्या पहिल्या अर्ध्या भागाकडे दुर्लक्ष करणारा summary पाहता model कमकुवत वाटू शकते. प्रत्यक्षात कारण बहुतेक वेळा लहान context window असते.
तुमच्या सर्व्हरने प्रत्यक्षात लागू केलेली Ollama कॉन्टेक्स्ट लांबी तपासा
कोणत्याही बिल्डवर काम करणारी चाचणी म्हणजे prompt_eval_count, जी सर्व्हरने प्रक्रिया केलेल्या प्रॉम्प्ट टोकन्सची संख्या दर्शवते. कॉन्टेक्स्ट क्षमतेपेक्षा जास्त डेटा पाठवा, म्हणजे ती संख्या मर्यादेवर थांबेल.
sudo apt update && sudo apt install -y jq
LONG=$(python3 -c "print('the quick brown fox jumps over the lazy dog. ' * 2000)")
jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:4096}}' |
curl -s http://localhost:11434/api/generate -d @- |
jq '{prompt_eval_count, prompt_eval_duration}'तो प्रॉम्प्ट सुमारे 18,000 शब्दांचा आहे, म्हणजेच 4096 टोकन्सपेक्षा कितीतरी जास्त. prompt_eval_count हे प्रत्यक्ष टोकन संख्येऐवजी 4096 च्या जवळ येते, कारण सर्व्हरने उर्वरित भाग काढून टाकला आहे. हे पुन्हा "num_ctx":16384 सह चालवा आणि संख्या वाढेल. जर तुमच्या बिल्डने डेटा ट्रंकेट करण्याऐवजी एरर दिली, तर त्याचा अर्थ असाच आहे, फक्त तो अधिक स्पष्टपणे समजतो.
ollama psCONTEXT कॉलम, ज्या बिल्ड्समध्ये तो दिसतो, त्यामध्ये सध्या लोड केलेल्या मॉडेलची कॉन्टेक्स्ट लांबी असते. त्याच्या शेजारील PROCESSOR कॉलम मॉडेलची स्थिती दर्शवतो. GPU नसलेल्या VPS वर 100% CPU असणे सामान्य आहे. GPU असलेल्या बॉक्सवर 30%/70% CPU/GPU सारखी विभागणी होणे म्हणजे वेट्स (weights) आणि कॅशे (cache) आता VRAM मध्ये मावत नाहीत, आणि याचे सामान्य कारण वाढलेली num_ctx ही असते.
journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5इन्फरन्स रनर त्याच्या कॉन्टेक्स्टचा आकार n_ctx असलेल्या ओळीमध्ये प्रिंट करतो. अचूक शब्दरचना रिलीजनुसार बदलू शकते, त्यामुळे जर ती ओळ दिसत नसेल तर ते काहीतरी चुकल्याचे लक्षण नसून केवळ नाव बदलले असल्याचे समजावे.
num_ctx सेट करण्यासाठी चार ठिकाणे
रिक्वेस्टमध्ये. "options": {"num_ctx": 16384} ला /api/generate किंवा /api/chat कडे पाठवा. हे इतर सर्व सेटिंग्जपेक्षा प्रभावी ठरते आणि ते फक्त त्या एका कॉलसाठी लागू होते. जर हे मूल्य लोड केलेल्या मॉडेलच्या सध्याच्या मूल्यापेक्षा वेगळे असेल, तर सर्व्हर आधी मॉडेल पुन्हा लोड करतो, जे तुम्ही रिस्पॉन्स मधील load_duration मध्ये पाहू शकता: ते जवळजवळ शून्यावरून काही सेकंदांपर्यंत वाढते. मॉडेल निष्क्रिय राहिल्यामुळे अनलोड झाले असेल तरीही असाच विलंब होतो, त्यामुळे एकदा तुम्ही कॉन्टेक्स्ट साईज निश्चित केली की keep_alive वापरून मॉडेल मेमरीमध्ये ठेवणे फायदेशीर ठरते.
इंटरअॅक्टिव्ह सेशनमध्ये. ollama run च्या आत, /set parameter num_ctx 16384 टाईप करा. हे फक्त त्या सेशनपुरते मर्यादित राहते.
Modelfile मध्ये. हे मूल्य एका विशिष्ट मॉडेलमध्ये समाविष्ट (bake) करते, त्यामुळे क्लायंट-साईडवर कोणताही बदल न करता प्रत्येक क्लायंटला ते मिळते.
FROM llama3.1:8b
PARAMETER num_ctx 16384ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16kसर्व्हरवर. OLLAMA_CONTEXT_LENGTH हे अशा प्रत्येक रिक्वेस्टसाठी डीफॉल्ट सेट करते ज्यामध्ये स्वतःचे num_ctx नसते. systemd अंतर्गत, युनिट फाईल एडिट करण्याऐवजी ड्रॉप-इन फाईल वापरा.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama psजेव्हा तुम्ही दुसऱ्या कोणाच्या क्लायंटचे डीबगिंग करत असता, तेव्हा प्राधान्यक्रमाचे (precedence) महत्त्व अधिक असते. ज्या रिक्वेस्टमध्ये num_ctx असते ती सर्व्हरच्या डीफॉल्ट सेटिंगला ओव्हरराईड करते, त्यामुळे एखादा चॅट फ्रंट-एंड किंवा एजंट जो स्वतःचे लहान मूल्य पाठवतो, तो तुमच्या systemd मधील बदलाला नकळतपणे निष्प्रभ करतो. जेव्हा तुम्ही एखादा कोडिंग एजंट तुमच्या Ollama सर्व्हरला जोडता, तेव्हा सर्व्हरला दोष देण्यापूर्वी क्लायंट काय पाठवत आहे ते तपासा.
तुम्ही num_ctx मॉडेलच्या कमाल मर्यादेइतके का सेट करू शकत नाही
Attention मध्ये प्रत्येक token त्याच्या आधीच्या प्रत्येक token कडे पाहतो. आधीच्या token साठी मोजलेले keys आणि values प्रत्येक नवीन token साठी पुन्हा मोजावे लागू नयेत म्हणून साठवले जातात. या संचयाला KV cache (key/value cache) म्हणतात. मॉडेल लोड होताना तो संपूर्ण num_ctx साठी allocate केला जातो. conversation वाढत असताना तो हळूहळू allocate होत नाही. त्यामुळे one line prompt असतानाही मोठ्या context साठी त्याची memory लागते.
प्रत्येक layer मध्ये प्रत्येक token साठी प्रत्येक key/value head ला एक key vector आणि एक value vector ठेवला जातो. त्यामुळे गणना एका ओळीत मांडता येते:
kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_value2 ही संख्या keys आणि values स्वतंत्रपणे मोजते. इतर संख्या तुमच्या स्वतःच्या मॉडेलमधून घ्या.
curl -s http://localhost:11434/api/show -d '{"model":"llama3.1:8b"}' |
jq '.model_info | {ctx: ."llama.context_length", layers: ."llama.block_count", heads: ."llama.attention.head_count", kv_heads: ."llama.attention.head_count_kv", embed: ."llama.embedding_length"}'Llama 3.1 8B मध्ये 32 layers आणि 8 key/value heads आहेत. Head dimension ही embed ला heads ने भागल्यावर मिळते. त्यामुळे येथे 4096 / 32 = 128 होते. काही मॉडेल्स ती थेट llama.attention.key_length म्हणून देतात. Default cache मध्ये f16 values ठेवले जातात, त्यामुळे bytes_per_value चे मूल्य 2 आहे. म्हणून 2 32 8 128 2 = 131,072 bytes होते. Context मधील प्रत्येक token साठी cache ला 128 KiB लागतात. Context length ने गुणल्यावर हा खर्च स्पष्टपणे मोठा होतो.
या तक्त्यामागील डेटा
[
{
"label": "4k",
"kv_cache_gib": 0.5,
"total_ram_gib": 5.1
},
{
"label": "8k",
"kv_cache_gib": 1,
"total_ram_gib": 5.6
},
{
"label": "16k",
"kv_cache_gib": 2,
"total_ram_gib": 6.6
},
{
"label": "32k",
"kv_cache_gib": 4,
"total_ram_gib": 8.6
},
{
"label": "64k",
"kv_cache_gib": 8,
"total_ram_gib": 12.6
},
{
"label": "128k",
"kv_cache_gib": 16,
"total_ram_gib": 20.6
}
]हे 6 rows वरील सूत्रातून केलेली गणना आहेत; ती मोजमापे नाहीत. Total column मध्ये Ollama library ने October 2026 मध्ये llama3.1:8b साठी दाखवलेला 4.9 GB download जोडला आहे. तो 4.6 GiB इतका आहे. Compute buffers आणि server process यामध्ये धरलेले नाहीत. त्यामुळे ही किमान गरज समजा.
मुख्य मुद्दा म्हणजे या खर्चाचा आकार. 8k वर cache साठी 1 GiB लागतात. Weights च्या तुलनेत ही रक्कम नगण्य आहे. मॉडेलच्या पूर्ण 128k वर cache साठी 16 GiB लागतात. हे weights पेक्षा तीनपटांहून अधिक आहे. त्यामुळे एकूण memory गरज जवळपास 20.6 GiB होते. म्हणून 4 GB VPS वर हे मॉडेल उपयुक्त context सह load करता येत नाही. 8 GB VPS वर 8k context साठी पुरेशी memory असते. 16 GB VPS वर उरलेल्या system साठी memory ठेवून 32k पर्यंत जाता येते. Weights वाढले की या सर्व मर्यादा अधिक memory कडे सरकतात. त्यामुळे या 8B मॉडेलऐवजी मोठे मॉडेल निवडण्याचा विचार करत असल्यास, CPU-only VPS वरील Qwen चा 27B tag साठी केलेली हीच गणना 8 ते 64 GB memory दरम्यान context साठी किती कमी memory उरते हे दाखवते.
KV cache मध्ये बसत नसेल तर काय होते
केवळ CPU असलेल्या VPS वर process ची memory वापर वाढत जातो. Model load होत असताना आणि दीर्घ request चालू असताना त्याचे निरीक्षण करा.
free -m
ps -eo rss,comm --sort=-rss | head -n 5RSS (resident set size) kilobytes मध्ये दाखवला जातो. free -m मधील वापरलेला swap वाढू लागला, तर context कमी करा. Swap मध्ये असलेला KV cache generation अत्यंत मंद करतो. प्रत्येक नवीन token साठी संपूर्ण cache वाचावा लागतो. त्यामुळे प्रत्येक token ला काही seconds लागतात.
सिस्टमची memory पूर्णपणे संपली, तर kernel एखादा process बंद करतो. सामान्यतः सर्वाधिक memory वापरणारा process निवडला जातो.
sudo dmesg | grep -i "killed process"Out of memory: Killed process 1234 (ollama) असलेली ओळ म्हणजे kernel ने Ollama process बंद करण्यासाठी निवडला. याचा अर्थ memory संपवणारा process तोच होता असे आवश्यक नाही. Ollama हा सर्वाधिक memory वापरणारा एकमेव मोठा process असेल, तर context बसत नसणे हे सामान्य कारण असते. num_ctx कमी करण्यापूर्वी त्या वेळी आणखी काय चालू होते ते तपासा. Ollama अनेकदा ही स्थिती येण्यापूर्वीच request नाकारतो. त्यानंतर request अयशस्वी होते आणि error message मध्ये आवश्यक memory आणि उपलब्ध असलेली memory नमूद केली जाते.
GPU असलेल्या मशीनवर failure कमी स्पष्टपणे दिसतो. काही layers system RAM मध्ये हलवले जातात, ollama ps मध्ये CPU आणि GPU यांच्यातील विभाजन दिसते आणि throughput मोठ्या प्रमाणात कमी होतो. ही घट तुमच्या hardware वर अवलंबून असते. त्यामुळे दुसऱ्याच्या मशीनवरील आकड्यावर विश्वास ठेवण्याऐवजी प्रत्येक context setting वर तुमच्या मशीनवरील प्रति सेकंद tokens मोजा.
Prefill साठी लागणारा वेळ प्रॉम्प्टच्या तुलनेत वेगाने वाढतो
Prefill म्हणजे पहिला आउटपुट टोकन दिसण्यापूर्वी इनपुटवर केलेले काम. प्रत्येक प्रॉम्प्ट टोकन त्याच्या आधीच्या प्रत्येक टोकनवर लक्ष केंद्रित करते (attend), त्यामुळे एकूण काम इनपुटच्या लांबीच्या वर्गाच्या (square) प्रमाणात वाढते. प्रॉम्प्ट दुप्पट केल्यास पहिल्या टोकनसाठी लागणारा प्रतीक्षा वेळ दुप्पटीपेक्षा जास्त वाढतो.
प्रतिसादामध्ये मोजमाप दिलेले असते, त्यामुळे तुम्हाला त्यावर आंधळा विश्वास ठेवण्याची गरज नाही.
jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:16384}}' |
curl -s http://localhost:11434/api/generate -d @- |
jq '{tokens: .prompt_eval_count, prefill_seconds: (.prompt_eval_duration/1000000000)}'हे short prompt आणि long prompt या दोन्हींसह चालवा. प्रत्येक प्रकरणात tokens ला seconds ने भागा. CPU-only VPS वर long-context request मध्ये prefill हा सहसा सर्वात धीमा टप्पा असतो. त्यामुळे short prompt वरून मिळवलेला tokens per second आकडा long prompt साठी अचूक अंदाज देत नाही. समोर असलेला कोणताही timeout संपेपर्यंत prefill सुरू राहिल्यास, long prompt ला उत्तराऐवजी context deadline exceeded मिळण्याचे हेच सामान्य कारण असते. त्यामुळे context कमी करण्यापूर्वी कोणत्या layer ने प्रक्रिया थांबवली ते शोधा.
Concurrency (एकाच वेळी अनेक विनंत्या) मध्ये याचा सर्वाधिक फटका बसतो. सर्व्ह केल्या जाणाऱ्या प्रत्येक विनंतीला स्वतःच्या कॅशेची आवश्यकता असते, त्यामुळे वरील चार्टमधील मेमरी ही प्रति सर्व्हर नसून प्रति विनंती आहे. एक लांब विनंती सर्व्हरला गुंतवून ठेवू शकते, ज्यामुळे लहान विनंत्या रांगेत थांबतात. OLLAMA_NUM_PARALLEL मुद्दाम सेट करा आणि दोन्ही संख्या एकत्र वाढवण्यापूर्वी एक self-hosted LLM एकाच वेळी किती वापरकर्त्यांना सर्व्ह करू शकते हे वाचा.
लहान cache वापरून मेमरी पुन्हा उपलब्ध करा
bytes_per_value हे formula मधील तुम्ही नियंत्रित करू शकणारे setting आहे. Ollama च्या FAQ मध्ये OLLAMA_KV_CACHE_TYPE चे दस्तऐवजीकरण आहे. त्यात f16 हे default आहे, q8_0 ला f16 च्या सुमारे निम्मी मेमरी लागते आणि q4_0 ला सुमारे एक चतुर्थांश मेमरी लागते. q8_0 साठी अचूक प्रमाण थोडे अधिक than half आहे: llama.cpp प्रत्येक 32 values चा block 32 one-byte values आणि two-byte scale म्हणून साठवते. त्यामुळे एकूण 34 bytes लागतात, तर f16 साठी 64 bytes लागतात. त्यामुळे q8_0 वापरल्यास 32k row ला 4 GiB ऐवजी सुमारे 2.1 GiB लागतात. Weights quantise केल्यास याच memory budget च्या दुसऱ्या बाजूने memory मोकळी होते. त्यासाठी VPS वर प्रत्यक्ष बसणारा GLM tag quantisation च्या प्रत्येक पर्यायातून तपासला आहे. त्याच FAQ नुसार Flash Attention enabled असतानाच cache quantise केला जातो. तो सक्तीने enabled करण्यासाठी OLLAMA_FLASH_ATTENTION=1 वापरा.
[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"अंदाज न करता पडताळणी करा: service restart करा, आधीप्रमाणेच num_ctx वर model load करा आणि RSS ची तुलना करा. Support हा model आणि backend वर अवलंबून असतो. त्यामुळे setting बदलूनही काही फरक पडत नसेल, तर तुमचे combination समर्थित नाही. Cache type हा global option आहे. त्यामुळे server वरील प्रत्येक model त्याच्यासह चालतो. Quality बाबत FAQ नुसार q8_0 मुळे सहसा जाणवण्याजोगा परिणाम होत नाही. q4_0 मध्ये अधिक precision कमी होते आणि मोठ्या context sizes वर हा परिणाम अधिक स्पष्ट दिसतो. त्यामुळे त्यावर अवलंबून राहण्यापूर्वी q4_0 ची तुमच्या स्वतःच्या prompts विरुद्ध चाचणी करा. तुम्ही येथे आला असण्याचे कारण हीच settings असतील, तर Ollama आणि llama.cpp ही settings वेगवेगळ्या प्रकारे उघड करतात.
num_ctx निवडण्यासाठीची कृती
/api/showमधून मॉडेलची कमाल context, त्यातील लेयर्सची संख्या आणि key/value head ची संख्या तपासा.- सूत्राचा वापर करून प्रति टोकन किती bytes लागतात ते काढा आणि तुम्हाला हव्या असलेल्या context ने गुणा.
- यामध्ये मॉडेलच्या वजनाचा (weight size) आकार मिळवा, उपलब्ध RAM शी तुलना करा आणि सिस्टमच्या इतर कामांसाठी किमान 1 GiB RAM शिल्लक ठेवा.
- मूल्य सेट करा, मॉडेल लोड करा आणि त्यानंतर
ollama psवprompt_eval_countवापरून नेमके किती context लागू झाले आहे याची खात्री करा. - तुमचा प्रत्यक्ष वर्कलोड चालवताना
free -mवर लक्ष ठेवा; जर swap मेमरी वापरली जाऊ लागली, तर context अर्धी करा.
बहुतेक कामांसाठी लोकांना वाटते त्यापेक्षा कमी context पुरेशी असते. एखादा मोठा अहवाल सारांशित करण्यासाठी 16k पुरेशी असते. पाच दस्तऐवजांचे भाग पेस्ट करणारे retrieval front end क्वचितच 8k च्या पुढे जाते. कोडिंग एजंट जेव्हा संपूर्ण फाइल्स वाचतो, तेव्हाच खऱ्या अर्थाने 64k किंवा त्यापेक्षा जास्त context ची गरज भासते. अशा वेळी, उपलब्ध हार्डवेअरनुसार context ठरवण्याऐवजी, context च्या गरजेनुसार मशीनची क्षमता ठरवणे योग्य ठरते. जर सर्व्हर नवीन असेल, तर Ollama चे VPS वरील कार्यरत इंस्टॉलेशन पासून सुरुवात करा आणि मॉडेल्स व्यवस्थित लोड होऊ लागल्यावर context ट्यून करा.
FAQ
Ollama मधील default context length किती आहे?
ते build आणि hardware वर अवलंबून असते. त्यामुळे अंदाज न धरता तपासा. Ollama च्या FAQ मध्ये 4096 tokens दस्तऐवजीकरण केले आहेत, तर Modelfile reference मध्ये num_ctx default म्हणून 2048 दिले आहे. Context length पृष्ठावर उपलब्ध VRAM नुसार निवडला जाणारा default दिला आहे: 24 GiB पेक्षा कमी असल्यास 4k, 24 GiB ते 48 GiB पर्यंत 32k, आणि 48 GiB किंवा त्याहून अधिक असल्यास 256k. CPU-only VPS साधारणपणे लहान context length वापरतो. ज्या build मध्ये हा column उपलब्ध आहे, त्यामध्ये ollama ps लागू केलेला context दाखवतो. API response मधील prompt_eval_count प्रत्येक build मध्ये तो context निश्चितपणे दाखवतो.
Ollama माझ्या मोठ्या prompt ची सुरुवात का दुर्लक्षित करते?
कारण prompt ची लांबी context window पेक्षा जास्त होती. त्यामुळे model ला दिसण्यापूर्वी server ने prompt कापला आणि कोणतीही error परत केली नाही. तोच prompt मोठ्या num_ctx सह पुन्हा पाठवा आणि response मधील prompt_eval_count वाढतो का ते monitor करा. तो आकडा बदलत नसेल, तर तुमच्या आणि server मधील एखादा घटक स्वतः num_ctx सेट करत आहे. Chat front ends आणि agent frameworks मध्ये हे सामान्य आहे.
मोठ्या num_ctx साठी किती अतिरिक्त RAM आवश्यक असते?
Context length ला प्रत्येक token च्या cache cost ने गुणा करा. ही cost 2 * layers * kv_heads * head_dim * bytes_per_value आहे. f16 मधील Llama 3.1 8B साठी ती प्रत्येक token मागे 128 KiB आहे. त्यामुळे 32k tokens साठी weights व्यतिरिक्त 4 GiB लागतात आणि पूर्ण 128k साठी 16 GiB लागतात. Model load होताना cache allocate केला जातो. त्यामुळे prompts लहान असले तरी मोठ्या num_ctx साठी तेवढी memory लागते.
मोठी context window Ollama ला धीमे करते का?
होय, दोन प्रकारे. Prompt ची लांबी वाढल्यावर prefill work तिच्या वर्गाच्या प्रमाणात वाढते. त्यामुळे लांब input मुळे पहिला token मिळण्यास त्याच्या लांबीवरून अपेक्षित वेळेपेक्षा अधिक विलंब होतो. मोठा cache memory साठीही स्पर्धा करतो. GPU box वर तो काही layers system RAM मध्ये ढकलतो, तर CPU box वर machine swap कडे ढकलतो. मोठे num_ctx तुम्ही पूर्णपणे वापरले नाही तरी memory खर्च होते. मात्र prefill time तेव्हा खर्च होत नाही.
एका model साठी num_ctx कायमस्वरूपी सेट करता येतो का?
होय. FROM llama3.1:8b आणि PARAMETER num_ctx 16384 असलेली Modelfile लिहा आणि त्यानंतर ollama create llama3.1-16k -f ./Modelfile चालवा. llama3.1-16k मागणाऱ्या प्रत्येक client ला कोणतेही options पाठविल्याशिवाय तो context मिळेल. स्वतःचे num_ctx असलेली request मात्र त्याला प्राधान्य देते. त्यामुळे हे ceiling नसून default सेट करते.