Continue.dev एआई कोडिंग

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

Continue.dev एक ओपन-सोर्स AI कोडिंग सहायक है जो VS Code और JetBrains के लिए 25K+ GitHub सितारों के साथ उपलब्ध है। एक्सटेंशन आपके स्थानीय मशीन पर चलता है (या आपके IDE में), लेकिन यह इंफरेंस के लिए एक बैकएंड मॉडल सर्वर से जुड़ता है। Continue.dev को Clore.ai से किराए पर लिए गए शक्तिशाली GPU की ओर इशारा करके आप पाते हैं:

शीर्ष-स्तरीय कोडिंग मॉडल (34B+ पैरामीटर) जो आपके लैपटॉप पर बैठेंगे नहीं
पूर्ण गोपनीयता — कोड उस इन्फ्रास्ट्रक्चर पर रहता है जिसे आप नियंत्रित करते हैं
लचीला खर्च — केवल तब भुगतान करें जब आप कोड कर रहे हों (~$0.20–0.50/घं बनाम Copilot के $19/माह)
OpenAI-अनुकूल API — Continue.dev Ollama, vLLM, या TabbyML से सहज रूप से कनेक्ट होता है

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

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

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

अवलोकन

संपत्ति

विवरण

प्रोजेक्ट

continuedev/continue

लाइसेंस

Apache 2.0

GitHub स्टार्स

25K+

IDE समर्थन

VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, आदि)

कॉन्फ़िग फ़ाइल

~/.continue/config.json

बैकएंड विकल्प

Ollama, vLLM, TabbyML, LM Studio, llama.cpp, OpenAI-संगत APIs

कठिनाई

सरल (एक्सटेंशन इंस्टॉल) / मध्यम (स्व-होस्टेड बैकएंड)

GPU आवश्यक?

Clore.ai सर्वर पर (हाँ); आपके लैपटॉप पर (नहीं)

प्रमुख विशेषताएँ

ऑटोकम्प्लीट, चैट, एडिट मोड, कोडबेस संदर्भ (RAG), कस्टम स्लैश कमांड्स

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

मॉडल

VRAM

मजबूती

नोट्स

codellama:7b

~6 GB

तेज़ ऑटोकम्प्लीट

अच्छा शुरूआती विकल्प

codellama:13b

~10 GB

संतुलित

ऑटोकम्प्लीट के लिए सर्वोत्तम गुणवत्ता/गति

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.10/घं

CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B

अनुशंसित

RTX 3090

24 GB

32 GB

80 GB

~$0.20/घंटा

CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B

प्रदर्शन

RTX 4090

24 GB

32 GB

80 GB

~$0.35/घंटा

ऊपर के समान मॉडल, तेज़ इंफरेंस

शक्ति

A100 40GB

40 GB

64 GB

120 GB

~$0.60/घं

एक साथ कई 34B मॉडल

अधिकतम

A100 80GB

80 GB

200 GB

~$1.10/घंटा

70B मॉडल (CodeLlama 70B)

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

VS Code या कोई भी JetBrains IDE
Continue.dev एक्सटेंशन इंस्टॉल किया हुआ
आपके Clore.ai सर्वर के साथ स्थिर इंटरनेट कनेक्शन
कोई लोकल GPU आवश्यक नहीं — सभी इंफरेंस Clore.ai पर होते हैं

त्वरित प्रारम्भ

भाग 1: Clore.ai बैकएंड सेट अप करें

विकल्प A — Ollama बैकएंड (ज्यादातर उपयोगकर्ताओं के लिए अनुशंसित)

Ollama Continue.dev के लिए सबसे आसान बैकएंड है — सरल सेटअप, उत्कृष्ट मॉडल प्रबंधन, 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. एक तेज़ ऑटोकम्प्लीट मॉडल खींचें (चैट मॉडल से अलग)
docker exec ollama ollama pull starcoder2:3b   # बहुत तेज, FIM ऑटोकम्प्लीट के लिए शानदार

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

# 7. परीक्षण इंफरेंस
docker exec ollama ollama run qwen2.5-coder:32b "Write a Python function to binary search a sorted list"

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

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

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

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

vLLM तेज़ इंफरेंस और मल्टी-यूज़र समर्थन प्रदान करता है। आदर्श यदि कई डेवलपर एक 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

# मल्टी-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": "Write a hello world in Rust"}],
    "max_tokens": 200
  }'

विकल्प C — TabbyML बैकएंड (FIM ऑटोकम्प्लीट विशेषज्ञ)

