> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/ai-platforms-and-agents/continue-dev.md).

# Continue.dev AI Coding

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 एक्सटेंशन जुड़ता है।

{% hint style="success" %}
सारे GPU सर्वर उदाहरण उन सर्वरों का उपयोग करते हैं जो [CLORE.AI मार्केटप्लेस के माध्यम से किराये पर लिए गए हैं](https://clore.ai/marketplace).
{% endhint %}

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

## अवलोकन

| गुण                  | विवरण                                                                |
| -------------------- | -------------------------------------------------------------------- |
| **प्रोजेक्ट**        | [continuedev/continue](https://github.com/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 | 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।

```bash
# 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 कनेक्ट कर सके):

```bash
# बाहरी एक्सेस सक्षम करके 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
```

{% hint style="warning" %}
पोर्ट 11434 को सार्वजनिक रूप से एक्सपोज़ करना डिफ़ॉल्ट रूप से कोई प्रमाणीकरण नहीं देता। प्रोडक्शन उपयोग के लिए, इसके बजाय SSH टनल सेट करें (देखें [टिप्स और सर्वोत्तम प्रथाएँ](#tips--best-practices)).
{% endhint %}

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

vLLM तेज़ इनफरेंस और मल्टी-यूज़र सपोर्ट प्रदान करता है। यदि कई डेवलपर्स एक ही Clore.ai सर्वर साझा करते हैं तो यह आदर्श है।

```bash
# 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 दस्तावेज़ीकरण](https://tabby.tabbyml.com/) पूरा सेटअप विवरण के लिए।

```bash
# 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:**

1. एक्सटेंशन्स पैनल खोलें (`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: Continue.dev को Clore.ai का उपयोग करने के लिए कॉन्फ़िगर करें

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

```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 के बजाय:

```json
{
  "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 बैकएंड** (केवल ऑटोकम्प्लीट):

```json
{
  "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 टनल का उपयोग करें:

```bash
# 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 के साथ

```bash
# अपनी लोकल मशीन पर 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) पर, आप एक बड़ा चैट मॉडल और एक छोटा ऑटोकम्प्लीट मॉडल एक साथ चला सकते हैं:

```bash
# 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 संदर्भ-सक्षम सुझावों के लिए आपके कोडबेस का इंडेक्स कर सकता है। एक एम्बेडिंग मॉडल पुल करें:

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

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

## GPU एक्सेलेरेशन

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

```bash
# अपने 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             | 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             |

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

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

```bash
# 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 आपको वार्तालाप के बीच में मॉडल बदलने देता है:

```json
{
  "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 घंटे के हिसाब से चार्ज करता है। सर्वर शुरू/रोकने के लिए एक साधारण स्क्रिप्ट का उपयोग करें:

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

# 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` सामान्य कोडिंग वर्कफ़्लो के लिए:

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

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

```bash
# आपकी 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 कॉन्फ़िग वैलिडेशन

```bash
# अपनी लोकल मशीन पर 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 दस्तावेज़](https://docs.continue.dev/) — सभी IDE इंटीग्रेशन और कॉन्फ़िग विकल्पों के लिए आधिकारिक डॉक्स
* [Continue.dev GitHub](https://github.com/continuedev/continue) — स्रोत कोड, इश्यूज़, मॉडल संगतता
* [Continue.dev कॉन्फ़िग संदर्भ](https://docs.continue.dev/reference) — पूरा `config.json` schema
* [Clore.ai पर Ollama](/guides/guides_v2-hi/language-models/ollama.md) — विस्तृत Ollama सेटअप गाइड (अनुशंसित बैकएंड)
* [Clore.ai पर vLLM](/guides/guides_v2-hi/language-models/vllm.md) — टीमों के लिए उच्च-प्रदर्शन वैकल्पिक बैकएंड
* [TabbyML](https://tabby.tabbyml.com/) — FIM अनुकूलन के साथ विशेषीकृत ऑटोकम्प्लीट बैकएंड
* [GPU तुलना गाइड](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — अपने कोडिंग कार्यभार के लिए सही GPU चुनें
* [मॉडल संगतता](/guides/guides_v2-hi/getting-started/model-compatibility.md) — कौन से मॉडल किस VRAM आकार में फिट होते हैं
* [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — वर्तमान में सबसे अच्छा ओपन कोडिंग मॉडल
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — लंबा संदर्भ रखने वाला एक मजबूत विकल्प
* [CLORE.AI मार्केटप्लेस के माध्यम से किराये पर लिए गए हैं](https://clore.ai/marketplace) — GPU सर्वर किराए पर लें


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/ai-platforms-and-agents/continue-dev.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.