GitHub Copilot को बदलें: Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 क्लाउड ऑटोकम्पलीट बनाम लोकल AI की लागत

VS Code में GitHub Copilot सक्रिय रहने पर आप जो भी कीस्ट्रोक टाइप करते हैं, वह Microsoft के Azure-होस्टेड OpenAI इन्फ्रास्ट्रक्चर को भेजा जाता है। यह कोई षड्यंत्र सिद्धांत नहीं है — यह दस्तावेज़ीकृत उत्पाद आर्किटेक्चर है। आपके मालिकाना एल्गोरिदम, आंतरिक व्यावसायिक तर्क, अप्रकाशित फीचर्स और आर्किटेक्चरल निर्णय सभी आपकी मशीन से बाहर जा रहे हैं। साइड प्रोजेक्ट पर काम करने वाले व्यक्तिगत डेवलपर्स के लिए यह समझौता अक्सर स्वीकार्य होता है। व्यावसायिक रूप से संवेदनशील सॉफ़्टवेयर बनाने वाली टीमों के लिए, यह एक महत्वपूर्ण सुरक्षा और अनुपालन जोखिम है।

फिर वित्तीय पहलू भी है।

GitHub Copilot मूल्य निर्धारण की वास्तविकता

Business टियर पर 50 डेवलपर्स वाले एक मध्यम आकार के इंजीनियरिंग संगठन के लिए, आप $11,400 प्रति वर्ष देख रहे हैं — अनिश्चित काल तक, एक बाहरी विक्रेता को, बिना अंतर्निहित मॉडल के स्वामित्व या मूल्य निर्धारण स्थिरता की किसी गारंटी के। Microsoft पहले ही लॉन्च के बाद से Copilot की कीमतें बढ़ा चुका है, और इस प्रवृत्ति के उलटने की उम्मीद करने का कोई संरचनात्मक कारण नहीं है।

"लोकल AI" का वास्तविक अर्थ

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

Cloud Copilot flow:
Keypress → VS Code → HTTPS → Azure OpenAI → Inference → Response → VS Code

Local Ollama flow:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

localhost इन्फरेंस पथ विफलता के एक पूरे वर्ग को हटा देता है: API आउटेज, रेट लिमिटिंग, कॉर्पोरेट प्रॉक्सी हस्तक्षेप, और भौगोलिक लेटेंसी भिन्नता। सख्त एंटरप्राइज़ फ़ायरवॉल के पीछे काम करने वाले डेवलपर्स जो पहले Copilot का उपयोग नहीं कर सकते थे, वे अब नेटवर्क परिधि को छुए बिना पूरी तरह सक्षम कोड मॉडल चला सकते हैं।

क्लाउड निर्भरता की छिपी लागतें

लाइसेंसिंग शुल्क से परे, क्लाउड ऑटोकम्पलीट ऑपरेशनल कपलिंग पेश करता है जिसे कम आंकना आसान है:

• वेंडर लॉक-इन: आपकी टीम का वर्कफ़्लो एक थर्ड-पार्टी सेवा पर निर्भर हो जाता है जिसका मूल्य निर्धारण, उपलब्धता और सेवा की शर्तों पर एकतरफा नियंत्रण होता है।
• अनुपालन का बोझ: कई विनियमित उद्योग (स्वास्थ्य सेवा, वित्त, रक्षा) किसी भी ऐसे टूल के लिए औपचारिक डेटा प्रोसेसिंग समझौतों और सुरक्षा समीक्षाओं की मांग करते हैं जो कोड को बाहरी रूप से प्रसारित करता हो। इन वातावरणों में Copilot की अनुमोदन प्रक्रिया सरल नहीं है।
• कॉन्टेक्स्ट विंडो लीकेज: क्लाउड मॉडल न केवल आपकी वर्तमान फ़ाइल बल्कि आसपास के कॉन्टेक्स्ट बफर भी प्राप्त करते हैं — कॉन्फ़िगरेशन के आधार पर आसन्न फ़ाइलें, हाल ही में खोले गए टैब और रिपॉजिटरी मेटाडेटा।
• ऑडिट ट्रेल की कमियां: जब कोड सुझाव किसी बाहरी ब्लैक बॉक्स से आते हैं, तो मुकदमेबाजी या लाइसेंसिंग विवादों में IP उत्पत्ति का श्रेय निर्धारित करना जटिल हो जाता है।

