डॉकर मॉडल रनर: कॉन्टेक्स्ट साइज़ कॉन्फ़िग गाइड

डॉकर मॉडल रनर में कॉन्टेक्स्ट साइज कॉन्फ़िगर करने का कॉन्फ़िगरेशन अधिक जटिल है जितना होना चाहिए।

जबकि context_size पैरामीटर डॉकर-कॉम्पोज़ कॉन्फ़िगरेशन में मौजूद है, यह अक्सर docker/model-runner:latest-cuda इमेज द्वारा नज़रअंदाज़ किया जाता है, जो 4096-टोकन कॉन्टेक्स्ट साइज को हार्डकोड करता है। यह गाइड सीमाओं का पता लगाता है और व्यावहारिक वर्कअराउंड प्रदान करता है।

इस छवि को Flux 1 dev द्वारा बनाया गया था।

समस्या को समझना

जब आप डॉकर मॉडल रनर का उपयोग डॉकर-कॉम्पोज़ के साथ करते हैं, तो आप कॉन्टेक्स्ट साइज को इस तरह कॉन्फ़िगर कर सकते हैं:

services:
  llm:
    image: docker/model-runner:latest-cuda
    models:
      - llm_model

models:
  llm_model:
    model: ai/gemma3-qat:4B
    context_size: 10240

हालांकि, लॉग्स की जांच करने पर पता चलता है कि वास्तव में उपयोग किया जा रहा कॉन्टेक्स्ट साइज:

docker compose logs 2>&1 | grep -i "n_ctx"

आपको यह आउटपुट मिलेगा:

llamaCppArgs: [... --ctx-size 4096 ...]
llama_context: n_ctx = 4096

docker/model-runner:latest-cuda इमेज --ctx-size 4096 हार्डकोड करती है जब llama.cpp को कॉल किया जाता है, और आपका context_size: 10240 कॉन्फ़िगरेशन पूरी तरह से नज़रअंदाज़ किया जाता है।

यह क्यों होता है

कॉन्टेक्स्ट साइज (n_ctx) llama.cpp में मॉडल इनिशियलाइज़ेशन टाइम पर सेट किया जाता है, जो डॉकर मॉडल रनर द्वारा उपयोग किया जाने वाला अंडरलाइंग इन्फरेंस इंजन है। यह मॉडल के कॉन्टेक्स्ट कंस्ट्रक्शन फेज के दौरान होता है, किसी भी API रिक्वेस्ट्स को प्रोसेस करने से पहले। डॉकर मॉडल रनर के कॉम्पोज़ इंटीग्रेशन में एक बग प्रतीत होता है जहां यह context_size पैरामीटर को मॉडल्स सेक्शन से अंडरलाइंग llama.cpp प्रक्रिया को सही ढंग से पास नहीं करता है। इसके बजाय, यह 4096 टोकन्स के साथ डिफ़ॉल्ट होता है, चाहे आपका कोई भी कॉन्फ़िगरेशन हो।

इस सीमा का मतलब है कि हालांकि डॉकर कॉम्पोज़ आपकी YAML कॉन्फ़िगरेशन में context_size पैरामीटर को पहचानता है, docker/model-runner:latest-cuda इमेज इसे llama.cpp के कमांड-लाइन अर्गुमेंट्स को कंस्ट्रक्ट करने के दौरान सम्मानित नहीं करता है। हार्डकोडेड --ctx-size 4096 फ्लैग आप द्वारा निर्दिष्ट किसी भी कॉन्फ़िगरेशन पर प्राथमिकता रखता है।

वर्कअराउंड और समाधान

क्या करना है? विधियाँ 1-2-3 काम करेंगी, लेकिन इनके कुछ सीमाएँ हैं।

विधि 1. एड-हॉक, काम करेगी। विधि 2. मॉडल में हार्डकोड की गई है। विधि 3. आवश्यक कंटेनराइज़ेशन और अपने एप्लिकेशन को कॉम्पोज़िशन में डालना। यह उत्पादन के करीब है।

विधि 1: docker model configure का उपयोग करें (सीमित)

