Recursive Flint: Claude Code, OpenCode और Cline में लोकल चलाएँ

Claude Code, OpenCode या Cline में लोकल कोडिंग आज़माने के लिए किसी संगत Mac पर Ollama के ज़रिए Recursive Flint चलाएँ। अगर आपके कंप्यूटर में मॉडल के लिए पर्याप्त मेमोरी नहीं है, तो पहले गैर-संवेदनशील कोड के साथ OpenCode का अस्थायी क्लाउड विकल्प आज़माएँ। शुरुआत एक सीमित काम और स्पष्ट टेस्ट से करें, और बार-बार अटकने वाले काम के लिए अपना मौजूदा क्लाउड मॉडल उपलब्ध रखें।

नीचे दी गई उपलब्धता और कॉन्फ़िगरेशन की जानकारी 2026-10-23 की स्थिति के अनुसार है।

Recursive Flint में क्या नया है?

Flint में वेट का बड़ा संग्रह है, लेकिन हर नया टोकन बनाने के लिए अपेक्षाकृत कम गणना करनी पड़ती है। इसके आधिकारिक मॉडल कार्ड में कुल 39.8B पैरामीटर और प्रति टोकन लगभग 2.5B सक्रिय पैरामीटर, टेक्स्ट इनपुट और आउटपुट, तथा Apache 2.0 लाइसेंस के तहत वेट दिए गए हैं। Mixture-of-experts यानी विशेषज्ञों के मिश्रण वाली संरचना में हर टोकन के लिए कुछ विशेषज्ञ सक्रिय होते हैं; निष्क्रिय वेट भी स्टोरेज और मेमोरी लेते हैं।

Flint रीज़निंग का आउटपुट देता है और टूल कॉल का अनुरोध करता है। फ़ाइलें पढ़ना, बदलाव करना और टर्मिनल कमांड चलाना आपके कोडिंग क्लाइंट का काम है; वह इनके नतीजे वापस मॉडल को भेजता है। इसलिए मॉडल, उसे चलाने वाले इन्फ़रेंस रनटाइम और कोडिंग क्लाइंट की एक साथ जाँच करें।

Recursive अपने अनुकूलित इंजन और छोटे कॉन्टेक्स्ट के साथ M4 Pro MacBook Pro पर 125 tokens/s से अधिक और 64GB वाले RTX Spark पर 150 tokens/s से अधिक गति बताता है। ये कंपनी द्वारा बताई गई जनरेशन दरें हैं; ये Ollama या Cline में सही कोड बदलाव तैयार होने तक लगने वाले समय के माप नहीं हैं।

उसी कॉन्टेक्स्ट सीमा का इस्तेमाल करें जो आपका रनटाइम वास्तव में कॉन्फ़िगर करता है। मॉडल कार्ड में इनपुट और आउटपुट के लिए साझा 262,144 tokens दर्ज हैं; घोषणा में 512K तक का उल्लेख है, लेकिन 256K के भीतर रहने की सलाह दी गई है। इनमें से कोई भी संख्या यह गारंटी नहीं देती कि आपका लैपटॉप पूरी विंडो के लिए मेमोरी दे पाएगा।

Flint के लिए कितनी मेमोरी चाहिए?

वेट, कॉन्टेक्स्ट कैश, गणना के बफ़र और बाकी ऐप्लिकेशन के लिए मेमोरी रखें। लगभग 23GB की डाउनलोड फ़ाइल का मतलब यह नहीं है कि Flint किसी 24GB वाले कंप्यूटर पर आराम से चल जाएगा।

