Qwen3-Coder-Next को लोकल चलाएँ: एनालिटिक्स डैशबोर्ड को वाइब कोड करें

Qwen3-Coder-Next, Qwen टीम का एक ओपन-वेट कोडिंग मॉडल है, जिसे एजेंटिक प्रोग्रामिंग और लोकल डेवलपर वर्कफ़्लोज़ के लिए बनाया गया है। यह कुशल बने रहने के लिए स्पार्स मिक्सचर-ऑफ-एक्सपर्ट्स डिजाइन का उपयोग करता है, ताकि आधुनिक कोडिंग और टूल-यूज़ बेंचमार्क्स पर मजबूत प्रदर्शन दे सके, साथ ही लंबे कॉन्टेक्स्ट और जटिल मल्टी-स्टेप टास्क्स का समर्थन भी करे।

Qwen3-Coder-Next को खास तौर पर रोमांचक बनाता है इसका टॉप क्लोज़्ड मॉडल्स के मुकाबले प्रतिस्पर्धी होना। शुरुआती मूल्यांकन दिखाते हैं कि यह Claude Sonnet 4.5 जैसे सिस्टम्स के क़रीब प्रदर्शन स्तर तक पहुँच सकता है, जबकि आप इसे लोकल तौर पर चला सकते हैं और अपने सेटअप, प्राइवेसी, और स्पीड पर पूरा नियंत्रण रखते हैं, महंगे होस्टेड API पर निर्भर हुए बिना।

स्रोत: Qwen/Qwen3-Coder-Next

इस ट्यूटोरियल में, हम llama.cpp को सोर्स से बिल्ड करेंगे, llama.cpp इन्फरेंस सर्वर का उपयोग करके Qwen3-Coder-Next को लोकल चलाएँगे, फिर इसे Qwen Code CLI से कनेक्ट करेंगे। अंत में, हम एक सरल डेटा एनालिटिक्स डैशबोर्ड को वाइब कोड करेंगे।

Qwen3-Coder-Next के हार्डवेयर और सॉफ्टवेयर आवश्यकताएँ

लोकल रूप से Qwen3-Coder-Next को बिल्ड और रन करने से पहले, आपको एक कार्यात्मक Linux डेवलपमेंट सेटअप चाहिए जिसमें llama.cpp को कंपाइल करने और GGUF मॉडल्स को चलाने के लिए आवश्यक स्टैंडर्ड बिल्ड टूल्स हों।

सिस्टम पैकेजों के अलावा, यह भी सुनिश्चित करें कि आपके पास ये हों:

• Python (>= 3.11) सहायक स्क्रिप्ट्स और लोकल वर्कफ़्लोज़ के लिए
• Node.js + npm (Node 20+) Qwen Code CLI इंस्टॉल करने के लिए
• सही NVIDIA GPU ड्राइवर्स
• पूरा GPU एक्सेलेरेशन सक्षम करने के लिए CUDA टूलकिट

शुरू करने के लिए अपने सिस्टम को अपडेट करें और कोर डिपेंडेंसीज़ इंस्टॉल करें:

sudo apt-get update
sudo apt-get install -y build-essential cmake curl git libcurl4-openssl-devसंचालित द्वारा

यदि आप CUDA एक्सेलेरेशन का उपयोग करने की योजना बना रहे हैं, तो यह सुनिश्चित करें कि आपकी NVIDIA GPU सही ढंग से डिटेक्ट हो रही है:

nvidia-smiसंचालित द्वारा

हमारे केस में, हम NVIDIA RTX 3090 का उपयोग कर रहे हैं जिसमें 24GB VRAM है। चूँकि बड़े क्वांटाइज़ेशन्स के लिए Qwen3-Coder-Next को इससे अधिक मेमोरी चाहिए, शेष मॉडल वेट्स अपने आप सिस्टम RAM में ऑफ़लोड हो जाएँगे, जिससे मॉडल लोकल रूप से अच्छे प्रदर्शन के साथ चल सकेगा।

Qwen3-Coder-Next को स्मूदली चलाने के लिए, आपके हार्डवेयर को लगभग इन मेमोरी लक्ष्यों को पूरा करना चाहिए:

• 46GB RAM / VRAM / यूनिफाइड मेमोरी — 4-बिट GGUF इन्फरेंस के लिए अनुशंसित।
• ~85GB मेमोरी — 8-बिट वेरिएंट्स के लिए आवश्यक।

यदि आपके पास 46GB उपलब्ध नहीं है, तो भी आप छोटे क्वांटाइज़्ड वेरिएंट्स (जैसे 3-बिट) चला सकते हैं।

एक सरल thumb rule:

डिस्क + RAM + VRAM ≥ क्वांट साइज़

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

CUDA सपोर्ट के साथ llama.cpp इंस्टॉल करना

Qwen3-Coder-Next को लोकल चलाने से पहले, हमें एक तेज़ इन्फरेंस इंजन चाहिए। आज का सबसे लोकप्रिय विकल्प है llama.cpp, जो हल्का GGUF इन्फरेंस और आसान लोकल सर्वर प्रदान करता है।

यदि आप सबसे तेज़ सेटअप चाहते हैं, तो llama.cpp macOS, Linux, और Windows के लिए (CUDA-सक्षम बिल्ड सहित) प्रीबिल्ट बायनरीज़ ऑफर करता है। आप इन्हें आधिकारिक GitHub रिलीज़ पेज से सीधे डाउनलोड कर सकते हैं: Release b7936 · ggml-org/llama.cpp. 

प्रीबिल्ट इंस्टॉल के साथ, आप तुरंत llama.cpp CLI टूल्स चला सकते हैं या बिना खुद कुछ कंपाइल किए इन्फरेंस सर्वर शुरू कर सकते हैं।

इस ट्यूटोरियल में, हम कुछ महत्वपूर्ण कारणों से प्रीबिल्ट बायनरीज़ पर निर्भर होने के बजाय llama.cpp को मैन्युअली बिल्ड करेंगे:

• नवीनतम अपडेट्स और बग फिक्स सीधे GitHub रिपॉज़िटरी से
• Linux सिस्टम्स के लिए ऑप्टिमाइज़्ड पूरा CUDA सपोर्ट
• आपके विशेष GPU और एनवायरनमेंट के अनुरूप बेहतर प्रदर्शन
• नए क्वांट फॉर्मैट्स और मॉडल आउटपुट गुणवत्ता में हालिया सुधारों के लिए आवश्यक

आइए GitHub से सीधे आधिकारिक llama.cpp सोर्स कोड डाउनलोड करके शुरू करें। यह सुनिश्चित करता है कि हम नवीनतम CUDA सुधारों और बग फिक्स सहित सबसे हालिया वर्ज़न के साथ काम कर रहे हैं:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cppसंचालित द्वारा

इस समय, आपको llama.cpp डायरेक्टरी के भीतर होना चाहिए, जहाँ से आप प्रोजेक्ट को स्क्रैच से बिल्ड करने के लिए आवश्यक सब कुछ पा सकते हैं।

अगला चरण है CMake का उपयोग करके बिल्ड सिस्टम को कॉन्फ़िगर करना। यह चरण आवश्यक बिल्ड फ़ाइलें जनरेट करता है और CUDA के माध्यम से GPU एक्सेलेरेशन सक्षम करता है:

cmake /workspace/llama.cpp -B /workspace/llama.cpp/build -DGGML_CUDA=ON -DBUILD_SHARED_LIBS=OFFसंचालित द्वारा

अब हम वास्तविक इन्फरेंस सर्वर बायनरी को कंपाइल करते हैं। यही वह कंपोनेंट है जो Qwen3-Coder-Next को लोकल होस्ट करेगा और कोडिंग टूल्स व CLI इंटीग्रेशन्स के लिए API एंडपॉइंट एक्सपोज़ करेगा:

cmake --build /workspace/llama.cpp/build -j --clean-first --target llama-serverसंचालित द्वारा

बिल्ड पूरा होने के बाद, कंपाइल्ड एग्ज़िक्यूटेबल्स build/bin/ डायरेक्टरी में स्टोर होते हैं। इन्हें मुख्य प्रोजेक्ट फ़ोल्डर से सीधे चलाना आसान बनाने के लिए, आप इन्हें इस तरह कॉपी कर सकते हैं:

cp /workspace/llama.cpp/build/bin/llama-server /workspace/llama.cpp/llama-serverसंचालित द्वारा

Qwen3-Coder-Next मॉडल डाउनलोड करना

अब जब llama.cpp इंस्टॉल हो गया है, अगला चरण है Hugging Face से Qwen3-Coder-Next GGUF मॉडल डाउनलोड करना।

शुरू करने से पहले, यह सुनिश्चित करें कि आपके पास नवीनतम Python इंस्टॉलेशन (>= 3.11) हो, क्योंकि Hugging Face टूलिंग और ट्रांसफ़र यूटिलिटीज़ इस पर निर्भर करती हैं।

बड़े GGUF फ़ाइलों को कुशलता से डाउनलोड करने के लिए, हम Hugging Face Hub क्लाइंट को हाई-स्पीड Xet और ट्रांसफ़र बैकएंड्स के साथ उपयोग करेंगे:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferसंचालित द्वारा

अब Hugging Face के ऑप्टिमाइज़्ड ट्रांसफ़र बैकएंड को सक्षम करें:

export HF_HUB_ENABLE_HF_TRANSFER=1संचालित द्वारा

अब हम Qwen3-Coder-Next के Unsloth डायनेमिक GGUF वर्ज़न को डाउनलोड कर सकते हैं। इस ट्यूटोरियल में, हम विशेष रूप से UD-Q4_K_XL क्वांटाइज़ेशन को फ़ेच करेंगे।

यह एक बेहतरीन डिफ़ॉल्ट चुनाव है क्योंकि यह इन बातों के बीच शानदार संतुलन देता है:

• मॉडल क्वालिटी (बहुत मजबूत कोडिंग प्रदर्शन)
• इन्फरेंस स्पीड (लोकल वाइब कोडिंग वर्कफ़्लोज़ के लिए काफ़ी तेज़)
• मेमोरी दक्षता (RAM ऑफ़लोडिंग के साथ हाई-एंड कंज़्यूमर GPUs पर फिट हो जाता है)

यहाँ Q4 फॉर्मैट का मतलब है कि मॉडल को 4-बिट प्रिसीजन तक कंप्रेस किया गया है, जिससे यह फुल FP16 वेट्स की तुलना में काफी हल्का हो जाता है, फिर भी प्रभावशाली आउटपुट क्वालिटी बनाए रखता है। 

hf download unsloth/Qwen3-Coder-Next-GGUF \
  --local-dir /workspace/models/qwen3-coder-next \
  --include "*UD-Q4_K_XL*"संचालित द्वारा

कमांड चलने के बाद, मॉडल फ़ाइलें आपके लोकल डायरेक्टरी में डाउनलोड होना शुरू हो जाएँगी।

हाई-स्पीड नेटवर्क पर, इसमें आमतौर पर कुछ ही मिनट लगते हैं। डाउनलोड पूरा होने के बाद, आपके पास llama-server में लोड करने के लिए तैयार GGUF मॉडल होगा।

Qwen3-Coder-Next इन्फरेंस सर्वर चलाना

GGUF मॉडल डाउनलोड होने के बाद, हम llama-server इन्फरेंस बैकएंड का उपयोग करके Qwen3-Coder-Next को लोकल लॉन्च कर सकते हैं। यह एक OpenAI-कम्पैटिबल API सर्वर शुरू करता है जिससे कोडिंग टूल्स और CLI कनेक्ट हो सकते हैं।

निम्न कमांड चलाएँ:

./llama-server \
  --model "/workspace/models/qwen3-coder-next/Qwen3-Coder-Next-UD-Q4_K_XL.gguf" \
  --alias "Qwen3-Coder-Next" \
  --host 0.0.0.0 \
  --port 8080 \
  --threads 32 \
  --threads-batch 32 \
  --ctx-size 20000\
  --batch-size  1024\ 
  --ubatch-size 256 \
  --jinja \
  --flash-attn on \
  --temp 0.7 \
  --top-p 0.9 \
  --min-p 0.05 \
  --fit on \
  --swa offसंचालित द्वारा

मुख्य आर्ग्युमेंट्स की व्याख्या:

• --model: डाउनलोड किए गए Qwen3-Coder-Next GGUF चेकपॉइंट का पाथ
• --alias: API क्लाइंट्स में दिखने वाला उपयोगकर्ता-अनुकूल मॉडल नाम
• --host 0.0.0.0: सर्वर को सभी नेटवर्क इंटरफेस पर एक्सपोज़ करता है (रिमोट ऐक्सेस के लिए उपयोगी)
• --port 8080: इन्फरेंस API को 8080 पोर्ट पर चलाता है
• --threads 32: अधिकतम थ्रूपुट के लिए 32 CPU थ्रेड्स का उपयोग
• --threads-batch 32: तेज़ टोकन जनरेशन हेतु बैच प्रोसेसिंग को पैरेललाइज़ करता है
• --ctx-size 20000: लंबे कोडिंग सेशन्स के लिए बड़ा कॉन्टेक्स्ट विंडो (~20K टोकन) सेट करता है
• --batch-size 1024: इन्फरेंस के दौरान GPU उपयोग में सुधार
• --ubatch-size 256: स्मूद प्रदर्शन के लिए माइक्रो-बैचिंग नियंत्रित करता है
• --jinja: इंस्ट्रक्शन-स्टाइल मॉडलों के लिए आवश्यक चैट टेम्पलेट फ़ॉर्मैटिंग सक्षम करता है
• --flash-attn on: फास्ट लंबे-कॉन्टेक्स्ट इन्फरेंस के लिए फ्लैश अटेंशन सक्रिय करता है
• --temp 0.7: आउटपुट को केंद्रित रखता है, फिर भी वाइब कोडिंग के लिए क्रिएटिव
• --top-p 0.9: बैलेंस्ड विविधता के लिए न्यूक्लियस सैंपलिंग
• --min-p 0.05: बेहद कम-प्रोबेबिलिटी टोकन्स को फ़िल्टर करता है ताकि क्लीन कम्प्लीशन्स मिलें
• --fit on: लेयर्स को अपने आप VRAM में फिट करता है और बाकी को RAM में ऑफ़लोड करता है
• --swa off: स्लाइडिंग विंडो अटेंशन अक्षम करता है (फुल-कॉन्टेक्स्ट टास्क्स के लिए बेहतर)

सर्वर शुरू हो जाने के बाद, उसे उसी टर्मिनल विंडो में चलने दें। फिर एक नया टर्मिनल टैब या सेशन खोलें ताकि सर्वर को रोके बिना API टेस्ट कर सकें।

नए टर्मिनल से, उपलब्ध मॉडलों को क्वेरी करके सब कुछ सही काम कर रहा है या नहीं, यह कन्फर्म कर सकते हैं:

curl http://127.0.0.1:8080/v1/modelsसंचालित द्वारा

यदि सर्वर सही चल रहा है, तो आपको रिस्पॉन्स में Qwen3-Coder-Next दिखेगा, जिसका मतलब है कि आपका लोकल इन्फरेंस एंडपॉइंट उपयोग के लिए तैयार है।

Web UI के माध्यम से लोकल Qwen3-Coder-Next API एंडपॉइंट एक्सेस करें

इन्फरेंस सर्वर चलने के बाद, आप बिल्ट-इन llama.cpp Web UI के जरिए सीधे Qwen3-Coder-Next के साथ इंटरेक्ट भी कर सकते हैं।

अपना ब्राउज़र खोलें और जाएँ: http://127.0.0.1:8080.

यह एक साधारण ChatGPT-स्टाइल इंटरफ़ेस खोलता है जहाँ आप जल्दी से प्रॉम्प्ट टेस्ट कर सकते हैं और यह सत्यापित कर सकते हैं कि मॉडल सही तरह से जवाब दे रहा है।

उदाहरण के लिए, मॉडल से कुछ व्यावहारिक जनरेट करने को कहकर शुरू करें, जैसे एक बेसिक Python ट्रेडिंग बॉट।

कुछ ही सेकंड में, आपको काम करने वाला कोड और स्पष्ट इम्प्लीमेंटेशन स्टेप्स के साथ पूरा रिस्पॉन्स मिल जाएगा।

खास तौर पर प्रभावशाली है स्पीड। हमारे सेटअप पर, Qwen3-Coder-Next लगभग 44 टोकन प्रति सेकंड जनरेट कर रहा है, जिससे लोकल कोडिंग बेहद उत्तरदायी लगती है—रियल-टाइम वाइब कोडिंग वर्कफ़्लोज़ के लिए पर्याप्त तेज़।

Qwen Code CLI इंस्टॉल और सेट अप करें

अब जब लोकल इन्फरेंस सर्वर http://127.0.0.1:8080/v1 पर चल रहा है, तो हम इसे Qwen Code CLI से कनेक्ट कर सकते हैं। यह आपको एक हल्का-फुल्का टर्मिनल-आधारित कोडिंग असिस्टेंट देता है जो OpenAI-कम्पैटिबल API के जरिए आपके लोकल Qwen3-Coder-Next मॉडल से बात करता है।

Qwen Code CLI एक Node-आधारित टूल है, इसलिए आपको चाहिए:

• Node.js 20+
• npm (Ubuntu/Debian पर Node.js के साथ अपने आप इंस्टॉल हो जाता है)

NodeSource से Node.js इंस्टॉल करें (सही वर्ज़न पाने के लिए अनुशंसित):

sudo apt update
sudo apt install -y curl ca-certificates
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejsसंचालित द्वारा

अब Qwen Code CLI को ग्लोबली इंस्टॉल करें:

npm install -g @qwen-code/qwen-code@latestसंचालित द्वारा

सुनिश्चित करें कि यह सही इंस्टॉल हुआ है:

qwen --version संचालित द्वारा

0.9.0संचालित द्वारा

Qwen CLI OpenAI-स्टाइल एनवायरनमेंट वेरिएबल्स की अपेक्षा करता है। हम एक सरल कॉन्फ़िग फ़ाइल बनाएँगे जो इसे बताए:

• एक डमी API की का उपयोग करें (क्योंकि हम लोकल चला रहे हैं)
• रिक्वेस्ट्स को llama-server (पोर्ट 8080) पर भेजें
• वही सटीक मॉडल नाम उपयोग करें जो हमने --alias से सेट किया था

कॉन्फ़िग डायरेक्टरी और .env फ़ाइल बनाएँ:

mkdir -p ~/.qwen
cat > ~/.qwen/.env <<'EOF'
OPENAI_API_KEY="dummy"
OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
OPENAI_MODEL="Qwen3-Coder-Next"
EOFसंचालित द्वारा

अब Qwen Code लॉन्च करें:

qwen संचालित द्वारा

इस बिंदु पर, आपका CLI आपके लोकल Qwen3-Coder-Next सर्वर से जुड़ चुका है, इसलिए हर प्रॉम्प्ट होस्टेड API पर जाने की बजाय लोकल रूप से चलता है।

Qwen3-Coder-Next का उपयोग करके एनालिटिकल डैशबोर्ड को वाइब कोड करना

अब जब सब कुछ लोकल रूप से चल रहा है, हम वाइब कोडिंग शुरू कर सकते हैं और Qwen Code CLI का उपयोग करके एक सरल एनालिटिक्स डैशबोर्ड बना सकते हैं।

पहले, एक नया प्रोजेक्ट फ़ोल्डर बनाएँ और उसमें जाएँ:

mkdir dashboardcd dashboardसंचालित द्वारा

इसके बाद, इसी डायरेक्टरी के अंदर Qwen CLI लॉन्च करें:

qwenसंचालित द्वारा

अब मॉडल को एक स्पष्ट, सरल निर्देश दें, उदाहरण के लिए:

“डमी डेटा (सेल्स, यूज़र्स, रेवेन्यू, चर्न) के साथ एक HTML एनालिटिक्स डैशबोर्ड बनाएँ, KPI कार्ड्स, एक इंटरेक्टिव टेबल और कम से कम एक चार्ट दिखाएँ, डेट-रेंज और कैटेगरी फ़िल्टर्स जोड़ें।”

कुछ ही सेकंड में, Qwen3-Coder-Next आवश्यकताओं को समझता है और कोड लिखने से पहले टास्क को एक स्ट्रक्चर्ड प्लान में बाँट देता है।

चेकलिस्ट पूरी करने के बाद, मॉडल ने एक ही बार में पूरा वर्किंग डैशबोर्ड जेनरेट किया, जिसमें शामिल हैं:

• index.html
• style.css
• script.js

जब आप index.html फ़ाइल को ब्राउज़र में खोलते हैं, तो तुरंत एक आधुनिक, सुव्यवस्थित डैशबोर्ड दिखाई देगा जिसमें क्लीन स्टाइलिंग, KPI कार्ड्स और वास्तविक लगने वाले प्लेसहोल्डर मेट्रिक्स होंगे। 

फ़िल्टर्स, टेबल इंटरेक्शन्स और डाउनलोड विकल्प बॉक्स से बाहर ही स्मूदली काम करते हैं।

नीचे स्क्रॉल करने पर, डैशबोर्ड में लगभग 150 डमी रिकॉर्ड्स के साथ विस्तृत ट्रांज़ैक्शन डेटा भी शामिल है, जो इसे एक वास्तविक एनालिटिक्स प्रोडक्ट जैसा एहसास देता है।

हालाँकि यह हर संभावित विज़ुअलाइज़ेशन जनरेट नहीं करता (उदाहरण के लिए, समय के साथ रेवेन्यू का एक लाइन चार्ट एक अच्छा ऐड-ऑन होता), फिर भी यह तथ्य कि लोकल रूप से चल रहा क्वांटाइज़्ड मॉडल मूलतः एक ही बार में फ़ंक्शनल डैशबोर्ड बना सकता है, अत्यंत प्रभावशाली है। 

कुल मिलाकर, प्रॉम्प्ट से वर्किंग आउटपुट तक पूरा बिल्ड कुछ ही मिनटों में हो गया।

अंतिम विचार

सच कहूँ तो, Qwen3-Coder-Next के साथ मेरा अनुभव थोड़ा मिला-जुला रहा।

कागज़ पर, मूल्यांकन बताते हैं कि यह Claude Sonnet 4.5 जैसे फ्रंटियर-लेवल मॉडलों के करीब होना चाहिए, और एक 80B MoE कोडिंग मॉडल को लोकल रूप से चलाने का विचार वाकई रोमांचक है। 

इस ट्यूटोरियल में, हमने सफलतापूर्वक CUDA सपोर्ट के साथ llama.cpp बिल्ड किया, Unsloth GGUF क्वांट डाउनलोड किया, लोकल इन्फरेंस सर्वर लॉन्च किया, और मिनटों में एक वर्किंग एनालिटिक्स डैशबोर्ड को वाइब कोड भी किया। लोकल स्पीड और रेस्पॉन्सिवनेस प्रभावशाली थे, खासकर ओपन-वेट सेटअप के लिए।

लेकिन व्यवहार में, मुझे लगातार “Sonnet-लेवल” विश्वसनीयता नहीं दिखी जिसकी कुछ बेंचमार्क्स से उम्मीद बनती है। मैंने कुछ घंटे इस मॉडल को opencode जैसे अधिक जटिल एजेंट एनवायरनमेंट्स में उपयोग करने की कोशिश में लगाए, और मुझे टूल एरर्स, अस्थिर जेनेरेशन्स, और कभी-कभी लूपिंग आउटपुट्स जैसी समस्याएँ मिलती रहीं।

दिलचस्प बात यह है कि जब मैंने एक सरल वर्कफ़्लो पर स्विच किया और Qwen Code CLI का इस्तेमाल किया, तो मॉडल कहीं अधिक भरोसेमंद लगा। उस सेटिंग में, यह डायरेक्ट कोडिंग टास्क्स, क्विक प्रोटोटाइपिंग, और वाइब कोडिंग सेशन्स के लिए अच्छा प्रदर्शन करता रहा। यह स्मूद, तेज़, और लोकल रूप से उपयोग करने में सचमुच मज़ेदार था।

मेरा निष्कर्ष: Qwen3-Coder-Next निश्चित रूप से प्रयोग करने लायक है, खासकर अगर आप क्लाउड APIs के बिना एक शक्तिशाली लोकल कोडिंग असिस्टेंट चाहते हैं। लेकिन मैं इसे अभी प्रोडक्शन-ग्रेड कोडिंग एजेंट्स के पूर्ण प्रतिस्थापन के रूप में सुझाव नहीं दूँगा, जब तक कि आप डिबगिंग में समय लगाने, llama.cpp सेटिंग्स को ट्यून करने, और अपने हार्डवेयर के लिए परफॉर्मेंस को ऑप्टिमाइज़ करने के लिए तैयार न हों।

यदि आप अपने वर्कफ़्लोज़ में AI के साथ काम करने के बारे में अधिक सीखने के इच्छुक हैं, तो मैं AI-Assisted Coding for Developers कोर्स देखने की सलाह दूँगा।