TabbyML श्रेष्ठ fill-in-the-middle (FIM) ऑटोकम्प्लीट प्रदान करता है — इनलाइन घोस्ट-टेक्स्ट सुझाव। देखें TabbyML गाइड पूर्ण सेटअप विवरण के लिए।

# Continue.dev ऑटोकम्प्लीट के लिए त्वरित 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:

एक्सटेंशन्स पैनल खोलें (Ctrl+Shift+X / Cmd+Shift+X)
खोजें "Continue" — Continue (continuedev) द्वारा आधिकारिक एक्सटेंशन इंस्टॉल करें
साइडबार में Continue आइकन पर क्लिक करें (या Ctrl+Shift+I)

JetBrains (IntelliJ, PyCharm, WebStorm, GoLand):

File → Settings → Plugins → Marketplace
खोजें "Continue" और इंस्टॉल करें
IDE को रीस्टार्ट करें; Continue पैनल दाहिने साइडबार पर दिखाई देता है

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

संपादित करें ~/.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 (fast)",
      "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": "Edit selected code" },
    { "name": "comment", "description": "Add comments to code" },
    { "name": "share", "description": "Export conversation as markdown" },
    { "name": "cmd", "description": "Generate terminal command" },
    { "name": "commit", "description": "Generate git commit message" }
  ]
}

के लिए vLLM बैकएंड Ollama के बजाय:

{
  "models": [
    {
      "title": "Clore.ai — DeepSeek Coder 33B (vLLM)",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "not-required",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}

के लिए TabbyML बैकएंड (केवल ऑटोकम्प्लीट):

{
  "tabAutocompleteModel": {
    "title": "Clore.ai — TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "auth-token-if-set"
  }
}

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

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

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

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

# टनल को बनाए रखें (~/ .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 के साथ

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

# स्वतः पुनः कनेक्ट होने वाला स्थायी टनल चलाएँ
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=SSH tunnel to Clore.ai coding server
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) पर, आप एक बड़े चैट मॉडल और एक छोटे ऑटोकम्प्लीट मॉडल को एक साथ चला सकते हैं:

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

# मॉडल खींचें
docker exec ollama ollama pull qwen2.5-coder:32b      # चैट (22 GB)
docker exec ollama ollama pull starcoder2:3b           # ऑटोकम्प्लीट (2 GB)
docker exec ollama ollama pull nomic-embed-text        # एम्बेडिंग्स (0.5 GB)

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

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

कोडबेस इंडेक्सिंग (आपके रिपो के लिए RAG)

Continue.dev संदर्भ-आधारित सुझावों के लिए आपके कोडबेस को इंडेक्स कर सकता है। एक एम्बेडिंग मॉडल खींचें:

# Clore.ai सर्वर पर — Ollama में एम्बेडिंग मॉडल जोड़ें
docker exec ollama ollama pull nomic-embed-text

# लोकल config.json में एम्बेडिंग्स पहले से ऊपर कॉन्फ़िगर की गई हैं।
# Continue.dev स्वचालित रूप से आपका खुला वर्कस्पेस इंडेक्स करेगा।
# मैन्युअल री-इंडेक्स ट्रिगर करें: Ctrl+Shift+P → "Continue: Index Codebase"

GPU त्वरक

इन्फरेंस प्रदर्शन निगरानी करें

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

# प्रति सेकंड टोकन्स जांचें (Ollama लॉग्स)
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

~40–60 t/s

RTX 3060 12GB

DeepSeek-Coder 6.7B

~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

ऑटोकम्प्लीट (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: फ्लैश अटेंशन सक्षम करें (तेज़, कम मेमोरी)

टिप्स और सर्वोत्तम प्रथाएँ

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

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

{
  "models": [
    {
      "title": "Chat — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "जटिल प्रश्नों, कोड समीक्षा, आर्किटेक्चर निर्णयों के लिए सर्वश्रेष्ठ"
    },
    {
      "title": "Fast — CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "त्वरित उत्तर, सरल पूर्णताएँ, कम विलंबता"
    },
    {
      "title": "Autocomplete — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "इनलाइन घोस्ट-टेक्स्ट सुझाव"
    }
  ]
}

लागत तुलना

समाधान

मासिक लागत (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": "Review this code for bugs, security issues, and performance problems. Be specific and actionable.",
      "description": "कोड समीक्षा"
    },
    {
      "name": "test",
      "prompt": "Write comprehensive unit tests for this code. Include edge cases. Use the same language/framework as the code.",
      "description": "टेस्ट जनरेट करें"
    },
    {
      "name": "docstring",
      "prompt": "Add clear, comprehensive docstrings/comments to this code following best practices for the language.",
      "description": "डॉक्यूमेंटेशन जोड़ें"
    },
    {
      "name": "optimize",
      "prompt": "Optimize this code for performance. Explain what you changed and why.",
      "description": "कोड ऑप्टिमाइज़ करें"
    }
  ]
}

समस्याओं का निवारण

समस्या

संभावित कारण

समाधान

Continue.dev "Connection refused" दिखा रहा है

Ollama पहुँच योग्य नहीं है

जांचें कि SSH टनल सक्रिय है; सत्यापित करें curl http://localhost:11434/ काम करता है

ऑटोकम्प्लीट चालू नहीं हो रहा

Tab ऑटोकम्प्लीट मॉडल सेट नहीं है

जोड़ें 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('✅ Config is valid JSON')
    print(f'Models: {[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ Error: {e}')
" ~/.continue/config.json

अधिक पढ़ने के लिए

Continue.dev दस्तावेज़ीकरण — सभी IDE एकीकरण और कॉन्फ़िग विकल्पों के लिए आधिकारिक डॉक्स
Continue.dev GitHub — स्रोत कोड, समस्याएँ, मॉडल संगतता
Continue.dev कॉन्फ़िग संदर्भ — पूर्ण config.json में schema
Clore.ai पर Ollama — विस्तृत Ollama सेटअप गाइड (अनुशंसित बैकएंड)
Clore.ai पर vLLM — टीमों के लिए उच्च-प्रदर्शन वैकल्पिक बैकएंड
TabbyML on Clore.ai — FIM अनुकूलन के साथ विशेष ऑटोकंप्लीट बैकएंड
GPU तुलना मार्गदर्शिका — अपने कोडिंग कार्यभार के लिए सही GPU चुनें
मॉडल संगतता — कौन से मॉडल किस VRAM आकार में फिट होते हैं
Qwen2.5-Coder — वर्तमान में सर्वश्रेष्ठ खुला कोडिंग मॉडल
DeepSeek-Coder-V2 — लंबी संदर्भ क्षमता वाला मजबूत विकल्प
CLORE.AI मार्केटप्लेस — GPU सर्वर किराए पर लें

PreviousHaystack AI फ़्रेमवर्क Nextअवलोकन

Last updated 23 hours ago

Was this helpful?

hashtagअवलोकन

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

hashtagआवश्यकताएँ

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

hashtagलोकल आवश्यकताएँ (आपकी मशीन)

hashtagत्वरित प्रारम्भ

hashtagभाग 1: Clore.ai बैकएंड सेट अप करें

hashtagविकल्प A — Ollama बैकएंड (ज्यादातर उपयोगकर्ताओं के लिए अनुशंसित)

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

hashtagविकल्प C — TabbyML बैकएंड (FIM ऑटोकम्प्लीट विशेषज्ञ)

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

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

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

hashtagSSH टनल सेटअप (सुरक्षित रिमोट एक्सेस)

hashtagस्थायी टनल autossh के साथ

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

hashtagकोडबेस इंडेक्सिंग (आपके रिपो के लिए RAG)

hashtagGPU त्वरक

hashtagइन्फरेंस प्रदर्शन निगरानी करें

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

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

hashtagटिप्स और सर्वोत्तम प्रथाएँ

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

hashtagलागत तुलना

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

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

hashtagसमस्याओं का निवारण

hashtagडिबग कमांड्स

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

hashtagअधिक पढ़ने के लिए

अवलोकन

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

आवश्यकताएँ

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

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

त्वरित प्रारम्भ

भाग 1: Clore.ai बैकएंड सेट अप करें

विकल्प A — Ollama बैकएंड (ज्यादातर उपयोगकर्ताओं के लिए अनुशंसित)

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

विकल्प C — TabbyML बैकएंड (FIM ऑटोकम्प्लीट विशेषज्ञ)

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

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

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

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

स्थायी टनल autossh के साथ

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

कोडबेस इंडेक्सिंग (आपके रिपो के लिए RAG)

GPU त्वरक

इन्फरेंस प्रदर्शन निगरानी करें

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

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

टिप्स और सर्वोत्तम प्रथाएँ

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

लागत तुलना

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

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

समस्याओं का निवारण

डिबग कमांड्स

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

अधिक पढ़ने के लिए