आप डॉकर मॉडल CLI का उपयोग करके कॉन्टेक्स्ट साइज कॉन्फ़िगर कर सकते हैं, जो कॉन्फ़िगरेशन को डॉकर के मॉडल मेटाडेटा में स्टोर करता है:

docker model configure --context-size=10000 ai/gemma3-qat:4B

यह कमांड मॉडल के कॉन्फ़िगरेशन को अपडेट करता है, लेकिन इस इम्प्लीमेंटेशन में महत्वपूर्ण सीमाएँ हैं। कॉन्फ़िगरेशन स्टोर की जाती है लेकिन हमेशा सही ढंग से लागू नहीं होती है।

सीमाएँ:

• यह docker model run का उपयोग करके सीधे काम नहीं करता है, केवल API एंडपॉइंट के लिए कर्ल
• आप कॉन्फ़िगर करने के बाद docker model run का उपयोग नहीं कर सकते - यह कॉन्फ़िगरेशन को नज़रअंदाज़ करेगा
• कॉन्फ़िगरेशन नज़रअंदाज़ की जाती है जब docker/model-runner:latest-cuda इमेज के साथ डॉकर-कॉम्पोज़ का उपयोग किया जाता है
• जब मॉडल को अपडेट किया जाता है या फिर से पुल किया जाता है तो कॉन्फ़िगरेशन खो सकती है

यह विधि सीधे API कॉल्स के साथ टेस्टिंग के लिए सबसे अच्छी तरह काम करती है, लेकिन डॉकर-कॉम्पोज़ का उपयोग करने वाले उत्पादन डिप्लॉयमेंट्स के लिए उपयुक्त नहीं है।

विधि 2: अपना खुद का मॉडल पैकेज करें

एक कस्टम कॉन्टेक्स्ट साइज सेट करने का सबसे विश्वसनीय तरीका docker model package का उपयोग करके अपना खुद का मॉडल पैकेज करना है, जिसमें डिज़ायर्ड कॉन्टेक्स्ट साइज होता है:

docker model package \
  --gguf /path/to/model.gguf \
  --context-size 10240 \
  --name my-model:custom-context

यह एक नया OCI आर्टिफैक्ट बनाता है (डॉकर इमेज के समान) जिसमें कॉन्टेक्स्ट साइज स्थायी रूप से कॉन्फ़िगर किया गया है। पैकेज किया गया मॉडल फिर डॉकर हब या किसी भी OCI-समर्थित रेजिस्ट्री में पुश किया जा सकता है और किसी भी अन्य डॉकर मॉडल रनर मॉडल की तरह पुल किया जा सकता है।

हालांकि, इस दृष्टिकोण की आवश्यकता होती है:

• मूल GGUF मॉडल फाइल तक पहुंच (llama.cpp द्वारा उपयोग किया जाने वाला क्वांटाइज़्ड फॉर्मेट)
• हर बार जब आप कॉन्टेक्स्ट साइज बदलना चाहते हैं तो फिर से पैकेज करना, जो समय लेने वाला हो सकता है
• अपने खुद के मॉडल रेजिस्ट्री या डॉकर हब अकाउंट का प्रबंधन
• डॉकर मॉडल रनर पैकेजिंग वर्कफ्लो का ज्ञान

यह विधि उन उत्पादन वातावरणों के लिए सबसे उपयुक्त है जहां आप डिप्लॉयमेंट्स के माध्यम से स्थिर, पुनरुत्पाद्य कॉन्टेक्स्ट साइज की आवश्यकता होती है।

विधि 3: डॉकर कॉम्पोज़

इस समय docker/model-runner:latest-cuda के लिए टूटा हुआ है

लेकिन अपने इमेज में एप्लिकेशन के लिए काम कर सकता है :)

जबकि सिंटैक्स डॉकर-कॉम्पोज़.यमएल में मौजूद है:

services:
  llm:
    image: docker/model-runner:latest-cuda
    models:
      - llm_model

models:
  llm_model:
    model: ai/gemma3-qat:4B
    context_size: 10240

यह काम नहीं करता - context_size पैरामीटर डॉकर-कॉम्पोज़ द्वारा पहचाना जाता है लेकिन लागू नहीं किया जाता है। मॉडल अभी भी 4096 टोकन्स का उपयोग करता है।