आज के समय में लोकल मॉडल कहाँ प्रतिस्पर्धी हैं

Code Llama 13B और StarCoder2 7B जैसे आधुनिक क्वांटाइज़्ड मॉडल जो कंज्यूमर हार्डवेयर पर चलते हैं, सबसे सामान्य ऑटोकंप्लीट परिदृश्यों के लिए Copilot के साथ वास्तविक रूप से प्रतिस्पर्धी कंप्लीशन गुणवत्ता प्राप्त करते हैं: बॉयलरप्लेट जनरेशन, फ़ंक्शन सिग्नेचर कंप्लीशन, टेस्ट स्कैफोल्डिंग और सामान्य एल्गोरिदम इम्प्लीमेंटेशन। यह अंतर और भी कम हो जाता है जब मॉडल उन भाषाओं और पैटर्न के कोड पर काम कर रहा होता है जिन पर उसे विशेष रूप से प्रशिक्षित किया गया हो।

गणना सीधी है: शून्य मार्जिनल लागत, संपूर्ण डेटा संप्रभुता, और कोई बाहरी निर्भरता नहीं बनाम एक बढ़ता हुआ SaaS बिल और क्लाउड इन्फरेंस प्रदाता के साथ अपना कोडबेस साझा करने का एक अप्रत्यक्ष समझौता। जो टीमें दीर्घकालिक टूलचेन स्वामित्व के बारे में गंभीर हैं, उनके लिए लोकल-फर्स्ट दृष्टिकोण एक समझौता नहीं है — यह अधिक रक्षनीय आर्किटेक्चरल विकल्प है।

Step 2 पूर्वावश्यकताएं: VS Code और Ollama

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

Visual Studio Code

आपको VS Code 1.80 या उसके बाद का संस्करण चाहिए। Continue.dev एक्सटेंशन इनलाइन घोस्ट-टेक्स्ट कंप्लीशन के लिए आधुनिक VS Code APIs पर निर्भर करता है, और पुराने संस्करण चुपचाप विफल हो जाएंगे या खराब व्यवहार उत्पन्न करेंगे।

कमांड लाइन से अपना संस्करण सत्यापित करें:

code --version

अपेक्षित आउटपुट (आपका नया हो सकता है):

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

यदि आप VSCodium जैसा कोई फोर्क चला रहे हैं, तो Continue.dev पूरी तरह से संगत है — बस सुनिश्चित करें कि आप Microsoft Marketplace के बजाय Open VSX Registry से एक्सटेंशन प्राप्त कर रहे हैं, क्योंकि VSCodium डिफ़ॉल्ट रूप से Microsoft के प्रोप्राइटरी एक्सटेंशन होस्ट के बिना आता है।

Ollama

Ollama एक लोकल मॉडल रनटाइम है जो मॉडल डाउनलोड, क्वांटाइज़ेशन प्रबंधन को संभालता है, और localhost:11434 पर एक OpenAI-compatible REST API एक्सपोज़ करता है। यह संगतता परत ठीक इसीलिए है कि Continue.dev इसके साथ इतनी आसानी से एकीकृत होता है — किसी कस्टम प्लगइन आर्किटेक्चर की आवश्यकता नहीं।

प्लेटफ़ॉर्म के अनुसार इंस्टॉलेशन:

इंस्टॉलेशन के बाद, Ollama daemon शुरू करें:

ollama serve

macOS पर, Ollama इंस्टॉलेशन के बाद स्वचालित रूप से एक मेनू बार एप्लिकेशन के रूप में चलता है। Linux पर, आप इसे systemd सर्विस के रूप में चलाना चाह सकते हैं:

sudo systemctl enable ollama
sudo systemctl start ollama

API सक्रिय है या नहीं, इसे सत्यापित करें:

curl http://localhost:11434/api/tags

एक सफल रिस्पॉन्स एक JSON ऑब्जेक्ट लौटाता है जो आपके स्थानीय रूप से इंस्टॉल किए गए मॉडलों की सूची देता है। इस चरण में खाली सूची होना ठीक है — मॉडल डाउनलोड बाद के चरण में होता है।

{
  "models": []
}

हार्डवेयर संबंधी विचार

यहीं पर अधिकांश ट्यूटोरियल आपको अधूरा छोड़ देते हैं। आपका हार्डवेयर सीधे तय करता है कि कौन से मॉडल व्यवहार्य हैं और किस quantization स्तर पर।

Ollama स्वचालित रूप से Metal (Apple Silicon), CUDA (NVIDIA), या ROCm (AMD) के माध्यम से आपके GPU पर लेयर्स ऑफलोड करता है। किसी मैन्युअल कॉन्फ़िगरेशन की आवश्यकता नहीं है — Ollama आपके हार्डवेयर का पता लगाता है और लेयर ऑफलोडिंग को पारदर्शी तरीके से अनुकूलित करता है।

Apple Silicon उपयोगकर्ताओं के लिए महत्वपूर्ण नोट: Unified memory CPU और GPU के बीच साझा होती है। 16 GB वाला MacBook Pro M3 एक 13B मॉडल को आराम से चला सकता है क्योंकि कोई अलग VRAM सीमा नहीं होती। यह लोकल AI वर्कफ़्लो में Apple Silicon के पक्ष में सबसे मजबूत तर्कों में से एक है।

अपने एनवायरनमेंट की पुष्टि करना

आगे बढ़ने से पहले यह त्वरित जाँच करें:

# Confirm VS Code version
code --version

# Confirm Ollama is running and responsive
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Confirm GPU acceleration (Ollama logs)
ollama run llama3.2:1b "say ok"

मॉडल इन्फरेंस के दौरान Ollama टर्मिनल आउटपुट देखें। आपको अपने GPU को संदर्भित करते हुए लेयर ऑफलोड काउंट दिखने चाहिए। यदि सब कुछ CPU पर चलता है, तो बड़े कोड मॉडल लाने से पहले अपनी ड्राइवर इंस्टॉलेशन की जाँच करें।

दोनों पूर्वापेक्षाएँ पुष्ट होने के बाद, आप Continue.dev इंस्टॉल करने और सब कुछ जोड़ने के लिए तैयार हैं।

Step 3 चरण 1: Continue.dev एक्सटेंशन इंस्टॉल करना

Continue.dev इस पूरे सेटअप की आधारशिला है — एक ओपन-सोर्स AI कोड असिस्टेंट जो GitHub Copilot के ड्रॉप-इन रिप्लेसमेंट के रूप में काम करता है, लेकिन एक महत्वपूर्ण आर्किटेक्चरल अंतर के साथ: यह आपके अनुरोधों को वहाँ रूट करता है जहाँ आप इसे बताते हैं, जिसमें एक स्थानीय रूप से चलने वाला Ollama इंस्टेंस भी शामिल है। कोई टेलीमेट्री नहीं। कोई क्लाउड एग्रेस नहीं। कोई सब्सक्रिप्शन नहीं।

VS Code Marketplace से इंस्टॉल करना

सबसे सरल इंस्टॉलेशन पथ सीधे एडिटर के अंदर VS Code Extension Marketplace के माध्यम से जाता है:

1. VS Code खोलें
2. Extensions panel खोलने के लिए Ctrl+Shift+X (Windows/Linux) या Cmd+Shift+X (macOS) दबाएं
3. "Continue" खोजें
4. Continue द्वारा प्रकाशित extension को ढूंढें (आइकन एक विशिष्ट purple gradient लोगो है)
5. Install पर क्लिक करें

