> 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/continue-dev.md).

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

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

{% hint style="info" %}
**आर्किटेक्चर**: आपका IDE (Continue.dev एक्सटेंशन के साथ) → इंटरनेट → Clore.ai GPU सर्वर (Ollama / vLLM / TabbyML चला रहा) → स्थानीय मॉडल inference। कोई भी कोड कभी किसी तीसरे-पक्ष 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`                                                    |
| **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](https://clore.ai/bare-metal) | कई 34B मॉडल एक साथ                             |
| **अधिकतम**   | A100 80GB | 80 GB | 80 GB | 200 GB | [bare metal](https://clore.ai/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।

```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. एक तेज़ 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 कनेक्ट कर सके):

```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

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

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

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

vLLM तेज़ inference और multi-user समर्थन प्रदान करता है। यदि कई डेवलपर एक 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

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

```bash
# 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` अपने **लोकल मशीन**:

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

```json
{
  "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):

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

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

```bash
# अपनी लोकल मशीन (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 एक साथ चला सकते हैं:

```bash
# 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 डाउनलोड करें:

```bash
# 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 प्रदर्शन की निगरानी करें

```bash
# अपने 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 को ट्यून करें

```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: flash attention सक्षम करें (तेज़, कम मेमोरी)
```

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

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

कार्य प्रकार के अनुसार विशेषीकृत मॉडलों के साथ 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": "जटिल प्रश्नों, 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 प्रति घंटे शुल्क लेता है। सर्वर को शुरू/बंद करने के लिए एक सरल स्क्रिप्ट का उपयोग करें:

```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": "इस कोड में भाषा के सर्वोत्तम अभ्यासों का पालन करते हुए स्पष्ट, व्यापक 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`; छोटे मॉडल या क्वांटाइज़्ड संस्करण का उपयोग करें        |

### डीबग कमांड

```bash
# अपनी स्थानीय मशीन पर — कनेक्टिविटी का परीक्षण करें
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` स्कीमा
* [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/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.