विधि 4: एन्वायर्नमेंट वेरिएबल्स (भी टूटा हुआ)

MODEL_CONTEXT एन्वायर्नमेंट वेरिएबल का उपयोग करने का प्रयास:

services:
  llm:
    image: docker/model-runner:latest-cuda
    environment:
      - MODEL_CONTEXT=10240

यह भी काम नहीं करता - एन्वायर्नमेंट वेरिएबल डॉकर-कॉम्पोज़ का उपयोग करने के दौरान सम्मानित नहीं किया जाता है।

कॉन्टेक्स्ट साइज की पुष्टि

वास्तव में उपयोग किया जा रहा कॉन्टेक्स्ट साइज जांचने के लिए, लॉग्स की जांच करें:

# llama.cpp arguments check
docker compose logs 2>&1 | grep "llamaCppArgs"

# actual context size check
docker compose logs 2>&1 | grep -i "n_ctx" | tail -10

आपको यह आउटपुट मिलेगा:

llamaCppArgs: [-ngl 999 --metrics --model /models/... --ctx-size 4096 ...]
llama_context: n_ctx = 4096
llama_context: n_ctx_per_seq = 4096

अगर आप n_ctx = 4096 देखते हैं जबकि आपने अलग साइज कॉन्फ़िगर किया है, तो आपका कॉन्फ़िगरेशन नज़रअंदाज़ किया जा रहा है।

कॉन्टेक्स्ट साइज का परीक्षण

इसके लिए कि आपका कॉन्टेक्स्ट साइज कॉन्फ़िगरेशन वास्तव में लागू हो रहा है या नहीं, आपको 4096-टोकन सीमा से अधिक होने वाले प्रॉम्प्ट्स के साथ परीक्षण करना होगा। यहां एक व्यावहारिक स्क्रिप्ट है जिसमें Python का उपयोग करके परीक्षण करने के लिए:

#!/bin/bash
MODEL="ai/gemma3-qat:4B"
PORT=8085

# large prompt test
python3 -c "print('test ' * 5000)" > large_prompt.txt

python3 << 'PYTHON' > request.json
import json
import os

with open('large_prompt.txt', 'r') as f:
    large_prompt = f.read().strip()

request = {
    "model": os.environ.get("MODEL", "ai/gemma3-qat:4B"),
    "messages": [{
        "role": "user",
        "content": large_prompt
    }]
}
print(json.dumps(request))
PYTHON

curl -s http://localhost:${PORT}/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d @request.json > response.json

# token usage check
python3 << 'PYTHON'
import json
with open('response.json') as f:
    r = json.load(f)
    if 'usage' in r:
        print(f"Prompt tokens: {r['usage']['prompt_tokens']}")
        if r['usage']['prompt_tokens'] > 4096:
            print("✅ कॉन्टेक्स्ट विंडो 4096 से अधिक है!")
        else:
            print("⚠️ कॉन्टेक्स्ट विंडो 4096 तक सीमित प्रतीत होता है")
PYTHON

वैकल्पिक समाधान

अगर आपको अधिक लचीलापूर्ण कॉन्टेक्स्ट साइज कॉन्फ़िगरेशन की आवश्यकता है, तो इन वैकल्पिक समाधानों पर विचार करें:

• Ollama - एक वैकल्पिक LLM होस्टिंग समाधान जो कॉन्टेक्स्ट साइजों पर बेहतर नियंत्रण प्रदान करता है और सरल कॉन्फ़िगरेशन। Ollama आपको प्रति मॉडल कॉन्टेक्स्ट साइज निर्दिष्ट करने की अनुमति देता है और डॉकर-कॉम्पोज़ की सीमाओं के साथ नहीं आता है।

• डॉकर मॉडल रनर बनाम Ollama तुलना - दोनों समाधानों की विस्तृत तुलना, जिसमें कॉन्टेक्स्ट साइज कॉन्फ़िगरेशन क्षमताएँ, प्रदर्शन, और प्रत्येक प्लेटफॉर्म को चुनने का समय शामिल है।

संबंधित संसाधन

डॉकर मॉडल रनर

• डॉकर मॉडल रनर चीटशीट - सभी डॉकर मॉडल रनर ऑपरेशन्स के लिए उदाहरणों के साथ पूर्ण कमांड रेफरेंस
• डॉकर मॉडल रनर में NVIDIA GPU समर्थन जोड़ना - GPU त्वरण सक्षम करने के लिए चरण-दर-चरण गाइड
• डॉकर मॉडल रनर बनाम Ollama: किसे चुनना है?

डॉकर और इन्फ्रास्ट्रक्चर

• डॉकर चीटशीट - कंटेनर प्रबंधन के लिए आवश्यक डॉकर कमांड्स
• डॉकर कॉम्पोज़ चीटशीट - डॉकर कॉम्पोज़ कॉन्फ़िगरेशन और कमांड्स के लिए पूर्ण गाइड

वैकल्पिक LLM समाधान

• Ollama चीटशीट - बिल्ट-इन GPU समर्थन और सरल कॉन्टेक्स्ट साइज कॉन्फ़िगरेशन के साथ वैकल्पिक LLM होस्टिंग समाधान
• Ollama को Python के साथ इंटीग्रेट करना

आधिकारिक दस्तावेज़ीकरण

• डॉकर मॉडल रनर दस्तावेज़ीकरण - मॉडल रनर के लिए आधिकारिक डॉकर दस्तावेज़ीकरण
• llama.cpp कॉन्टेक्स्ट कॉन्फ़िगरेशन - अंडरलाइंग इन्फरेंस इंजन दस्तावेज़ीकरण

निष्कर्ष

डॉकर मॉडल रनर में कॉन्टेक्स्ट साइज को कॉन्फ़िगर करने में वर्तमान में समस्या है जब आप docker-compose का उपयोग करते हैं। जबकि कॉन्फ़िगरेशन सिंटैक्स डॉकर कम्पोज स्पेसिफिकेशन में मौजूद है, यह docker/model-runner:latest-cuda इमेज में उचित रूप से लागू नहीं किया गया है, जो आपकी कॉन्फ़िगरेशन के बावजूद 4096-टोकन कॉन्टेक्स्ट साइज को हार्डकोड करता है।

सबसे विश्वसनीय कार्यaround यह है कि आप अपने मॉडल्स को docker model package का उपयोग करके अपने इच्छित कॉन्टेक्स्ट साइज के साथ पैकेज करें, हालांकि यह आपके वर्कफ्लो में जटिलता जोड़ता है और मूल GGUF मॉडल फाइलों तक पहुंच की आवश्यकता होती है। वैकल्पिक रूप से, आप docker model configure का उपयोग सीधे API एक्सेस के लिए कर सकते हैं, लेकिन यह docker-compose डिप्लॉयमेंट्स के साथ काम नहीं करता है।

अधिकांश उपयोग के मामलों के लिए, 4096-टोकन कॉन्टेक्स्ट साइज आम तौर पर सामान्य संवादात्मक AI अनुप्रयोगों के लिए पर्याप्त होता है। अगर आपको बड़े कॉन्टेक्स्ट विंडो या अधिक लचीला कॉन्फ़िगरेशन की आवश्यकता है, तो Ollama का उपयोग एक विकल्प के रूप में करें, जो डॉकर-कम्पोज सीमाओं के बिना कॉन्टेक्स्ट साइजों पर बेहतर नियंत्रण प्रदान करता है।

आप VRAM उपयोग को अन्य तरीकों से भी अनुकूलित कर सकते हैं जैसे मॉडल क्वांटाइजेशन (Q4, Q6, Q8) और GPU लेयर कॉन्फ़िगरेशन (MODEL_GPU_LAYERS), जो कॉन्टेक्स्ट साइज समायोजनों से अधिक प्रभावी होते हैं VRAM खपत को कम करने के लिए।

NVIDIA GPU समर्थन और VRAM प्रबंधन के बारे में अधिक विवरण के लिए, देखें हमारा गाइड NVIDIA GPU समर्थन को डॉकर मॉडल रनर में जोड़ना।