Skip to content

स्थानीय मॉडल: Ollama, vLLM और ds4 ​

पिछले पाठ तक, OpenClaw पूरी तरह क्लाउड API से जुड़ा था। इस पाठ में तरीका बदलेंगे: OpenClaw स्थानीय मॉडल—इन्फ़ेरेंस आपके अपने हार्डवेयर पर चलता है, कोई API खर्च नहीं, बातचीत का डेटा एक बाइट भी बाहर नहीं जाता। आधिकारिक आर्किटेक्चर में, मॉडल और agent harness (Claude, Codex, स्थानीय मॉडल) सब बदले जा सकने वाले प्लगइन हैं, स्थानीय बैकएंड पूर्ण प्रथम-श्रेणी नागरिक हैं: Ollama, vLLM, SGLang सब इनबिल्ट provider हैं, LM Studio के लिए विशेष onboarding है, ds4 (macOS Metal पर DeepSeek V4 Flash स्थानीय रूप से चलाना) पूरी तरह कॉन्फ़िगरेशन से जुड़ता है। पूरी प्रक्रिया में लगभग 10 मिनट, यह ट्यूटोरियल v2026.10.9 पर आधारित है।

सीखने के बाद आप क्या कर सकेंगे ​

  • Ollama से स्थानीय मॉडल को OpenClaw में जोड़ें, टूल कॉलिंग सही काम करती है—Claw सच में काम कर सकता है, सिर्फ बातचीत का साथी नहीं
  • vLLM / SGLang से GPU सर्वर पर ओपन-सोर्स वेट सेल्फ-होस्ट करें, OpenClaw मॉडल डायरेक्टरी अपने आप मिल जाती है
  • macOS पर ds4 से DeepSeek V4 Flash स्थानीय रूप से चलाएं, thinking स्तर और आवश्यकतानुसार शुरूआत कॉन्फ़िगर करें
  • आधिकारिक चयन तालिका से सात स्थानीय बैकएंड के उपयोग-केस समझें, पहली बार इंस्टॉल करते समय भी रास्ता न मिलने की स्थिति न आए
  • स्तरित डायग्नोस्टिक कमांड से 「मॉडल जवाब देता है」 और 「Gateway रूटिंग सही है」 में अंतर करें, स्थानीय-प्राथमिक + क्लाउड फ़ॉलबैक वाली हाइब्रिड योजना कॉन्फ़िगर करें

🎒 शुरू करने से पहले की तैयारी ​

  • पूरा किया मॉडल जोड़ने का सारांश: provider व्यवस्था और मॉडल बदलना: provider/model रेफ़रेंस नियम और 「प्लगइन इंस्टॉल → क्रेडेंशियल कॉन्फ़िगर → मॉडल चुनें」 तीन चरणों पर मन में स्पष्टता हो
  • OpenClaw इंस्टॉल हो चुका है, Gateway चल रहा है: openclaw gateway status का आउटपुट आता है
  • एक ऐसी मशीन जो मॉडल चला सके—आधिकारिक llama.cpp होस्टेड रेसिपी का सबसे छोटा संस्करण भी 8 GiB मुख्य मेमोरी से शुरू (64K कॉन्टेक्स्ट रेसिपी), वास्तविक ज़रूरत मॉडल वेट, कॉन्टेक्स्ट और रनटाइम पर निर्भर करती है
  • कम से कम एक स्थानीय इन्फ़ेरेंस बैकएंड इंस्टॉल करें (Ollama / vLLM / SGLang / LM Studio / ds4 में से कोई एक), या नीचे दिए चरणों के साथ तुरंत इंस्टॉल करें

💡 स्थानीय मॉडल का उपयोग क्यों करें?

तीन ठोस कारण: मुफ़्त—इन्फ़ेरेंस आपके CPU/GPU पर होता है, कोई per-token बिल नहीं; ऑफ़लाइन—मॉडल डाउनलोड के बाद इंटरनेट बंद होने पर भी चलता है, इंट्रानेट और गोपनीय वातावरण के लिए अनुकूल; प्राइवेसी—बातचीत, मेमोरी, फ़ाइलें पूरी तरह आपके हार्डवेयर से बाहर नहीं जातीं। कीमत भी स्पष्ट है: गुणवत्ता और गति हार्डवेयर पर निर्भर हैं, और स्थानीय मॉडल में होस्टिंग प्रदाता का सुरक्षा फ़िल्टर नहीं होता, टूल अनुमतियां आपको खुद कसनी होंगी (चरण 1 में विस्तार से)।

मेरे साथ करें ​

चरण 1: बैकएंड चुनें—आधिकारिक चयन तालिका से मिलान करें ​

क्यों: स्थानीय बैकएंड का अपना-अपना काम है, गलत बैकएंड चुनने से मेहनत दोगुनी होती है। आधिकारिक local-models गाइड में एक चयन तालिका है, पहले उससे मिलान करें:

बैकएंडइसका उपयोग कब करेंकैसे जुड़ें
OllamaCLI वर्कफ़्लो, समृद्ध मॉडल लाइब्रेरी, रखरखाव-मुक्त systemd सेवाइनबिल्ट provider (चरण 2)
vLLM / SGLang / MLXहाई-थ्रूपुट सेल्फ-होस्टिंग, OpenAI-संगत HTTP एंडपॉइंटvLLM, SGLang इनबिल्ट provider (चरण 3)
ds4macOS Metal पर DeepSeek V4 Flash स्थानीय रूप से चलाएं, OpenAI-संगत टूल कॉलिंगपूरी तरह कॉन्फ़िगरेशन (चरण 4)
LM Studioपहली बार स्थानीय डिप्लॉयमेंट, GUI लोडर, नेटिव Responses APIonboarding गाइड (चरण 4)
llama.cpp (प्लगइन)हार्डवेयर-जागरूक मॉडल चयन, डाउनलोड सत्यापन, OpenClaw-मैनेज्ड serverllama.cpp प्लगइन इंस्टॉल करने के बाद openclaw onboard चुनें Managed local server
llmmanOCI रिपॉज़िटरी से मॉडल खींचना + llama.cpp/vLLM/MLX इंजन + लोकल/मैनेज्ड हाइब्रिड राउटिंगस्टैंडअलोन provider
LiteLLM / कस्टम OpenAI-संगत प्रॉक्सीबीच में दूसरे मॉडल API की एक परत लगानापिछले पाठ का custom प्रवाह

तीन सामान्य नियम, आगे के हर कदम पर उपयोग होंगे:

  1. एडॉप्टर: जब कस्टम provider baseUrl लिखता है पर api को छोड़ देता है, तो डिफ़ॉल्ट openai-completions; बैकएंड Responses API सपोर्ट करता हो तो api: "openai-responses" का उपयोग संभव है (LM Studio सपोर्ट करता है)। Ollama अपवाद है—यह नेटिव एडॉप्टर (api: "ollama") से चलता है, देखें कदम 2 की /v1 चेतावनी।
  2. हार्डवेयर सीमा: मेमोरी ज़रूरत मॉडल वेट, कॉन्टेक्स्ट, रनटाइम और मशीन पर मौजूद अन्य लोड पर निर्भर करती है; आधिकारिक llama.cpp मैनेज्ड रेसिपी 64K कॉन्टेक्स्ट का उपयोग करती है, सबसे छोटे को भी शुरुआत में कम से कम 8 GiB होस्ट मेमोरी चाहिए, और यह चलने की गारंटी नहीं देता, गति की तो बिल्कुल नहीं। OpenClaw के पूरे prompt, टूल schema, इतिहास और आउटपुट के लिए पर्याप्त मार्जिन रखें।
  3. सुरक्षा: लोकल मॉडल मैनेज्ड प्रोवाइडर के सुरक्षा फ़िल्टर प्रदान नहीं करते। टूल अनुमतियाँ और prompt इंजेक्शन रक्षा को मॉडल क्षमता के अनुसार कसना होगा—मॉडल जितना कमज़ोर, उतना आसानी से वेबपेज या फ़ाइलों में छिपे इंजेक्टेड निर्देशों से भटक सकता है।

कदम 2: Ollama से जुड़ें (लोकल मॉडल का अनुशंसित शुरुआती बिंदु) ​

क्यों: Ollama लोकल मॉडल का सबसे आसान रास्ता है—OpenClaw में बिल्ट-इन provider, Ollama एक कमांड से मॉडल खींचता है, इंस्टॉल के बाद मेंटेनेंस-मुक्त बैकग्राउंड सेवा।

तरीका A (अनुशंसित): onboarding गाइड ​

पहले Ollama इंस्टॉल करें (ollama.com/download) और एक मॉडल खींचें:

bash
ollama pull gemma4

फिर गाइड चलाएँ:

bash
openclaw onboard

Ollama चुनें, फिर मोड चुनें: Cloud + Local (लोकल मॉडल + लॉग-इन होने पर :cloud क्लाउड मॉडल) या Local only (पूरी तरह लोकल)।

आपको यह दिखना चाहिए: गाइड पहले डिफ़ॉल्ट या कॉन्फ़िगर किए गए Ollama होस्ट की जाँच करता है; ऑटो-डिस्कवरी केवल उन मॉडलों को पहचानती है जो मेमोरी में लोड हो चुके हैं (/api/ps रिपोर्ट करता है), और टूल सपोर्ट + कम से कम 16K कॉन्टेक्स्ट (/api/show पुष्टि करता है) ज़रूरी है। चुना गया रूट एक वास्तविक completion पास करने के बाद ही सेव होता है—डिस्कवरी प्रक्रिया कभी भी निष्क्रिय मॉडलों को अपने आप खींचती या लोड नहीं करती। इंस्टॉल हो पर लोड न हुए मॉडल ऑटो-डिस्कवर नहीं होते: डेस्कटॉप संस्करण के Model Setup में Ollama कार्ड का Choose connection → Local only चुनकर आप एक इंस्टॉल किया निष्क्रिय मॉडल लाइव जाँच से गुज़ार सकते हैं, पहले मैन्युअली लोड करने की ज़रूरत नहीं। पूरा होने पर openclaw models list --provider ollama मॉडलों की सूची दिखा सकता है।