चलाने का तरीका	प्रकाशित हार्डवेयर और स्टोरेज की जरूरतें	आपके लिए इसका मतलब
Recursive का अनुकूलित rec इंजन	M4 Pro, M5 Pro या M5 Max; कम से कम 48GB यूनिफ़ाइड मेमोरी; लगभग 30GB खाली डिस्क	यह Mac पर rec की दस्तावेज़ में दी गई जरूरत है, हर Ollama सेटअप का न्यूनतम नहीं।
Ollama का flint पैकेज	अभी डिफ़ॉल्ट डाउनलोड 23GB है; v0.40.8 में Flint का समर्थन सिर्फ macOS पर है	पैकेज के आकार से अधिक मेमोरी खाली रखें और आवंटित कॉन्टेक्स्ट जाँचें।
संगत llama.cpp/CUDA के साथ NVIDIA NVFP4 GGUF	मॉडल फ़ाइल 22.9GB; Recursive कम से कम 48GB GPU मेमोरी या Spark पर यूनिफ़ाइड मेमोरी की सलाह देता है	RTX Spark और DGX Spark जाँचे गए उपकरण हैं। लॉन्च के समय 64GB पर किया गया प्रदर्शन प्रकाशित न्यूनतम जरूरत नहीं है।
BF16 के लिए SGLang सर्वर बंडल	हर इंस्टेंस (रेप्लिका) के लिए कम से कम 141GB VRAM के साथ B300 या H200 पर सत्यापित; लगभग 80GB वेट और 50GB कंटेनर इमेज	यह अलग सर्वर सेटअप है, जो आम लैपटॉप के हार्डवेयर से आगे की जरूरत रखता है।

ये आँकड़े rec की जरूरतों, Ollama की मॉडल सूची, NVIDIA के लिए आधिकारिक क्वांटाइज़्ड मॉडल कार्ड और SGLang डिप्लॉयमेंट गाइड से लिए गए हैं।

macOS की सीमा Ollama v0.40.8 में Flint के कार्यान्वयन पर लागू है; अन्य GPU का समर्थन बाद की किसी रिलीज़ के लिए रखा गया है। दूसरे रनटाइम के लिए NVIDIA-संगत वेट पहले से मौजूद हैं, लेकिन इससे यह साबित नहीं होता कि यही Ollama कमांड Windows/Linux पर भी Flint चला सकती है।

Flint को Ollama से लोकल चलाएँ

Ollama इंस्टॉल या अपडेट करें, उसकी सर्विस चालू रखें और कोडिंग क्लाइंट जोड़ने से पहले मॉडल से एक सामान्य जवाब लेकर देखें। Ollama की Mac इंस्टॉलेशन गाइड के अनुसार macOS Sonoma 14 या नया संस्करण चाहिए।

Bash में चलाएँ:

ollama --version
ollama run flint

दूसरी कमांड जरूरत पड़ने पर मॉडल डाउनलोड करती है और चैट खोलती है। उससे किसी छोटे फ़ंक्शन को समझाने के लिए कहें, फिर उस चैट से बाहर निकलें।

कोडिंग क्लाइंट के लिए Ollama ऐप की सेटिंग्स में कम से कम 64K कॉन्टेक्स्ट आवंटित करें। Claude Code और OpenCode, दोनों की इंटीग्रेशन गाइड यही आकार सुझाती हैं। बड़ा कॉन्टेक्स्ट अधिक मेमोरी लेता है; अगर वह मेमोरी में नहीं समाता, तो क्लाउड विकल्प या दूसरा हार्डवेयर चुनें।

जब कोई अनुरोध चल रहा हो, तो दूसरे टर्मिनल से सर्वर जाँचें:

ollama ps

देखें कि सूची में Flint मौजूद है, CONTEXT जाँचें और GPU पर कितना काम जा रहा है यह देखने के लिए PROCESSOR देखें। कॉन्टेक्स्ट दस्तावेज़ इन फ़ील्ड को समझाता है। मॉडल की बताई गई अधिकतम सीमा और इस समय आवंटित कॉन्टेक्स्ट अलग हो सकते हैं।

अगर कोई भी क्लाइंट कनेक्ट नहीं हो पा रहा, तो पहले Ollama ऐप खोलें और ollama run flint दोबारा चलाएँ। अगर किसी क्लाइंट की सूची में Flint नहीं दिखता, तो ollama pull flint चलाकर सूची रीफ़्रेश करें।

एक कोडिंग टूल जोड़ें और फ़ाइल में बदलाव जाँचें

अपना मौजूदा क्लाइंट चुनें और जाँच के लिए खाली डायरेक्टरी या रिपॉज़िटरी की अस्थायी ब्रांच खोलें। नीचे दिए तरीके एक ही लोकल मॉडल से जुड़ने के अलग-अलग विकल्प हैं।