वैकल्पिक रूप से, VS Code CLI का उपयोग करके command line से इंस्टॉल करें:

code --install-extension Continue.continue

या यदि आप VS Codium (telemetry-मुक्त fork) उपयोग कर रहे हैं, तो extension Open VSX Registry पर उपलब्ध है:

codium --install-extension Continue.continue

नोट: Continue.dev JetBrains IDEs (IntelliJ, PyCharm, GoLand, आदि) को भी एक अलग plugin के माध्यम से सपोर्ट करता है, लेकिन यह गाइड विशेष रूप से VS Code integration पर केंद्रित है।

इंस्टॉलेशन की जांच करना

एक बार इंस्टॉल होने के बाद, आपको अपने VS Code वातावरण में दो तत्काल बदलाव दिखने चाहिए:

Side panel खोलने के लिए Activity Bar में Continue आइकन पर क्लिक करें। पहली बार लॉन्च करने पर, Continue एक onboarding flow प्रस्तुत करेगा जो आपको एक provider कनेक्ट करने के लिए प्रेरित करेगा। आप इसे छोड़ या बंद कर सकते हैं — हम अगले चरण में config.json को सीधे संपादित करके Ollama को manually जोड़ेंगे, जो हमें GUI wizard की तुलना में कहीं अधिक नियंत्रण देता है।

Extension की Architecture को समझना

आगे बढ़ने से पहले, यह समझना उचित है कि Continue वास्तव में क्या इंस्टॉल करता है और यह कैसे संवाद करता है:

VS Code Extension (Continue.dev)
        │
        ▼
  config.json  ──────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          ▼
  Chat Provider (LLM)                               Autocomplete Provider (LLM)
  e.g., Ollama → llama3                             e.g., Ollama → starcoder2
        │                                                          │
        └────────────────────────┬─────────────────────────────────┘
                                 │
                                 ▼
                    http://localhost:11434  (Ollama REST API)

Continue chat और autocomplete को दो स्वतंत्र रूप से कॉन्फ़िगर करने योग्य providers में अलग करता है। यह एक शक्तिशाली विभाजन है — आप conversational queries के लिए llama3 या deepseek-coder जैसे बड़े, instruction-tuned model चला सकते हैं, जबकि low-latency inline completions के लिए starcoder2:3b जैसे हल्के, fill-in-the-middle model का उपयोग कर सकते हैं। कोई अन्य mainstream Copilot विकल्प provider granularity का यह स्तर उजागर नहीं करता।

config.json फ़ाइल का पता लगाना

Continue का संपूर्ण व्यवहार एक single JSON फ़ाइल द्वारा नियंत्रित होता है। जानें यह कहाँ स्थित है:

आप इसे VS Code के अंदर से सीधे Continue पैनल के सेटिंग्स गियर आइकन का उपयोग करके खोल सकते हैं, या अपने टर्मिनल में मैन्युअल रूप से नेविगेट कर सकते हैं:

# macOS / Linux
cat ~/.continue/config.json

# Windows (PowerShell)
Get-Content "$env:USERPROFILE\.continue\config.json"

एक्सटेंशन इंस्टॉल होने और कॉन्फ़िग फ़ाइल का पता लगने के बाद, आप Continue को अपने लोकल Ollama इंस्टेंस पर पॉइंट करने के लिए तैयार हैं।

Step 4 चरण 2: Ollama के लिए config.json को कॉन्फ़िगर करना

एक बार Continue.dev इंस्टॉल हो जाने के बाद, एक्सटेंशन का संपूर्ण व्यवहार एक ही फ़ाइल द्वारा नियंत्रित होता है: config.json। यहीं पर आप Continue को अपने लोकल Ollama इंस्टेंस से जोड़ते हैं, यह परिभाषित करते हैं कि कौन से मॉडल चैट बनाम ऑटोकम्पलीट को संभालते हैं, और परफॉर्मेंस पैरामीटर को ट्यून करते हैं। इस फ़ाइल को सही तरीके से सेट करना एक धीमे, अविश्वसनीय सेटअप और GitHub Copilot जैसी रिस्पॉन्सिवनेस वाले सेटअप के बीच का अंतर है।