नॉन-इंटरैक्टिव संस्करण (दोनों कस्टम पैरामीटर छोड़े जा सकते हैं):

bash
openclaw onboard --non-interactive --accept-risk --skip-health \
  --auth-choice ollama \
  --custom-base-url "http://ollama-host:11434" \
  --custom-model-id "qwen3.5:27b"

base URL छोड़ने पर लोकल डिफ़ॉल्ट होस्ट उपयोग होता है; model ID छोड़ने पर, पहले ऐसे मॉडल को प्राथमिकता मिलती है जो इंस्टॉल हो, टूल सपोर्ट करता हो, ≥16K कॉन्टेक्स्ट वाला हो (नॉन-रीज़निंग मॉडल पसंदीदा, फिर छोटा मॉडल), कोई भी योग्य न हो तो अनुशंसित gemma4 आज़माया जाता है।

तरीका B: मैन्युअल कॉन्फ़िगरेशन ​

bash
export OLLAMA_API_KEY="ollama-local"   # 本地/LAN 主机任意值即可
openclaw models set ollama/gemma4

या कॉन्फ़िग फ़ाइल में लिखें:

json5
{
  agents: {
    defaults: {
      model: { primary: "ollama/gemma4" },
    },
  },
}

⚠️ Ollama के baseUrl में /v1 न रखें (अन्य बैकएंड के विपरीत)

OpenClaw Ollama के लिए नेटिव /api/chat का उपयोग होता है, OpenAI-संगत /v1 नहीं। नेटिव पता baseUrl: "http://host:11434" लिखना अनिवार्य है—/v1 जोड़ने से टूल कॉलिंग टूट जाती है, मॉडल tool-call JSON को सादा टेक्स्ट की तरह थूक देता है। vLLM, SGLang, ds4, LM Studio इसके ठीक उलटे हैं, इनके baseUrl में /v1 ज़रूर रखें।

क्रेडेंशियल नियम: loopback, प्राइवेट नेटवर्क, .local, बेयर होस्टनेम वाले Ollama पतों** को असली token की ज़रूरत नहीं**, OpenClaw उन्हें ollama-local से चिह्नित करता है; केवल पब्लिक रिमोट होस्ट और https://ollama.com को असली OLLAMA_API_KEY या auth profile चाहिए।

Ollama Cloud (वैकल्पिक): लोकल हार्डवेयर न घेरता हुआ Ollama इकोसिस्टम ​

लोकल मॉडल नहीं चलाना चाहते, पर Ollama इकोसिस्टम के मैनेज्ड मॉडल चाहते हैं? स्टैंडअलोन provider ollama-cloud सीधे https://ollama.com से जुड़ता है, लोकल daemon की ज़रूरत नहीं:

bash
openclaw onboard --auth-choice ollama-cloud

onboarding का डिफ़ॉल्ट मॉडल ollama-cloud/minimax-m2.7; मैनेज्ड कैटलॉग में deepseek-v4-pro, glm-5.2, kimi-k3, minimax-m3, gpt-oss:20b जैसे ID शामिल हैं। हाइब्रिड मोड में लोकल होस्ट पर ollama signin करें, उसी Ollama होस्ट से लोकल मॉडल और :cloud क्लाउड मॉडल (जैसे minimax-m2.7:cloud, kimi-k3:cloud) साथ-साथ उपयोग करें।

  • openclaw models list --provider ollama आपके लोकल मॉडलों की सूची दिखाता है

कदम 3: vLLM या SGLang से जुड़ें (GPU सेल्फ-होस्टेड हाई-थ्रूपुट) ​

क्यों: अगर आपके पास GPU सर्वर या बड़ी VRAM वाली मशीन है और आप ओपन-सोर्स वेट को हाई-थ्रूपुट पर सेल्फ-होस्ट करना चाहते हैं (पिछले पाठ के LongCat के ओपन-सोर्स वेट इसी कैटेगरी में आते हैं)—vLLM और SGLang दोनों बिल्ट-इन provider हैं, OpenAI-संगत /v1, मॉडल ऑटो-डिस्कवरी सपोर्ट करते हैं।

vLLM चार कदमों में चल जाता है। पहले चार गुण याद रखें: provider id vllm, API openai-completions, प्रमाणीकरण VLLM_API_KEY, डिफ़ॉल्ट baseUrl http://127.0.0.1:8000/v1।

bash
vllm serve <model-id>              # 1. 起服务,模型 ID 换成你要托管的
export VLLM_API_KEY="vllm-local"   # 2. 服务器不鉴权时任非空值,作为启用发现的 opt-in 信号
json5
// 3. 选模型
{
  agents: {
    defaults: {
      model: { primary: "vllm/your-model-id" },
    },
  },
}
bash
openclaw models list --provider vllm   # 4. 验证