Claude Code

अगर Claude Code क्लाइंट इंस्टॉल है, तो उसे Ollama के लॉन्चर से खोलें:

ollama launch claude --model flint

यह कमांड Ollama पर Flint के पेज में प्रकाशित है। लॉन्चर Claude Code को Ollama के Anthropic-संगत एंडपॉइंट से जोड़ता है; Ollama पर लोकल इन्फ़रेंस के लिए मॉडल प्रोवाइडर की API कुंजी डालने की जरूरत नहीं है।

Claude Code के अंदर /status चलाकर चुना गया मॉडल और कनेक्शन देखें। पुष्टि करें कि एंडपॉइंट लोकल है, आम तौर पर http://localhost:11434, और अनुरोध के दौरान ollama ps के आउटपुट से उसका मिलान करें। मॉडल से उसका नाम पूछना यह जाँचने का तरीका नहीं है कि अनुरोध किस सर्वर पर गया।

अगर Claude Code अभी भी पुराना एंडपॉइंट इस्तेमाल करता है, तो ~/.claude/settings.json, प्रोजेक्ट की सेटिंग्स और शेल कॉन्फ़िगरेशन में ANTHROPIC_BASE_URL तथा ऑथेंटिकेशन या मॉडल को बदलने वाली संबंधित सेटिंग्स जाँचें। Claude की सेटिंग्स शेल से मिले मानों को ओवरराइड कर सकती हैं। संगठन द्वारा लागू प्रतिबंध भी बने रहते हैं।

OpenCode

अपने प्रोजेक्ट की डायरेक्टरी से लोकल मॉडल लॉन्च करें:

ollama launch opencode --model flint

Ollama यही कमांड प्रकाशित करता है। OpenCode के /models विकल्प में पुष्टि करें कि सक्रिय प्रोवाइडर Ollama और मॉडल Flint है। क्लाउड में चलने वाला Flint 40B Free अलग कनेक्शन है।

अगर OpenCode इंस्टॉल नहीं है, तो उसके मौजूदा इंस्टॉलेशन निर्देश अपनाएँ। लॉन्चर का तरीका अपनाने पर OpenCode के अलग-अलग कॉन्फ़िगरेशन संस्करणों के लिए प्रोवाइडर का JSON उदाहरण हाथ से बनाए रखने की जरूरत नहीं पड़ती।

Cline

Cline में पहले से उपलब्ध Ollama प्रोवाइडर चुनें:

1. Cline Settings खोलें और Ollama चुनें।
2. Base URL में http://localhost:11434 भरें।
3. flint या डाउनलोड किया गया टैग flint:latest चुनें।
4. Settings → Features में Use Compact Prompt चालू करें।

ये कदम Cline के लोकल मॉडल निर्देशों पर आधारित हैं। Cline का यह Ollama प्रोवाइडर ऊपर वाला पता बिना /v1 इस्तेमाल करता है। नीचे दिए टेस्ट के लिए Cline से फ़ाइलों में बदलाव और कमांड चलवाने हों, तो Act मोड चुनें।

वास्तविक बदलाव और टेस्ट रन की जाँच करें

टूल इस्तेमाल करने का पूरा चक्र जाँचने के लिए यह छोटा काम दें। इसमें फ़ाइलें बनाना, स्ट्रिंग को हाइफ़न वाले पहचानकर्ता में बदलने का फ़ंक्शन लिखना और उसके टेस्ट चलाना शामिल है:

Create slugify.py with a slugify(text) function. Lowercase ASCII letters, replace each run of non-alphanumeric characters with one hyphen, and remove leading and trailing hyphens.

Create test_slugify.py using unittest. Check that "Hello, World!" becomes "hello-world", "  A__B  " becomes "a-b", and an empty string stays empty.

Run python3 -m unittest -v. Show the changed files and the actual test result. Use only the Python standard library.