config.json का पता लगाना

Continue अपना कॉन्फ़िगरेशन आपकी होम डायरेक्टरी में स्टोर करता है:

आप इसे Continue साइडबार का उपयोग करके VS Code से सीधे भी खोल सकते हैं — Continue पैनल के नीचे गियर आइकन पर क्लिक करें, और यह एडिटर में config.json खोल देगा।

न्यूनतम Ollama कॉन्फ़िगरेशन

नीचे एक प्रोडक्शन-रेडी बेसलाइन config.json है जो Continue को चैट और टैब ऑटोकम्पलीट दोनों के लिए लोकली चल रहे Ollama इंस्टेंस से कनेक्ट करता है:

{
  "models": [
    {
      "title": "CodeLlama 13B (Chat)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (Autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85
  },
  "allowAnonymousTelemetry": false
}

दो अलग-अलग मॉडल क्यों? चैट मॉडल इंस्ट्रक्शन-फॉलोइंग और मल्टी-टर्न डायलॉग के लिए ऑप्टिमाइज़ किए गए हैं। ऑटोकम्पलीट मॉडल — विशेष रूप से वे जो Fill-in-the-Middle (FIM) के साथ ट्रेन किए गए हैं — प्रीफ़िक्स और सफ़िक्स कॉन्टेक्स्ट विंडो के आधार पर कोड की भविष्यवाणी करने के लिए विशेष रूप से ट्यून किए गए हैं। दोनों को मिलाने से दोनों अनुभव खराब हो जाते हैं।

प्रत्येक फ़ील्ड का विश्लेषण

models ऐरे — यह Continue चैट पैनल में उपलब्ध मॉडलों को परिभाषित करता है। आप कई एंट्री जोड़ सकते हैं और रनटाइम पर उनके बीच स्विच कर सकते हैं। प्रत्येक ऑब्जेक्ट के लिए आवश्यक है: - provider: लोकल इनफेरेंस के लिए "ollama" सेट करें - model: वही एग्ज़ैक्ट टैग जैसा ollama list में दिखता है - apiBase: Ollama का डिफ़ॉल्ट REST एंडपॉइंट; इसे केवल तभी बदलें जब आपने पोर्ट को रीमैप किया हो

tabAutocompleteModel — इनलाइन ऑटोकम्पलीट के लिए एक समर्पित एंट्री। यह मॉडल हर कीस्ट्रोक पॉज़ पर फायर होता है, इसलिए यहाँ छोटा और तेज़ बेहतर है। FIM सपोर्ट के साथ 3B–7B पैरामीटर मॉडल सबसे उपयुक्त है।

tabAutocompleteOptions — ऑटोकम्पलीट इंजन पर बारीक नियंत्रण:

allowAnonymousTelemetry — इसे false पर सेट करें। आप स्थानीय AI इसलिए चला रहे हैं ताकि आपका कोड थर्ड-पार्टी सर्वर से दूर रहे; Continue के एनालिटिक्स पाइपलाइन को टेलीमेट्री भेजने का कोई कारण नहीं है।

कनेक्शन की जाँच करना

config.json सेव करने के बाद, VS Code Command Palette (Cmd+Shift+P / Ctrl+Shift+P) खोलकर और निम्नलिखित चलाकर पुष्टि करें कि Ollama Continue से पहुँच योग्य है:

Continue: Open Debug Panel

आपको एक हरे रंग का स्टेटस इंडिकेटर और एक सफल मॉडल पिंग दिखना चाहिए। यदि आपको connection refused एरर मिले, तो निम्नलिखित से सत्यापित करें कि Ollama चल रहा है:

ollama serve
# or check its status
curl http://localhost:11434/api/tags

आपके पुल किए गए मॉडलों को सूचीबद्ध करने वाला एक वैध JSON रिस्पॉन्स पुष्टि करता है कि API लाइव है और Continue कम्पलीशन प्रदान करने के लिए आगे बढ़ सकता है।

Step 5 चरण 3: Code Llama या StarCoder2 डाउनलोड करना

Continue.dev इंस्टॉल होने और आपके config.json के सेट होने के बाद, अगला महत्वपूर्ण निर्णय यह है कि आप वास्तव में अपनी मशीन पर कौन सा मॉडल डाउनलोड करते हैं। स्थानीय कोड कम्पलीशन और चैट के लिए, दो मॉडल प्रमुख हैं: Code Llama (Meta) और StarCoder2 (BigCode/Hugging Face)। दोनों Ollama के माध्यम से बेहतरीन तरीके से चलते हैं, लेकिन उनकी ताकत अर्थपूर्ण रूप से अलग है। आइए उन्हें विस्तार से देखें, फिर सटीक पुल कमांड देखें।

एक नज़र में मॉडल तुलना

सिफारिश: यदि आपके पास 8 GB VRAM या RAM उपलब्ध है, तो संतुलित अनुभव के लिए codellama:7b-code से शुरू करें। यदि आप पूरी तरह से इन-लाइन ऑटोकम्पलीट गुणवत्ता और मल्टी-लैंग्वेज सपोर्ट पर केंद्रित हैं, तो starcoder2:7b fill-in-the-middle (FIM) बेंचमार्क में अक्सर बेहतर प्रदर्शन करता है।

Ollama के माध्यम से Code Llama पुल करना

Ollama मॉडल प्रबंधन को बेहद सरल बनाता है। अपना टर्मिनल खोलें और चलाएँ:

# Lightweight 7B instruct variant — best starting point
ollama pull codellama:7b-instruct

# 7B code-specialized variant — better raw completion, less chat
ollama pull codellama:7b-code

यदि आपके पास हार्डवेयर की अतिरिक्त क्षमता है (13B काफी बेहतर है)

ollama pull codellama:13b-instruct

`instruct` वेरिएंट प्राकृतिक भाषा के निर्देशों को समझता है और Continue.dev के अंदर **चैट पैनल** के लिए आदर्श है। `code` वेरिएंट को सरल बनाया गया है और यह पूरी तरह से completion कार्यों के लिए तैयार किया गया है — इसे "autocomplete engine" वेरिएंट के रूप में सोचें।

मॉडल pull करने के बाद, सत्यापित करें कि यह उपलब्ध है:

```bash
ollama list

आपको इसके समान आउटपुट दिखना चाहिए:

NAME                    ID              SIZE    MODIFIED
codellama:7b-instruct   8fdf8f752f6e    3.8 GB  2 minutes ago

Ollama के माध्यम से StarCoder2 को Pull करना

StarCoder2 को विशेष रूप से fill-in-the-middle (FIM) कार्यों के लिए बनाया गया था — ठीक वही जिस पर IDE autocomplete निर्भर करती है। इसे The Stack v2 डेटासेट से 600 से अधिक प्रोग्रामिंग भाषाओं पर प्रशिक्षित किया गया था, जो इसे असाधारण रूप से व्यापक बनाता है।

# 3B — लगभग किसी भी आधुनिक मशीन पर चलता है, CPU-only सहित
ollama pull starcoder2:3b

# 7B — गुणवत्ता और संसाधन उपयोग के लिए सबसे उपयुक्त
ollama pull starcoder2:7b

# 15B — ~10+ GB VRAM की आवश्यकता है, लेकिन Copilot के करीब गुणवत्ता देता है
ollama pull starcoder2:15b

यह पुष्टि करने के लिए कि यह सही तरीके से प्रतिक्रिया दे रहा है, अपने टर्मिनल से मॉडल को तुरंत परीक्षण करें:

ollama run starcoder2:7b "Write a Python function to flatten a nested list."

यदि आपको सुसंगत, वाक्यात्मक रूप से सही आउटपुट मिलता है, तो आपका मॉडल Continue.dev के उपयोग के लिए तैयार है।

हार्डवेयर की सीमाओं पर एक नोट

बड़े पैरामीटर काउंट से डरें नहीं। Quantized मॉडल (जिन्हें Ollama डिफ़ॉल्ट रूप से pull करता है — आमतौर पर Q4_K_M quantization) अपने सैद्धांतिक आकार से काफी छोटे होते हैं। Q4 quantization में एक 7B मॉडल आराम से इन पर चलता है:

• Apple Silicon Macs (M1/M2/M3) 16 GB unified memory के साथ — Metal के माध्यम से नेटिव के करीब GPU acceleration
• NVIDIA GPUs 6–8 GB VRAM के साथ (RTX 3060, 4060, आदि)
• CPU-only machines 16+ GB RAM के साथ — धीमा, लेकिन चैट के लिए पूरी तरह कार्यात्मक; autocomplete में देरी ध्यान देने योग्य होगी

यदि आप CPU-bound हैं, तो दृढ़ता से starcoder2:3b या codellama:7b-code को प्राथमिकता दें — उनका छोटा मेमोरी फुटप्रिंट सीधे तेज़ टोकन जनरेशन और अधिक प्रतिक्रियाशील autocomplete अनुभव में बदलता है।

एक बार जब आपका चुना हुआ मॉडल pull और सत्यापित हो जाता है, तो Continue.dev इसे Ollama API endpoint (http://localhost:11434) के माध्यम से स्वचालित रूप से खोज लेगा जिसे आपने Step 2 में कॉन्फ़िगर किया था — कोई अतिरिक्त लिंकिंग आवश्यक नहीं है।

Step 6 स्थानीय Autocomplete और Chat के लिए सर्वोत्तम अभ्यास

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

मॉडल चयन की रणनीति

सभी मॉडल समान नहीं होते, और सही उपकरण कार्य पर निर्भर करता है। एक ही मॉडल को autocomplete और chat दोनों करने के लिए मजबूर करने के बजाय, इन दोनों के लिए अलग-अलग मॉडल चलाएं।

मुख्य अंतर्दृष्टि: autocomplete विलंबता-संवेदनशील है, chat गुणवत्ता-संवेदनशील है। 150ms में प्रतिक्रिया देने वाला 3B मॉडल completions के लिए जादुई लगता है। वही मॉडल किसी जटिल आर्किटेक्चरल प्रश्न का उथला उत्तर देते समय टूटा हुआ लगता है।

config.json में Autocomplete व्यवहार को Tune करना

Continue.dev में डिफ़ॉल्ट autocomplete सेटिंग्स रूढ़िवादी हैं। बेहतर अनुभव के लिए इन्हें आगे बढ़ाएं:

{
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85,
    "multilineCompletions": "always",
    "debounceDelay": 300
  }
}

मुख्य विकल्पों की व्याख्या:

• debounceDelay: 300 — आपके अंतिम keystroke के 300ms बाद completion request भेजता है। कम मान अधिक responsive लगते हैं लेकिन आपके GPU पर दबाव डालते हैं। अपनी सीमा खोजें।
• prefixPercentage: 0.85 — cursor से पहले के कोड को context window का 85% आवंटित करता है। यह आदर्श है क्योंकि प्रासंगिक completions उत्पन्न करने के लिए मॉडल को अधिकतम prefix context की आवश्यकता होती है।
• multilineCompletions: "always" — मॉडल को केवल एकल पंक्तियों के बजाय पूरे blocks को complete करने का प्रयास करने के लिए बाध्य करता है। Boilerplate generation के लिए आवश्यक।
• maxPromptTokens: 1024 — requests को हल्का रखता है। बड़े मान गुणवत्ता में मामूली सुधार करते हैं लेकिन consumer hardware पर विलंबता काफी बढ़ा देते हैं।

Chat के लिए Context Management

Chat interface वह जगह है जहाँ अधिकांश डेवलपर Continue.dev का कम उपयोग करते हैं। अंतर्निहित context providers का आक्रामक रूप से उपयोग करें:

• @file — अपने prompt में सीधे किसी विशिष्ट फ़ाइल का संदर्भ दें
• @codebase — आपके पूरे repo में embeddings search को सक्रिय करता है (एक embeddings model कॉन्फ़िगर करना आवश्यक है)
• @terminal — आपके सबसे हालिया terminal output को context में paste करता है
• @problems — VS Code Problems panel की सामग्री को inject करता है, compiler errors को debug करने के लिए उत्तम

Debugging के लिए उदाहरण workflow:

@problems @file src/auth/middleware.ts

The JWT validation is throwing a 401 on every request even with a valid token.
Walk me through what could cause this and show me the fix.

यह एकल prompt मॉडल को error message, संबंधित source file, और एक स्पष्ट समस्या विवरण देता है — जिससे output की गुणवत्ता में उल्लेखनीय सुधार होता है।

Hardware Optimization सुझाव

GPU उपयोगकर्ता (NVIDIA/AMD): सुनिश्चित करें कि Ollama वास्तव में आपके GPU का उपयोग कर रहा है न कि CPU पर वापस जा रहा है:

# Verify GPU utilization while a model is loaded
ollama ps

# Check VRAM usage
nvidia-smi  # NVIDIA
rocm-smi    # AMD

यदि ollama ps 100% CPU दिखाता है, तो संभवतः आपको VRAM overflow की समस्या है। एक छोटे quantization पर जाएं:

# Pull a smaller quantized variant
ollama pull codellama:13b-code-q4_K_M

केवल CPU उपयोगकर्ताओं के लिए: Autocomplete मॉडल को 3B parameters या उससे कम पर रखें। सबसे छोटे memory footprint के लिए q4_0 quantization का उपयोग करें और Ollama के environment में numThreads को अपने physical core count (hyperthreaded नहीं) के अनुसार सेट करें:

OLLAMA_NUM_PARALLEL=1 OLLAMA_MAX_LOADED_MODELS=1 ollama serve

CPU पर एक साथ दो मॉडल चलाने से thrashing होगी। MAX_LOADED_MODELS=1 रखें और autocomplete तथा chat मॉडल के बीच स्विच करते समय cold-load delay को स्वीकार करें।

सुसंगत परिणामों के लिए Prompt अनुशासन

Local मॉडल GPT-4 की तुलना में छोटे और prompt quality के प्रति अधिक संवेदनशील होते हैं। ये आदतें आपको घंटों की निराशा से बचाएंगी:

1. language और framework के बारे में स्पष्ट रहें। यह न मानें कि मॉडल जानता है कि आप Next.js 14 App Router प्रोजेक्ट में हैं। इसे स्पष्ट रूप से बताएं।
2. केवल विवरण नहीं, पूरी error पेस्ट करें। Line numbers के साथ पूरे stack trace अस्पष्ट विवरणों से कहीं बेहतर परिणाम देते हैं।
3. एक specific output format मांगें। Prompts के अंत में "Show only the modified function, no explanation" या "Explain first, then show the code" जोड़ें, जो आपकी आवश्यकता पर निर्भर करे।
4. असंबंधित कार्यों के बीच /clear का उपयोग करें। Python के बारे में पिछली बातचीत से context contamination एक नए TypeScript session में प्रतिक्रियाओं को खराब कर सकती है।

Cloud पर कब वापस जाएं

Local मॉडल हर use case के लिए universal replacement नहीं हैं। व्यावहारिक रहें:

कई teams के लिए privacy की गारंटी अपरिहार्य है — आपका कोड कभी भी machine से बाहर नहीं जाता। यह अकेला कारण ही local setup को उचित ठहराता है, भले ही cloud मॉडल कभी-कभी बेहतर उत्तर दें।

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference