Continue.dev AI कोडिंग

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

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 मार्केटप्लेस के माध्यम से किराये पर लिए गए हैं.

आर्किटेक्चर: आपका 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": "चुने हुए कोड को संपादित करें" },
    { "name": "comment", "description": "कोड में टिप्पणियाँ जोड़ें" },
    { "name": "share", "description": "संवाद को मार्कडाउन के रूप में एक्सपोर्ट करें" },
    { "name": "cmd", "description": "टर्मिनल कमांड उत्पन्न करें" },
    { "name": "commit", "description": "git कमिट संदेश उत्पन्न करें" }
  ]
}

के लिए 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": "इस कोड की बग, सुरक्षा समस्याओं और प्रदर्शन समस्याओं के लिए समीक्षा करें। विशिष्ट और क्रियान्वयन योग्य रहें।",
      "description": "कोड समीक्षा"
    },
    {
      "name": "test",
      "prompt": "इस कोड के लिए व्यापक यूनिट टेस्ट लिखें। एज केस शामिल करें। कोड की ही भाषा/फ्रेमवर्क का उपयोग करें।",
      "description": "टेस्ट जेनरेट करें"
    },
    {
      "name": "docstring",
      "prompt": "इस कोड में भाषा के बेहतरीन अभ्यासों के अनुसार स्पष्ट, व्यापक डॉकस्ट्रिंग/कॉमेंट्स जोड़ें।",
      "description": "डॉक्यूमेंटेशन जोड़ें"
    },
    {
      "name": "optimize",
      "prompt": "इस कोड को प्रदर्शन के लिए अनुकूलित करें। आपने क्या बदला और क्यों, समझाएँ।",
      "description": "कोड अनुकूलित करें"
    }
  ]
}

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

समस्या

संभावित कारण

समाधान

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

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

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

ऑटोकम्प्लीट ट्रिगर नहीं हो रहा

Tab autocomplete मॉडल सेट नहीं है

जोड़ें 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; छोटा मॉडल या क्वांटाइज़्ड संस्करण उपयोग करें

डिबग कमांड्स

# आपकी LOCAL मशीन पर — कनेक्टिविटी टेस्ट करें
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 schema
Clore.ai पर Ollama — विस्तृत Ollama सेटअप गाइड (अनुशंसित बैकएंड)
Clore.ai पर vLLM — टीमों के लिए उच्च-प्रदर्शन वैकल्पिक बैकएंड
TabbyML — FIM अनुकूलन के साथ विशेषीकृत ऑटोकम्प्लीट बैकएंड
GPU तुलना गाइड — अपने कोडिंग कार्यभार के लिए सही GPU चुनें
मॉडल संगतता — कौन से मॉडल किस VRAM आकार में फिट होते हैं
Qwen2.5-Coder — वर्तमान में सबसे अच्छा ओपन कोडिंग मॉडल
DeepSeek-Coder-V2 — लंबा संदर्भ रखने वाला एक मजबूत विकल्प
CLORE.AI मार्केटप्लेस के माध्यम से किराये पर लिए गए हैं — GPU सर्वर किराए पर लें

PreviousHaystack AI फ़्रेमवर्क NextOpen Interpreter

Last updated 8 days 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 द्वारा अपेक्षित प्रदर्शन

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

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 कॉन्फ़िग वैलिडेशन

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