Python 3 उपलब्ध होना चाहिए; फ़ाइल और टर्मिनल की जरूरी कार्रवाइयों की अनुमति दें। सफलता का मतलब है कि फ़ाइलें मौजूद हों और टूल लॉग में टेस्ट कमांड पूरी होने के साथ एग्ज़िट स्टेटस 0 दिखे। कोड और टेस्ट खुद देखें; केवल मॉडल का यह कह देना कि टेस्ट पास हो गए, पर्याप्त नहीं है।

यह इंटीग्रेशन जाँचने का सुझाया गया उदाहरण है, किसी बेंचमार्क का परिणाम नहीं। अगर सामान्य चैट चलती है लेकिन फ़ाइल बदलना या कमांड चलाना विफल होता है, तो मॉडल की गुणवत्ता पर फैसला करने से पहले क्लाइंट की अनुमतियाँ, आवंटित कॉन्टेक्स्ट और चुना हुआ प्रोवाइडर जाँचें।

मॉडल डाउनलोड किए बिना क्लाउड में Flint आज़माएँ

लोकल मेमोरी या हार्डवेयर पर संसाधन लगाने से पहले किसी गैर-संवेदनशील काम के लिए OpenCode का मुफ्त क्लाउड विकल्प आज़माएँ। OpenCode इंस्टॉल होने पर Bash में opencode चलाएँ, /models खोलें और Flint 40B Free चुनें।

चयन के लिए सटीक पहचानकर्ता opencode/flint-40b-free है। OpenCode का मॉडल कैटलॉग इसे सीमित समय के लिए मुफ्त बताता है; उसके होमपेज के अनुसार शामिल मुफ्त मॉडल बिना खाता बनाए इस्तेमाल किए जा सकते हैं। Recursive बताता है कि क्लाउड पहुँच उपलब्ध क्षमता और अनुरोध दर की सीमाओं पर निर्भर है।

क्लाउड विकल्प में डेटा आपके लोकल इन्फ़रेंस की सीमा के भीतर नहीं रहता। OpenCode के अनुसार Flint का उपयोग करते समय इकट्ठा किया गया डेटा मॉडल सुधारने में इस्तेमाल हो सकता है और 30 दिन तक रखा जाता है। केवल ऐसा प्रोजेक्ट इस्तेमाल करें जिसे उस सर्विस को भेजने की अनुमति हो।

अगर मुफ्त विकल्प उपलब्ध नहीं है, तो मौजूदा कैटलॉग देखें; हमेशा मुफ्त पहुँच मिलने की धारणा न बनाएँ। गोपनीय कोड के लिए उपयुक्त लोकल सेटअप या ऐसा अलग प्रोवाइडर चुनें जिसे वह कोड भेजने की मंज़ूरी हो।

GPU पर OpenAI-संगत API से Flint उपलब्ध कराएँ

जब आपको सर्वर API चाहिए और आपके पास समर्थित डेटासेंटर GPU हो, तो Recursive का दिया हुआ SGLang बंडल इस्तेमाल करें। BF16 सेटअप के लिए Linux, Docker, NVIDIA Container Toolkit और संगत ड्राइवर चाहिए; 80GB वाला GPU इसकी एक रेप्लिका की जरूरत पूरी नहीं करता।

सर्वर बंडल के README में SGLang 0.5.16 के लिए Flint प्लगइन और संशोधित कर्नेल दिए गए हैं। केवल सामान्य इंस्टॉलेशन पर्याप्त नहीं है। ये Bash कमांड रिपॉज़िटरी की एक रिविज़न तय करती हैं और उसी के वेट तथा सर्वर फ़ाइलें साथ रखती हैं:

python3 -m venv .venv-flint
source .venv-flint/bin/activate
python3 -m pip install -U huggingface_hub openai

FLINT_REV=$(python3 -c 'from huggingface_hub import HfApi; print(HfApi().model_info("RecursiveSI/flint").sha)')
hf download RecursiveSI/flint --revision "$FLINT_REV" --local-dir "flint-$FLINT_REV"
cd "flint-$FLINT_REV"
hf cache verify RecursiveSI/flint --revision "$FLINT_REV" --local-dir .
docker build -t "flint-sglang:${FLINT_REV:0:12}" sglang

डाउनलोड, सत्यापन और इमेज बिल्ड सफल होने के बाद H200 पर लॉन्च करें:

docker run -d --name flint --gpus '"device=0"' --ipc=host \
  -p 127.0.0.1:30000:30000 \
  -v "$PWD:/model" -e MODEL=/model \
  "flint-sglang:${FLINT_REV:0:12}" \
  bash /model/sglang/serve_h200.sh

B300 के लिए इसकी जगह serve_b300.sh इस्तेमाल करें। डिप्लॉयमेंट गाइड की ड्राइवर जरूरतें मानें: CUDA 13 के लिए आम तौर पर R580 या नया ड्राइवर चाहिए। H200 सेटअप में इमेज की कम्पैटिबिलिटी लाइब्रेरी के ज़रिए ड्राइवर 570.133.20 के साथ संगतता भी दर्ज है।

स्टार्टअप असिंक्रोनस है, इसलिए कमांड लौटने के बाद भी सर्वर तैयार होने में समय लग सकता है। docker logs -f flint देखें और तैयारी पूरी होने का इंतज़ार करें; फिर दूसरे टर्मिनल में जाँचें:

curl --fail --silent --show-error http://127.0.0.1:30000/health_generate

तैयारी की जाँच का सफल जवाब मिलने पर अनुरोध भेज सकते हैं:

curl --fail --silent --show-error \
  http://127.0.0.1:30000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "flint",
    "messages": [
      {"role": "user", "content": "Write a Python function that merges overlapping intervals."}
    ],
    "max_tokens": 32768
  }'

जवाब choices[0].message.content में पढ़ें। सर्वर पर मॉडल ID flint है और क्लाइंट का बेस URL http://127.0.0.1:30000/v1 है। इस सेटअप में API ऑथेंटिकेशन नहीं है और सर्विस केवल लोकल लूपबैक इंटरफ़ेस पर खुलती है; दूसरे कंप्यूटरों के लिए खोलने से पहले पहुँच पर ऑथेंटिकेशन लगाएँ।

बंडल के चैट टेम्पलेट और पार्सर बनाए रखें। सुझाई गई सैंपलिंग सेटिंग्स हैं: temperature 1.0, top_p 0.95 और top_k 20। बाद के अनुरोधों में असिस्टेंट के संदेश वापस भेजते समय लौटे हुए reasoning_content को बनाए रखें। अगर finish_reason का मान length है, तो अंतिम जवाब या टूल कॉल से पहले ही रीज़निंग ने आउटपुट सीमा खर्च कर दी हो सकती है।

टूल कॉल और उसका परिणाम वापस भेजने का चक्र जाँचने के लिए बंडल की डायरेक्टरी से python3 sglang/example_client.py --base-url http://127.0.0.1:30000/v1 चलाएँ। अगर सर्वर कभी तैयार नहीं होता, तो क्लाइंट की जाँच करने से पहले कंटेनर लॉग में ड्राइवर, मेमोरी या बंडल लोड होने की त्रुटियाँ देखें।

कोडिंग बेंचमार्क से वास्तव में क्या पता चलता है?

प्रकाशित स्कोर को अपनी जरूरत पर Flint आज़माने का कारण मानें, लेकिन मूल्यांकन की सेटिंग्स साथ में देखें। वे यह साबित नहीं करते कि Flint हर Qwen या बड़े क्लाउड मॉडल का विकल्प है।

बेंचमार्क	रिलीज़ के समय Recursive द्वारा प्रकाशित Flint का परिणाम	संबंधित प्रकाशित तुलना
Terminal-Bench 2.1	54.9%	डेंस Qwen3.8-27B: Qwen के मूल्यांकन में 73.0%
SWE-bench Verified	74.2%	Qwen3.6-35B-A3B: Qwen के मूल्यांकन में 73.4%
SWE-bench Pro v2	89.7%	इस तुलना में पुराने, बिना संस्करण वाले Pro स्कोर न रखें।

ये आँकड़े Flint, Qwen3.8-27B और Qwen3.6-35B-A3B के मॉडल कार्ड में प्रकाशित हैं।

