Continue.dev AI कोडिंग

Clore.ai GPUs के साथ Continue.dev को पावर करें — निजी AI कोडिंग सहायता के लिए सस्ते GPU किरायों पर CodeLlama 34B, DeepSeek Coder, और Qwen2.5-Coder को लोकली चलाएँ।

Continue.dev VS Code और JetBrains के लिए एक ओपन-सोर्स AI कोडिंग असिस्टेंट है, जिसके 25K+ GitHub स्टार्स हैं। यह एक्सटेंशन आपकी लोकल मशीन पर चलता है (या आपके IDE में), लेकिन inference के लिए यह एक backend model server से कनेक्ट होता है। Clore.ai से किराए पर लिए गए शक्तिशाली GPU की ओर Continue.dev को इंगित करके, आपको मिलता है:

• शीर्ष-स्तरीय कोडिंग मॉडल (34B+ पैरामीटर) जो आपके लैपटॉप में फिट नहीं होंगे

• पूर्ण गोपनीयता — कोड आपके द्वारा नियंत्रित इन्फ्रास्ट्रक्चर पर ही रहता है

• लचीली लागत — केवल तब भुगतान करें जब आप कोडिंग कर रहे हों (~$0.20–0.50/घंटा बनाम Copilot के लिए $19/माह)

• OpenAI-संगत API — Continue.dev Ollama, vLLM, या TabbyML से सहजता से जुड़ता है

यह गाइड सेटअप पर केंद्रित है Clore.ai GPU backend (Ollama या vLLM) जिससे आपका स्थानीय Continue.dev एक्सटेंशन जुड़ता है।

सभी GPU सर्वर उदाहरण उन सर्वरों का उपयोग करते हैं जो के माध्यम से किराए पर लिए गए हैं CLORE.AI मार्केटप्लेस.

आर्किटेक्चर: आपका IDE (Continue.dev एक्सटेंशन के साथ) → इंटरनेट → Clore.ai GPU सर्वर (Ollama / vLLM / TabbyML चला रहा) → स्थानीय मॉडल inference। कोई भी कोड कभी किसी तीसरे-पक्ष API को नहीं छूता।

अवलोकन

गुण	विवरण
प्रोजेक्ट	continuedev/continue
लाइसेंस	Apache 2.0
GitHub स्टार्स	25K+
IDE समर्थन	VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, आदि)
कॉन्फ़िग फ़ाइल	~/.continue/config.json
backend विकल्प	Ollama, vLLM, TabbyML, LM Studio, llama.cpp, OpenAI-संगत APIs
कठिनाई	आसान (एक्सटेंशन इंस्टॉल) / मध्यम (self-hosted backend)
GPU आवश्यक?	Clore.ai सर्वर पर (हाँ); आपके लैपटॉप पर (नहीं)
मुख्य विशेषताएँ	Autocomplete, chat, edit mode, codebase context (RAG), custom slash commands

कोडिंग के लिए अनुशंसित मॉडल

मॉडल	VRAM	शक्ति	नोट्स
codellama:7b	~6 GB	तेज़ autocomplete	अच्छा शुरुआती विकल्प
codellama:13b	~10 GB	संतुलित	autocomplete के लिए गुणवत्ता/गति का सर्वोत्तम संतुलन
codellama:34b	~22 GB	CodeLlama की सर्वोत्तम गुणवत्ता	RTX 3090 / A100 की आवश्यकता है
deepseek-coder:6.7b	~5 GB	Python/JS विशेषज्ञ	वेब डेवलपमेंट के लिए उत्कृष्ट
deepseek-coder:33b	~22 GB	शीर्ष-स्तरीय ओपन सोर्स	कोड पर GPT-4 को टक्कर देता है
qwen2.5-coder:7b	~6 GB	बहुभाषी कोड	40+ भाषाओं में मजबूत
qwen2.5-coder:32b	~22 GB	अत्याधुनिक	2024 का सर्वश्रेष्ठ ओपन कोडिंग मॉडल
starcoder2:15b	~12 GB	कोड कंप्लीशन विशेषज्ञ	FIM (fill-in-the-middle) समर्थन

आवश्यकताएँ

Clore.ai सर्वर आवश्यकताएँ

टियर	GPU	VRAM	RAM	डिस्क	कीमत	मॉडल
बजट	RTX 3060	12 GB	16 GB	40 GB	$0.03–0.07/घंटा	CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B
अनुशंसित	RTX 3090	24 GB	32 GB	80 GB	$0.07–0.21/hr	CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B
प्रदर्शन	RTX 4090	24 GB	32 GB	80 GB	$0.14–0.42/hr	ऊपर जैसे ही मॉडल, लेकिन तेज़ inference
पावर	A100 40GB	40 GB	64 GB	120 GB	bare metal	कई 34B मॉडल एक साथ
अधिकतम	A100 80GB	80 GB	80 GB	200 GB	bare metal	70B मॉडल (CodeLlama 70B)

स्थानीय आवश्यकताएँ (आपकी मशीन)

• VS Code या कोई भी JetBrains IDE

• Continue.dev एक्सटेंशन इंस्टॉल किया हुआ

• अपने Clore.ai सर्वर से स्थिर इंटरनेट कनेक्शन

• कोई स्थानीय GPU आवश्यक नहीं — सभी inference Clore.ai पर होता है

त्वरित शुरुआत

भाग 1: Clore.ai backend सेट करें

विकल्प A — Ollama backend (अधिकांश उपयोगकर्ताओं के लिए अनुशंसित)

Ollama Continue.dev के लिए सबसे आसान backend है — सरल सेटअप, उत्कृष्ट मॉडल प्रबंधन, OpenAI-संगत API।

# 1. अपने Clore.ai सर्वर में SSH करें
ssh root@<clore-server-ip> -p <port>

# 2. GPU समर्थन के साथ Ollama शुरू करें
docker run -d \\
  --name ollama \
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  --restart unless-stopped \\
  ollama/ollama

# 3. सत्यापित करें कि Ollama चल रहा है
curl http://localhost:11434/

# 4. अपना कोडिंग मॉडल डाउनलोड करें (अपने VRAM के आधार पर चुनें)
# 12GB VRAM (RTX 3060) के लिए:
docker exec ollama ollama pull codellama:13b

# 24GB VRAM (RTX 3090 / RTX 4090) के लिए:
docker exec ollama ollama pull qwen2.5-coder:32b
# या:
docker exec ollama ollama pull deepseek-coder:33b

# 5. एक तेज़ autocomplete मॉडल डाउनलोड करें (chat model से अलग)
docker exec ollama ollama pull starcoder2:3b   # FIM autocomplete के लिए बहुत तेज़, शानदार

# 6. सत्यापित करें कि मॉडल उपलब्ध हैं
docker exec ollama ollama list

# 7. inference का परीक्षण करें
docker exec ollama ollama run qwen2.5-coder:32b "एक सॉर्टेड लिस्ट पर binary search करने के लिए Python फ़ंक्शन लिखें"

Ollama को बाहरी रूप से एक्सपोज़ करने के लिए (ताकि आपका स्थानीय IDE कनेक्ट कर सके):

# बाहरी पहुँच सक्षम करके Ollama को रीस्टार्ट करें
docker stop ollama && docker rm ollama

docker run -d \\
  --name ollama \
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \\
  --restart unless-stopped \\
  ollama/ollama

# अपनी LOCAL मशीन से परीक्षण करें:
curl http://<clore-server-ip>:11434/api/tags

पोर्ट 11434 को सार्वजनिक रूप से एक्सपोज़ करने पर डिफ़ॉल्ट रूप से कोई authentication नहीं होती। उत्पादन उपयोग के लिए, इसके बजाय SSH tunnel सेट करें (देखें टिप्स और सर्वोत्तम अभ्यास).

विकल्प B — vLLM backend (उच्च-थ्रूपुट / OpenAI-संगत)

vLLM तेज़ inference और multi-user समर्थन प्रदान करता है। यदि कई डेवलपर एक Clore.ai सर्वर साझा करते हैं, तो यह आदर्श है।

# OpenAI-संगत API के साथ vLLM शुरू करें
docker run -d \\
  --name vllm \\
  --gpus all \\
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \\
  -e HF_TOKEN="your-huggingface-token" \\
  --restart unless-stopped \\
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --dtype auto \\
  --max-model-len 32768 \\
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.90 \
  --served-model-name qwen2.5-coder-32b

# multi-GPU (जैसे, दो RTX 3090s) के लिए:
docker run -d \\
  --name vllm \\
  --gpus all \\
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \\
  -e HF_TOKEN="your-huggingface-token" \\
  vllm/vllm-openai:latest \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \\
  --tensor-parallel-size 2 \\
  --dtype auto \\
  --max-model-len 65536 \\
  --served-model-name deepseek-coder-v2

# API का परीक्षण करें
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder-32b",
    "messages": [{"role": "user", "content": "Rust में hello world लिखें"}],
    "max_tokens": 200
  }'

विकल्प C — TabbyML backend (FIM autocomplete विशेषज्ञ)

TabbyML श्रेष्ठ fill-in-the-middle (FIM) autocomplete प्रदान करता है — inline ghost-text सुझाव। देखें TabbyML दस्तावेज़ीकरण पूरे सेटअप विवरण के लिए।

# Continue.dev autocomplete के लिए त्वरित TabbyML सेटअप
docker run -d \\
  --name tabby \\
  --gpus all \\
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \\
  --restart unless-stopped \\
  tabbyml/tabby serve \\
  --model StarCoder2-7B \\
  --chat-model Mistral-7B \\
  --device cuda

# सत्यापित करें
curl http://localhost:8080/v1/health

भाग 2: Continue.dev एक्सटेंशन इंस्टॉल करें

VS Code:

1. Extensions panel खोलें (Ctrl+Shift+X / Cmd+Shift+X)

2. खोजें "Continue" — Continue (continuedev) द्वारा आधिकारिक एक्सटेंशन इंस्टॉल करें

3. साइडबार में Continue आइकन पर क्लिक करें (या Ctrl+Shift+I)

JetBrains (IntelliJ, PyCharm, WebStorm, GoLand):

1. File → Settings → Plugins → Marketplace

2. खोजें "Continue" और इंस्टॉल करें

3. IDE को रीस्टार्ट करें; Continue पैनल दाईं साइडबार में दिखाई देता है

भाग 3: Clore.ai का उपयोग करने के लिए Continue.dev को कॉन्फ़िगर करें

संपादित करें ~/.continue/config.json अपने लोकल मशीन:

{
  "models": [
    {
      "title": "Clore.ai — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 32768,
      "completionOptions": {
        "temperature": 0.1,
        "topP": 0.95,
        "maxTokens": 4096
      }
    },
    {
      "title": "Clore.ai — CodeLlama 13B (तेज़)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 16384
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" },
    { "name": "folder" },
    { "name": "codebase" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "चयनित कोड संपादित करें" },
    { "name": "comment", "description": "कोड में टिप्पणियाँ जोड़ें" },
    { "name": "share", "description": "वार्तालाप को markdown के रूप में निर्यात करें" },
    { "name": "cmd", "description": "टर्मिनल कमांड जनरेट करें" },
    { "name": "commit", "description": "git commit संदेश जनरेट करें" }
  ]
}

के लिए vLLM backend Ollama के बजाय:

{
  "models": [
    {
      "title": "Clore.ai — DeepSeek Coder 33B (vLLM)",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "आवश्यक नहीं",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}

के लिए TabbyML backend (केवल autocomplete):

{
  "tabAutocompleteModel": {
    "title": "Clore.ai — TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "यदि सेट किया गया हो तो auth-token"
  }
}

कॉन्फ़िगरेशन

SSH Tunnel सेटअप (सुरक्षित रिमोट एक्सेस)

पोर्ट्स को सार्वजनिक रूप से एक्सपोज़ करने के बजाय, अपनी लोकल मशीन से SSH tunnel का उपयोग करें:

# SSH tunnel खोलें: स्थानीय पोर्ट 11434 → Clore.ai सर्वर पोर्ट 11434
ssh -N -L 11434:localhost:11434 root@<clore-server-ip> -p <clore-ssh-port>

# tunnel को जीवित रखें (~/.ssh/config में जोड़ें):
Host clore-coding
  HostName <clore-server-ip>
  Port <clore-ssh-port>
  User root
  LocalForward 11434 localhost:11434
  LocalForward 8000 localhost:8000
  ServerAliveInterval 60
  ServerAliveCountMax 3

# इससे कनेक्ट करें:
ssh -N clore-coding

# फिर config.json में localhost का उपयोग करें:
# "apiBase": "http://localhost:11434"

autossh के साथ स्थायी tunnel

# अपनी लोकल मशीन (Linux/macOS) पर autossh इंस्टॉल करें
sudo apt install autossh   # Ubuntu/Debian
brew install autossh       # macOS

# ऐसा स्थायी tunnel चलाएँ जो स्वचालित रूप से पुनः कनेक्ट हो
autossh -M 0 -N \\
  -o "ServerAliveInterval 30" \\
  -o "ServerAliveCountMax 3" \\
  -L 11434:localhost:11434 \\
  root@<clore-server-ip> -p <clore-ssh-port>

# बूट पर स्वचालित प्रारंभ के लिए systemd में जोड़ें (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Description=Clore.ai coding server के लिए SSH tunnel
After=network.target

[Service]
ExecStart=autossh -M 0 -N \\
  -o StrictHostKeyChecking=accept-new \\
  -o ServerAliveInterval=30 \\
  -o ServerAliveCountMax=3 \\
  -L 11434:localhost:11434 \\
  root@CLORE_IP -p CLORE_PORT
Restart=always
RestartSec=10

[Install]
WantedBy=default.target
EOF

systemctl --user enable clore-tunnel
systemctl --user start clore-tunnel

विभिन्न कार्यों के लिए कई मॉडल लोड करें

RTX 3090 (24 GB) के लिए, आप एक बड़ा chat model और एक छोटा autocomplete model एक साथ चला सकते हैं:

# Clore.ai सर्वर पर:

# मॉडल डाउनलोड करें
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 GB)
docker exec ollama ollama pull starcoder2:3b           # Autocomplete (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0.5 GB)

# Ollama मॉडल स्वैपिंग को स्वचालित रूप से संभालता है
# स्मार्ट कैशिंग के साथ सभी तीन 24 GB VRAM में फिट हो जाते हैं

# VRAM उपयोग की निगरानी करें
nvidia-smi --query-gpu=memory.used,memory.free --format=csv -l 5

Codebase Indexing (आपके repo के लिए RAG)

Continue.dev context-aware सुझावों के लिए आपके codebase को index कर सकता है। एक embedding model डाउनलोड करें:

# Clore.ai सर्वर पर — Ollama में embedding model जोड़ें
docker exec ollama ollama pull nomic-embed-text

# स्थानीय config.json में, embeddings पहले से ऊपर कॉन्फ़िगर हैं।
# Continue.dev आपका खुला workspace स्वचालित रूप से index करेगा।
# मैन्युअल re-index ट्रिगर करें: Ctrl+Shift+P → "Continue: Index Codebase"

GPU त्वरण

Inference प्रदर्शन की निगरानी करें

# अपने Clore.ai सर्वर पर — कोडिंग सत्रों के दौरान GPU पर नज़र रखें
watch -n 1 nvidia-smi

# सेकंड प्रति टोकन जाँचें (Ollama logs)
docker logs ollama --tail 20 -f

# विस्तृत GPU आँकड़े
nvidia-smi dmon -s u -d 2

# मेमोरी विभाजन
nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu \\
  --format=csv,noheader -l 5

GPU के अनुसार अपेक्षित प्रदर्शन

GPU	मॉडल	संदर्भ	टोकन/सेकंड (लगभग)
RTX 3060 12GB	CodeLlama 7B	8K	~40–60 t/s
RTX 3060 12GB	DeepSeek-Coder 6.7B	8K	~45–65 t/s
RTX 3090 24GB	Qwen2.5-Coder 32B (Q4)	16K	~15–25 t/s
RTX 3090 24GB	DeepSeek-Coder 33B (Q4)	16K	~15–22 t/s
RTX 4090 24GB	Qwen2.5-Coder 32B (Q4)	16K	~25–40 t/s
A100 40GB	Qwen2.5-Coder 32B (FP16)	32K	~35–50 t/s
A100 80GB	CodeLlama 70B (Q4)	32K	~20–30 t/s

autocomplete (fill-in-the-middle) के लिए, starcoder2:3b या codellama:7b 50–100 t/s तक पहुँचता है — IDE में तुरंत जैसा महसूस होने के लिए पर्याप्त तेज़।

बेहतर प्रदर्शन के लिए Ollama को ट्यून करें

# Clore.ai सर्वर पर — Ollama सेटिंग्स को अनुकूलित करें
docker stop ollama && docker rm ollama

docker run -d \\
  --name ollama \
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \\
  -e OLLAMA_NUM_PARALLEL=2 \\
  -e OLLAMA_MAX_LOADED_MODELS=2 \\
  -e OLLAMA_FLASH_ATTENTION=1 \\
  --restart unless-stopped \\
  ollama/ollama

# OLLAMA_NUM_PARALLEL=2: 2 अनुरोधों को एक साथ सर्व करें
# OLLAMA_MAX_LOADED_MODELS=2: GPU मेमोरी में 2 मॉडल रखें
# OLLAMA_FLASH_ATTENTION=1: flash attention सक्षम करें (तेज़, कम मेमोरी)

टिप्स और सर्वोत्तम अभ्यास

विभिन्न कार्यों के लिए अलग-अलग मॉडल उपयोग करें

कार्य प्रकार के अनुसार विशेषीकृत मॉडलों के साथ Continue.dev को कॉन्फ़िगर करें — UI आपको बातचीत के बीच में मॉडल बदलने देता है:

{
  "models": [
    {
      "title": "Chat — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "जटिल प्रश्नों, code review, architecture decisions के लिए सर्वश्रेष्ठ"
    },
    {
      "title": "Fast — CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "त्वरित उत्तर, सरल completions, कम latency"
    },
    {
      "title": "Autocomplete — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "inline ghost-text सुझाव"
    }
  ]
}

लागत तुलना

समाधान	मासिक लागत (8 घंटे/दिन उपयोग)	गोपनीयता	मॉडल गुणवत्ता
GitHub Copilot	$19/उपयोगकर्ता/माह	❌ Microsoft क्लाउड	GPT-4o (बंद)
Cursor Pro	$20/उपयोगकर्ता/माह	❌ Cursor क्लाउड	Claude 3.5 (बंद)
Clore.ai पर RTX 3060	लगभग $24/माह	✅ आपका सर्वर	CodeLlama 13B
Clore.ai पर RTX 3090	लगभग $48/माह	✅ आपका सर्वर	Qwen2.5-Coder 32B
Clore.ai पर RTX 4090	लगभग $84/माह	✅ आपका सर्वर	Qwen2.5-Coder 32B
Clore.ai पर A100 80GB	लगभग $264/माह	✅ आपका सर्वर	CodeLlama 70B

3+ डेवलपर्स की एक टीम के लिए, जो एक Clore.ai RTX 3090 (~$48/माह कुल) साझा कर रही है, प्रति-उपयोगकर्ता लागत Copilot से कम पड़ती है, जबकि एक बड़ा, निजी मॉडल मिलता है.

कोडिंग न होने पर बंद करें

Clore.ai प्रति घंटे शुल्क लेता है। सर्वर को शुरू/बंद करने के लिए एक सरल स्क्रिप्ट का उपयोग करें:

# इन्हें स्थानीय स्क्रिप्ट के रूप में सहेजें

# start-coding-server.sh
#!/bin/bash
echo "Clore.ai के लिए SSH टनल खोली जा रही है..."
ssh -N -f -L 11434:localhost:11434 clore-coding
echo "टनल खुल गई है। Continue.dev तैयार है."

# stop-coding-server.sh
#!/bin/bash
echo "SSH टनल बंद की जा रही है..."
pkill -f "ssh.*clore-coding"
echo "टनल बंद हो गई है। बिलिंग रोकने के लिए अपना Clore.ai ऑर्डर भी रोकना याद रखें!"

Continue.dev के कस्टम कमांड्स का उपयोग करें

कस्टम स्लैश कमांड जोड़ें config.json सामान्य कोडिंग वर्कफ़्लो के लिए:

{
  "customCommands": [
    {
      "name": "review",
      "prompt": "इस कोड की बग्स, सुरक्षा समस्याओं, और प्रदर्शन मुद्दों के लिए समीक्षा करें। विशिष्ट और कार्रवाई योग्य रहें।",
      "description": "कोड समीक्षा"
    },
    {
      "name": "test",
      "prompt": "इस कोड के लिए व्यापक यूनिट टेस्ट लिखें। किनारे के मामले शामिल करें। कोड की ही भाषा/फ्रेमवर्क का उपयोग करें।",
      "description": "टेस्ट जनरेट करें"
    },
    {
      "name": "docstring",
      "prompt": "इस कोड में भाषा के सर्वोत्तम अभ्यासों का पालन करते हुए स्पष्ट, व्यापक docstrings/comments जोड़ें।",
      "description": "दस्तावेज़ीकरण जोड़ें"
    },
    {
      "name": "optimize",
      "prompt": "इस कोड को प्रदर्शन के लिए अनुकूलित करें। आपने क्या बदला और क्यों, यह समझाएँ।",
      "description": "कोड अनुकूलित करें"
    }
  ]
}

समस्या निवारण

समस्या	संभावित कारण	समाधान
Continue.dev में "Connection refused" दिखता है	Ollama उपलब्ध नहीं है	जांचें कि SSH टनल सक्रिय है; सत्यापित करें curl http://localhost:11434/ काम करता है
ऑटोकम्प्लीट ट्रिगर नहीं हो रहा	टैब ऑटोकम्प्लीट मॉडल सेट नहीं है	जोड़ें tabAutocompleteModel इसे config.json में जोड़ें; Continue सेटिंग्स में सक्षम करें
बहुत धीमे जवाब (>30s पहला टोकन)	मॉडल डिस्क से लोड हो रहा है	पहला अनुरोध मॉडल को VRAM में लोड करता है — बाद के अनुरोध तेज़ होते हैं
"Model not found" त्रुटि	मॉडल पुल नहीं किया गया	चलाएँ docker exec ollama ollama pull <model-name> Clore.ai सर्वर पर
टोकनों के बीच उच्च विलंबता	नेटवर्क लैग या मॉडल बहुत बड़ा है	SSH टनल का उपयोग करें; छोटे मॉडल पर स्विच करें; सर्वर GPU उपयोग जाँचें
कोडबेस संदर्भ काम नहीं कर रहा	एम्बेडिंग्स मॉडल गायब है	पुल करें nomic-embed-text Ollama के माध्यम से; जांचें embeddingsProvider config.json में
SSH टनल बार-बार टूटती है	अस्थिर कनेक्शन	उपयोग करें autossh लगातार पुनःकनेक्शन के लिए; जोड़ें ServerAliveInterval 30
कॉन्टेक्स्ट विंडो पार हो गई	लंबी फ़ाइलें/वार्तालाप	कम करें contextLength इसे config.json में सेट करें; लंबे कॉन्टेक्स्ट वाले मॉडल का उपयोग करें
JetBrains प्लगइन लोड नहीं हो रहा	IDE संस्करण असंगतता	JetBrains IDE को नवीनतम संस्करण में अपडेट करें; Continue.dev प्लगइन संगतता मैट्रिक्स जांचें
लोडिंग के दौरान vLLM OOM	पर्याप्त VRAM नहीं है	जोड़ें --gpu-memory-utilization 0.85; छोटे मॉडल या क्वांटाइज़्ड संस्करण का उपयोग करें

डीबग कमांड

# अपनी स्थानीय मशीन पर — कनेक्टिविटी का परीक्षण करें
curl http://localhost:11434/api/tags          # यदि SSH टनल का उपयोग कर रहे हैं
curl http://<clore-ip>:11434/api/tags        # यदि पोर्ट सीधे खुला है

# CLORE.AI सर्वर पर — Ollama जांचें
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # वर्तमान में लोड किए गए मॉडल दिखाएं

# मॉडल प्रतिक्रिया समय का परीक्षण करें
time curl http://localhost:11434/api/generate \
  -d '{"model": "codellama:7b", "prompt": "def hello():", "stream": false}'

# GPU मेमोरी जांचें
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# vLLM लॉग जांचें
docker logs vllm --tail 50 -f

# मॉडल खोए बिना Ollama पुनरारंभ करें
docker restart ollama

Continue.dev कॉन्फ़िग सत्यापन

# अपनी स्थानीय मशीन पर config.json सिंटैक्स सत्यापित करें
python3 -c \"
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ कॉन्फ़िग मान्य JSON है')
    print(f'Models: {[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ त्रुटि: {e}')
\" ~/.continue/config.json

अधिक पढ़ें

• Continue.dev दस्तावेज़ — सभी IDE एकीकरणों और कॉन्फ़िग विकल्पों के लिए आधिकारिक दस्तावेज़

• Continue.dev GitHub — सोर्स कोड, समस्याएँ, मॉडल संगतता

• Continue.dev कॉन्फ़िग संदर्भ — पूर्ण config.json स्कीमा

• Clore.ai पर Ollama — विस्तृत Ollama सेटअप मार्गदर्शिका (अनुशंसित बैकएंड)

• Clore.ai पर vLLM — टीमों के लिए उच्च-प्रदर्शन वैकल्पिक बैकएंड

• TabbyML — FIM अनुकूलन के साथ विशेषीकृत ऑटोकम्प्लीट बैकएंड

• GPU तुलना गाइड — अपने कोडिंग वर्कलोड के लिए सही GPU चुनें

• मॉडल संगतता — कौन से मॉडल किस VRAM आकार में फिट होते हैं

• Qwen2.5-Coder — वर्तमान में सबसे अच्छा ओपन कोडिंग मॉडल

• DeepSeek-Coder-V2 — लंबे कॉन्टेक्स्ट वाला एक मजबूत विकल्प

• CLORE.AI मार्केटप्लेस — GPU सर्वर किराए पर लें