आपको यह दिखना चाहिए: models list vLLM पर मौजूद मॉडलों की सूची देता है—VLLM_API_KEY सेट हो और models.providers.vllm न लिखा हो, तो OpenClaw GET http://127.0.0.1:8000/v1/models जाँचकर मॉडल प्रविष्टियाँ अपने आप बनाता है, साथ ही DeepSeek V4 और Nemotron 3 सीरीज़ के रीज़निंग मॉडल पहचानता है (yk_deepseek_v4 जैसे उपनाम सहित)। ध्यान दें: एक बार models.providers.vllm लिख देने पर, केवल आपके हाथ से लिखे मॉडल ही मान्य होते हैं—डायनामिक बनाए रखने के लिए agents.defaults.models में वाइल्डकार्ड "vllm/*": {} जोड़ें।

नॉन-इंटरैक्टिव एक कमांड (CI / स्क्रिप्ट डिप्लॉयमेंट के लिए):

bash
openclaw onboard --non-interactive --accept-risk --skip-health \
  --mode local \
  --auth-choice vllm \
  --custom-base-url "http://127.0.0.1:8000/v1" \
  --custom-api-key "vllm-local" \
  --custom-model-id "your-model-id"

vLLM किसी दूसरी मशीन/पोर्ट पर चल रहा हो, कॉन्टेक्स्ट पैरामीटर पिन करने हों या असली Key उपयोग करनी हो, तो स्पष्ट कॉन्फ़िगरेशन लिखें (आधिकारिक उदाहरण जस-का-तस अंश):

json5
{
  models: {
    providers: {
      vllm: {
        baseUrl: "http://127.0.0.1:8000/v1",
        apiKey: "${VLLM_API_KEY}",
        api: "openai-completions",
        timeoutSeconds: 300, // 可选:给慢的本地模型延长请求超时
        models: [
          {
            id: "your-model-id",
            name: "Local vLLM Model",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 128000,
            maxTokens: 8192,
          },
        ],
      },
    },
  },
}
🔧 एडवांस्ड (वैकल्पिक): इंटरैक्टिव अनुरोधों को प्राथमिकता पर शेड्यूल करना

एक vLLM साथ-साथ इंटरैक्टिव संवाद और cron / मेमोरी-सफ़ाई जैसे बैकग्राउंड काम संभालता हो, तो पहले सर्वर साइड पर नेटिव प्रायोरिटी शेड्यूलिंग चालू करें:

bash
vllm serve <model-id> --scheduling-policy priority

फिर संबंधित मॉडल के लिए opt-in चालू करें:

json5
{
  agents: {
    defaults: {
      models: {
        "vllm/your-model-id": { params: { priorityScheduling: true } },
      },
    },
  },
}

प्रायोरिटी मैपिंग: इंटरैक्टिव टर्न और मैन्युअल /compact को -100, डेलिगेटेड या अवर्गीकृत काम को 0, cron / हार्टबीट / मेमोरी / साधारण सहायक कंप्लीशन को 100—छोटा नंबर पहले शेड्यूल होता है, टकराव पर आगमन क्रम से टाई टूटती है। यह स्विच डिफ़ॉल्ट रूप से बंद है, केवल चुने गए vllm/* मॉडलों पर लागू होता है।

SGLang पर वही तरीका (बिल्ट-इन और डिफ़ॉल्ट रूप से सक्रिय, डिफ़ॉल्ट baseUrl http://127.0.0.1:30000/v1):

bash
export SGLANG_API_KEY="sglang-local"   # 服务器不鉴权时任非空值
openclaw onboard --auth-choice sglang

गाइड में डिफ़ॉल्ट प्लेसहोल्डर मॉडल sglang/Qwen/Qwen3-8B है।SGLANG_API_KEY सेट करने और models.providers.sglang न लिखने पर भी ऑटो-डिस्कवरी वैसे ही होती है; पैरामीटर पिन करने हैं तो स्पष्ट कॉन्फ़िगरेशन लिखें, जिसका आकार vLLM से बिल्कुल मेल खाता है (vllm की जगह sglang, पोर्ट की जगह 30000)।

💡 MLX या कोई अन्य OpenAI-संगत लोकल सेवा भी जोड़ी जा सकती है

कोई भी लोकल सेवा जो OpenAI-शैली का /v1/chat/completions एक्सपोज़ करती है, रेंज में आती है: MLX (mlx_lm.server), LiteLLM, OAI-proxy आदि।पिछले पाठ के custom फ़्लो से चलें, --custom-provider-id पर एक लोकल id दें (जैसे mlx)।मॉडल id में provider का आंतरिक key वैसे ही लिखें (जैसे mlx-community/Qwen3-30B-A3B-6bit), और संदर्भित करते समय प्रीफ़िक्स लगाएं: mlx/mlx-community/Qwen3-30B-A3B-6bit।

  • openclaw models list --provider vllm (या --provider sglang) होस्ट किए गए मॉडल लिखकर दिखाता है

चरण 4: ds4 या LM Studio से जुड़ें (macOS DeepSeek और शुरुआती GUI) ​

क्यों: दो विशेष बैकएंड बाकी दो तरह की ज़रूरतें पूरी करते हैं—ds4 Mac उपयोगकर्ताओं को DeepSeek V4 Flash लोकल चलाने का रास्ता देता है; LM Studio कमांड लाइन न छूने वालों को एक GUI देता है।

ds4: macOS Metal पर लोकल DeepSeek V4 Flash ​

पहले साफ़ कर लें कि ds4 क्या है: antirez का लोकल प्रोजेक्ट (github.com/antirez/ds4), जो macOS Metal बैकएंड पर DeepSeek V4 Flash GGUF चलाकर OpenAI-संगत /v1 एक्सपोज़ करता है।यह क्लाउड सेवा नहीं है, और न ही DeepSeek का आधिकारिक उत्पाद; OpenClaw की तरफ़ से कोई प्लगइन नहीं, पूरी तरह कॉन्फ़िगरेशन से कनेक्शन।

सेवा शुरू करें (<DS4_DIR> की जगह अपना ds4 checkout पाथ लिखें):

bash
<DS4_DIR>/ds4-server \
  --model <DS4_DIR>/ds4flash.gguf \
  --host 127.0.0.1 \
  --port 18000 \
  --ctx 32768 \
  --tokens 128

आपको यह दिखना चाहिए: curl http://127.0.0.1:18000/v1/models के रिस्पॉन्स में deepseek-v4-flash शामिल है।

फिर OpenClaw कॉन्फ़िगरेशन लिखें (आधिकारिक पूर्ण कॉन्फ़िगरेशन से अंश):

json5
{
  agents: {
    defaults: {
      model: { primary: "ds4/deepseek-v4-flash" },
      models: { "ds4/deepseek-v4-flash": { alias: "DS4 local" } },
    },
  },
  models: {
    mode: "merge",
    providers: {
      ds4: {
        baseUrl: "http://127.0.0.1:18000/v1",
        apiKey: "ds4-local",
        api: "openai-completions",
        timeoutSeconds: 300,
        models: [
          {
            id: "deepseek-v4-flash",
            name: "DeepSeek V4 Flash (ds4)",
            reasoning: true,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 32768,
            maxTokens: 128,
            compat: {
              supportsUsageInStreaming: true,
              supportsReasoningEffort: true,
              maxTokensField: "max_tokens",
              supportsStrictMode: false,
              thinkingFormat: "deepseek",
              supportedReasoningEfforts: ["low", "medium", "high", "xhigh"],
            },
          },
        ],
      },
    },
  },
}

दो मुख्य बिंदु:

  • --ctx 32768 से शुरू करें: OpenClaw के agent टर्न में tool schema और workspace context आते हैं, --ctx 4096 curl सीधे टेस्ट में पास हो जाता है, लेकिन agent का पूरी क्षमता वाला टर्न 500 prompt exceeds context एरर देता है।contextWindow को --ctx से मेल रखें, maxTokens को --tokens से।
  • Think Max को बड़ा कॉन्टेक्स्ट चाहिए: ds4-server --ctx 393216 और अनुरोध में reasoning_effort: "max" होने पर ही सक्रिय होता है; तब मॉडल मेटाडेटा सिंक होकर contextWindow: 393216, maxTokens: 384000, supportedReasoningEfforts में "max" जुड़ जाता है।
🔧 ज़रूरत पर शुरू: OpenClaw को ds4 तभी खींचने दें जब इस्तेमाल हो

ds4 को हमेशा चलते रहकर मेमोरी खाने नहीं देना चाहते? उसी provider एंट्री में localService जोड़ें, OpenClaw ds4/... मॉडल चुने जाने पर सेवा अपने आप शुरू कर देगा (आधिकारिक उदाहरण वैसा ही):

json5
{
  models: {
    providers: {
      ds4: {
        baseUrl: "http://127.0.0.1:18000/v1",
        apiKey: "ds4-local",
        api: "openai-completions",
        timeoutSeconds: 300,
        localService: {
          command: "<DS4_DIR>/ds4-server",
          args: [
            "--model",
            "<DS4_DIR>/ds4flash.gguf",
            "--host",
            "127.0.0.1",
            "--port",
            "18000",
            "--ctx",
            "32768",
            "--tokens",
            "128",
          ],
          cwd: "<DS4_DIR>",
          healthUrl: "http://127.0.0.1:18000/v1/models",
          readyTimeoutMs: 300000,
          idleStopMs: 0,
        },
        models: [
          {
            id: "deepseek-v4-flash",
            name: "DeepSeek V4 Flash (ds4)",
            reasoning: true,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 32768,
            maxTokens: 128,
            compat: {
              supportsUsageInStreaming: true,
              supportsReasoningEffort: true,
              maxTokensField: "max_tokens",
              supportsStrictMode: false,
              thinkingFormat: "deepseek",
              supportedReasoningEfforts: ["low", "medium", "high", "xhigh"],
            },
          },
        ],
      },
    },
  },
}

तीन फ़ील्ड ग़लत न लिखें: command पूर्णतः निरपेक्ष executable पाथ होना चाहिए (shell lookup नहीं होता, ~ expand नहीं होता); readyTimeoutMs: 300000 में 5 मिनट पूरे दें—ds4 में ठंडे Metal के रेज़िडेंट और मॉडल प्री-वॉर्म चरण होते हैं, पहला अनुरोध धीमा ही होगा; healthUrl में /v1/models से लाइवनेस जांचें।

LM Studio: GUI लोडर, onboarding पूरी तरह ऑटोमैटिक ​

LM Studio GUI से llama.cpp (GGUF) या MLX मॉडल चलाता है, और headless llmster daemon भी है।इंस्टॉल के बाद तीन चरण:

bash
lms server start --port 1234        # 1. 起本地服务(headless 版用 lms daemon up)
export LM_API_TOKEN="your-lm-studio-api-token"   # 2. LM Studio 开了认证才需要,没开就留空
openclaw onboard                    # 3. 选 LM Studio,在 Default model 提示里挑模型

आपको यह दिखना चाहिए: onboarding पहले LM Studio होस्ट का /api/v1/models जांचता है, केवल वही मॉडल ऑटो-सुझाए जाते हैं जिन्हें LM Studio "टूल ट्रेनिंग + कम से कम 16K वैध कॉन्टेक्स्ट" वाला रिपोर्ट करता है (लोड किए गए मॉडल का हिसाब लोडेड इंस्टेंस के कॉन्टेक्स्ट से लगता है, विज्ञापित अधिकतम से नहीं); चुनने के बाद एक वास्तविक completion चलाने पर ही सेव होता है, और ऑटो-चेक कभी भी आपके लिए मॉडल डाउनलोड नहीं करता।

LM Studio का मॉडल key author/model-name फ़ॉर्मैट में होता है (जैसे qwen/qwen3.5-9b), OpenClaw में संदर्भित करते समय provider प्रीफ़िक्स लगाएं: lmstudio/qwen/qwen3.5-9b।सटीक key देखने, डिफ़ॉल्ट बदलने, नया मॉडल इंस्टॉल करके रिफ़्रेश करने के लिए:

bash
curl http://localhost:1234/api/v1/models              # 看返回里的 key 字段
openclaw models set lmstudio/qwen/qwen3.5-9b
openclaw models list --provider lmstudio --refresh    # 装了新模型后刷新目录

डिफ़ॉल्ट merge मोड में, --refresh नए खोजे गए मॉडल जोड़ता है और आपकी हाथ से लिखी एंट्री का मेटाडेटा (नाम, कॉन्टेक्स्ट सीमा आदि) बनाए रखता है।नॉन-इंटरैक्टिव संस्करण: openclaw onboard --non-interactive --accept-risk --skip-health --auth-choice lmstudio; सभी पैरामीटर स्पष्ट रूप से देने हों तो --custom-base-url http://localhost:1234/v1 --lmstudio-api-key "$LM_API_TOKEN" --custom-model-id qwen/qwen3.5-9b और जोड़ें।

  • openclaw models list --provider ds4 (या --provider lmstudio) आपके मॉडल दिखा सकता है

चरण 5: चेन सत्यापित करें और हाइब्रिड फ़ॉलबैक कॉन्फ़िगर करें ​

क्यों: कॉन्फ़िगरेशन डिस्क पर लिखा जाना ≠ agent काम कर सकना।"मॉडल जवाब दे सकता है", "Gateway राउटिंग सही है", "टूल वास्तव में चलते हैं"—ये तीन परतें हैं, और आधिकारिक तौर पर परत-वार डायग्नोस्टिक कमांड दिए गए हैं—कौन सी परत टूटी है, पता रहेगा कि कहाँ ठीक करना है।

bash
# 第一层:模型本身能不能回话(不带工具、不带 agent 上下文)
openclaw infer model run --local --model <provider/model> --prompt "Reply with exactly: pong" --json

# 第二层:Gateway 路由通不通(只发 prompt,跳过 transcript、工具与内置 MCP,
# 但仍走完整的 Gateway 路由、auth 与 provider 选择)
openclaw infer model run --gateway --model <provider/model> --prompt "Reply with exactly: pong" --json

तीसरी परत: टूल स्मोक टेस्ट, एक पूरा agent टर्न चलाएं (ds4 उदाहरण के रूप में):

bash
openclaw agent \
  --local \
  --session-id ds4-tool-smoke \
  --model ds4/deepseek-v4-flash \
  --thinking off \
  --message "Use the shell command pwd once, then reply exactly: tool-ok <output>" \
  --json \
  --timeout 240

आपको यह दिखना चाहिए: executionTrace.winnerProvider ds4 है, executionTrace.winnerModel deepseek-v4-flash है, toolSummary.calls कम से कम 1 है, और दिखने वाला जवाब tool-ok से शुरू होता है—टूल वास्तव में चले, मॉडल ने आपको सुनाकर JSON नहीं पढ़ा।

सब पास होने पर, जो मॉडल सहज लगे उसे रोज़मर्रा का डिफ़ॉल्ट बनाएं:

bash
openclaw models set <provider/model>

बिना सेवा रुके पैसे बचाना चाहते हैं तो एक हाइब्रिड फ़ॉलबैक परत और कॉन्फ़िगर करें—आधिकारिक local-models गाइड की सिफ़ारिश: लोकल पहले, क्लाउड फ़ॉलबैक; provider एरर होने पर प्रति टर्न अगले fallback पर गिरता है (आधिकारिक उदाहरण में primary/fallbacks क्रम उलटने से बना है):

json5
{
  agents: {
    defaults: {
      model: {
        primary: "lmstudio/my-local-model",   // 本地优先
        fallbacks: ["anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6"],
      },
      models: {
        "anthropic/claude-sonnet-4-6": { alias: "Sonnet" },
        "lmstudio/my-local-model": { alias: "Local" },
        "anthropic/claude-opus-4-6": { alias: "Opus" },
      },
    },
  },
  models: {
    mode: "merge",   // merge 保住云端模型目录,随时 /model 切换
    providers: {
      lmstudio: {
        baseUrl: "http://127.0.0.1:1234/v1",
        apiKey: "lmstudio",
        api: "openai-responses",
        models: [
          {
            id: "my-local-model",
            name: "Local Model",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 196608,
            maxTokens: 8192,
          },
        ],
      },
    },
  },
}

क्लाउड पहले, लोकल फ़ॉलबैक चाहिए तो primary/fallbacks उलट दें, providers ब्लॉक और models.mode: "merge" वैसे ही रखें।ध्यान दें कि fallback "एरर होने पर ही स्विच" वाला प्रति टर्न स्विच है; छोटे अनुरोध लोकल पर रखने और सिर्फ़ बहुत बड़े अनुरोधों पर क्लाउड जाने वाला प्रति अनुरोध राउटिंग चाहिए तो आधिकारिक गाइड llmman के Hybrid inference की ओर इशारा करता है।

  • तीनों परतों का सत्यापन पास: दो स्तर का pong + टूल स्मोक toolSummary.calls ≥ 1

चेकपॉइंट ✅ ​

  • आधिकारिक चयन तालिका के अनुसार सही बैकएंड चुना: Ollama (CLI) / vLLM, SGLang (GPU हाई-थ्रूपुट) / ds4 (macOS DeepSeek) / LM Studio (GUI)
  • openclaw models list --provider <id> आपके लोकल मॉडल सूचीबद्ध कर सकता है
  • Ollama का baseUrl http://host:11434 है (/v1 नहीं); vLLM / SGLang / ds4 / LM Studio सभी में /v1 शामिल है
  • openclaw infer model run --local और --gateway दोनों pong लौटाते हैं
  • agent स्मोक टेस्ट में toolSummary.calls ≥ 1—टूल कॉल वास्तव में चले, JSON टेक्स्ट थूका नहीं गया
  • बिना सेवा रुके पैसे बचाना चाहते हैं: fallbacks हाइब्रिड योजना कॉन्फ़िगर की, models.mode: "merge" से क्लाउड मॉडल कैटलॉग बरक़रार रखा

ख़ामियों से बचने की चेतावनी ​

❌ Ollama baseUrl में /v1 शामिल था——टूल कॉल पूरी तरह ख़राब ​

Ollama नेटिव /api/chat एडॉप्टर से चलता है, baseUrl ज़रूरी तौर पर http://host:11434 होना चाहिए (बिना /v1)। /v1 शामिल होने पर OpenAI कम्पैटिबल मोड चलेगा, टूल कॉल ख़राब हो जाएँगे, मॉडल tool-call JSON को सादा टेक्स्ट की तरह थूक देगा। यह vLLM / SGLang / ds4 / LM Studio (सबको /v1 चाहिए) से बिल्कुल उल्टा है——याद न रहे तो याद रखें「Ollama अपने तौर पर चलता है」。

❌ ds4 --ctx 4096:curl चल जाता है, agent राउंड 500 ​

500 prompt exceeds context का कारण: OpenClaw के agent राउंड में टूल schema और workspace कॉन्टेक्स्ट होता है, जो एक curl टेस्ट मैसेज से कहीं बड़ा होता है। ds4-server --ctx कम से कम 32768 रखें, और models.providers.ds4.models[].contextWindow को अलाइन करें। Think Max के लिए तो --ctx 393216 से शुरू करना ही चाहिए।

❌ लोकल मॉडल「जवाब दे देता है」, लेकिन टूल कॉल रॉ JSON/XML टेक्स्ट की तरह दिखते हैं ​

पहले चरण 5 के अनुसार परत-दर-परत डायग्नोसिस करें। अगर दोनों स्तर infer model run चल जाएँ पर पूरा राउंड बिगड़ जाए, तो क्रम से जाँचें:

  1. लोकल Ollama मॉडल, LM Studio, होस्ट किए गए लोकल सर्विस tools.toolSearch सेट न होने परस्ट्रक्चर्ड Tool Search अपने आप चालू करते हैं (schema भेजना टालते हैं, क्षमता बनाए रखते हैं)——इसे बंद न करें।
  2. vLLM यूज़र पहले पुष्टि करें कि स्टार्टअप पर सही tool-call parser और chat template साथ हैं (vLLM आधिकारिक दस्तावेज़: Qwen2.5 के लिए hermes, Qwen3-Coder के लिए qwen3_xml)।
  3. फिर भी न चलने पर समर्पित मॉडल एंट्री में params.extra_body.tool_choice: "required" जोड़कर टूल कॉल ज़बरदस्ती चालू किया जा सकता है——सिर्फ़ उन मॉडलों के लिए जिन्हें「हर राउंड में टूल कॉल करना चाहिए」, ग्लोबल डिफ़ॉल्ट मत बनाएँ।
  4. आख़िरी उपाय: उस मॉडल का compat.supportsTools: false बंद कर दें; या लीन मोड agents.defaults.experimental.localModelLean: true चालू करें (browser, automations, message, image_generate, music_generate, video_generate, tts, pdf जैसे बड़े schema टूल हटा देता है)।

❌ धीमे मॉडल / ठंडे मॉडल का टाइमआउट ​

लोकल बड़े मॉडल का पहला token धीमा, LM Studio का कोल्ड लोड, ds4 का कोल्ड वॉर्मअप——सब आम है। provider एंट्री में timeoutSeconds सेट करें (जैसे 300)——यह कनेक्शन, रिस्पॉन्स हेडर, स्ट्रीमिंग body और कुल एबॉर्ट को कवर करता है, और ग्लोबल agents.defaults.timeoutSeconds पर प्राथमिकता रखता है। ds4 कोल्ड स्टार्ट के लिए अलग से localService.readyTimeoutMs: 300000 कॉन्फ़िगर करें।

❌ WSL2 + Ollama + NVIDIA/CUDA: वर्चुअल मशीन बार-बार रीस्टार्ट ​

आधिकारिक Ollama Linux इंस्टॉलर Restart=always वाली systemd सर्विस चालू करता है। WSL2 GPU एनवायरनमेंट में, बूट पर ऑटो-स्टार्ट पिछला मॉडल दोबारा लोड करता है, होस्ट मेमोरी जकड़ लेता है, और WSL2 VM को बार-बार रीस्टार्ट के चक्र में धकेल देता है (आधिकारिक ट्रबलशूटिंग पेज इसे WSL2 crash loop कहता है)। WSL2 में Ollama को बूट पर अपने आप मॉडल लोड न करने दें।

❌ कॉन्टेक्स्ट बजट की ग़लत समझ: आउटपुट कट गया, ऊपरी सीमा के पास सिर्फ़ एक token बचा ​

OpenClaw मॉडल विंडो के हिसाब से प्री-चेक करता है: मार्जिन 20% से कम होने पर चेतावनी (8k न्यूनतम), 10% से कम होने पर हार्ड ब्लॉक (4k न्यूनतम)। डिस्कवरी से जुड़े लोकल Ollama मॉडल का डिफ़ॉल्ट आउटपुट लिमिट 8,192 token है (OpenClaw आउटपुट लिमिट को num_predict की तरह नेटिव Ollama को भेजता है); Ollama की असीमित डिफ़ॉल्ट वापस लाने के लिए params: { num_predict: -1 } सेट करें। कस्टम मॉडल एंट्री में contextWindow/maxTokens असली वैल्यू लिखें, 200000 का फ़ॉलबैक डिफ़ॉल्ट मत अपनाएँ।

❌ Gateway डेमन की तरह चलने के बाद, export किया Key「लागू नहीं होता」 ​

पुराना ख़ामी दोहराया जा रहा है: launchd / systemd सर्विस इंटरैक्टिव shell के एनवायरनमेंट वेरिएबल नहीं देखती। OLLAMA_API_KEY, VLLM_API_KEY, SGLANG_API_KEY, LM_API_TOKEN को ~/.openclaw/.env में लिखें, या कॉन्फ़िगरेशन के env.shellEnv से उस प्रोसेस को दें।

❌ लोकल मॉडल को「मुफ़्त क्लाउड विकल्प」समझना, सुरक्षा में नंगे दौड़ना ​

लोकल मॉडल मेंहोस्टिंग प्रोवाइडर का सुरक्षा फ़िल्टर नहीं होता, और मॉडल जितना कमज़ोर, उतना आसानी से वेबपेज या फ़ाइल के इंजेक्शन निर्देशों में उलझ जाता है। टूल परमिशन सीमित रखें, compaction चालू रखें, ग्रुप-चैट सेशन के लिए सैंडबॉक्स पर विचार करें——आधिकारिक local-models गाइड के शब्द: keep tool permissions and prompt-injection defenses appropriate for the model and task। हार्डनिंग तरीक़े देखेंसुरक्षा हार्डनिंग (1): एक्सेस कंट्रोल और पहचान।

अगला क़दम ​

क्विक स्टार्ट का पूरा चैप्टर यहीं पूरा: इंस्टॉलेशन, मॉडल कनेक्शन (घरेलू पूरा सेट + रिले + लोकल मॉडल) सब काम कर रहे हैं। आगे:

संबंधित ट्यूटोरियल ​

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.