Recursive Terminal-Bench के लिए Terminus 2 और SWE बेंचमार्क के लिए mini-swe-agent इस्तेमाल करता है। उसके Terminal-Bench रन में इंटरनेट की अनुमति है, लेकिन वेब से खोजकर प्राप्त समाधानों को असफल गिना जाता है। Qwen की प्रकाशित तुलना से यह साबित नहीं होता कि उसने भी यही समायोजन किया; Qwen3.6 अपने SWE एजेंट के लिए अलग व्यवस्था भी इस्तेमाल करता है।

Pro v2 की व्याख्या में एक और सीमा है। Scale का निर्धारित प्रोटोकॉल हर काम के लिए 50 मिनट देता है और साफ़ वातावरण में पैच का दोबारा मूल्यांकन करवाता है। Recursive के मूल्यांकन संबंधी सामान्य नोट में एजेंट के लिए अधिकतम पाँच घंटे तक का टाइमआउट है, लेकिन यह स्पष्ट नहीं किया गया कि इस खास बेंचमार्क के नियम उस प्रोटोकॉल से मेल खाते हैं या नहीं। इसलिए 89.7% को Recursive का रिलीज़ परिणाम कहें, निर्धारित प्रोटोकॉल के तहत स्वतंत्र रूप से प्रमाणित परिणाम नहीं।

अगर Qwen3.6 पहले से आपके काम भरोसेमंद तरीके से पूरे करता है, तो Verified पर प्रकाशित 0.8 प्रतिशत अंक का अंतर ही मॉडल बदलने के लिए पर्याप्त कारण नहीं है। Flint तब आज़माएँ जब लोकल मॉडल की धीमी प्रतिक्रिया से काम में देरी हो रही हो। उसे तभी जारी रखें जब वही काम सही और समीक्षा किए गए नतीजे तक पहुँचे, और उसमें लगा समय व दोबारा कोशिशों की संख्या स्वीकार्य हो।

कौन-से काम लोकल रखें और क्लाउड पर कैसे लौटें?

Flint से शुरुआत किसी सीमित बग फ़िक्स, छोटी यूटिलिटी, खास व्यवहार के टेस्ट या कोड की व्याख्या से करें। कई सबसिस्टम में फैलने वाले बदलाव, अस्पष्ट विफलताओं या बार-बार असफल सुधारों के लिए अपना स्थापित बड़ा मॉडल आज़माएँ और उसे संबंधित फ़ाइलें, विफल कमांड तथा अब तक की प्रगति का छोटा सार दें।

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

Ollama से शुरू किए गए Claude Code से वापस लौटने के लिए वह सेशन बंद करें और अपनी मूल क्लाउड कॉन्फ़िगरेशन के साथ Claude Code फिर खोलें। अगर Anthropic Sonnet का सेटअप पहले से मौजूद है, तो Bash में चलाएँ:

claude --model sonnet

कोड भेजने से पहले /status जाँचें। मॉडल चुनने से अपने-आप एंडपॉइंट रीसेट नहीं होता: यह कमांड मानकर चलती है कि आपने लोकल एंडपॉइंट, ऑथेंटिकेशन या मॉडल के ओवरराइड स्थायी सेटिंग्स में नहीं सहेजे हैं। अगर सहेजे हैं, तो जाँच के लिए किए गए उन बदलावों को पुराने मानों पर लौटाएँ और क्लाइंट दोबारा शुरू करें; अपने मौजूदा क्लाउड क्रेडेंशियल सुरक्षित रखें।

OpenCode में /models से पहले से जुड़े क्लाउड प्रोवाइडर और मॉडल को चुनें; जरूरत हो तो पहले /connect इस्तेमाल करें। Cline में Settings से मूल प्रोवाइडर और मॉडल वापस चुनें। अगर Plan और Act की कॉन्फ़िगरेशन अलग हैं, तो दोनों जाँचें।

लोकल मॉडल केवल इन्फ़रेंस को लोकल रखता है। वेब टूल, MCP सर्वर और क्लाइंट के दूसरे इंटीग्रेशन अब भी बाहरी सर्विस से संपर्क कर सकते हैं; अगर कोड आपकी मशीन पर ही रहना चाहिए, तो उनकी अलग से जाँच करें।