> 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/language-models/deepseek-r1.md).

# DeepSeek-R1 रीजनिंग मॉडल

Clore.ai GPUs पर DeepSeek-R1 ओपन-सोर्स रीजनिंग मॉडल चलाएँ

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलते हैं, जिन्हें के माध्यम से किराये पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). RTX 4090 इंस्टेंस $0.14–0.42/घंटा से शुरू होते हैं।
{% endhint %}

## अवलोकन

DeepSeek-R1 एक 671B-पैरामीटर वाला ओपन-वेट रीजनिंग मॉडल है, जिसे जनवरी 2025 में DeepSeek द्वारा के तहत जारी किया गया था **Apache 2.0** लाइसेंस। यह पहला ओपन मॉडल है जो गणित, कोडिंग और वैज्ञानिक बेंचमार्क्स में OpenAI o1 की बराबरी करता है — जबकि अपनी पूरी चेन-ऑफ-थॉट को स्पष्ट `<think>` टैग्स के माध्यम से उजागर करता है।

पूरा मॉडल उपयोग करता है **Mixture-of-Experts (MoE)** प्रति टोकन 37B सक्रिय पैरामीटर के साथ, जिससे भारी पैरामीटर संख्या के बावजूद इन्फरेंस व्यावहारिक हो जाता है। अधिकांश प्रैक्टिशनरों के लिए, **डिस्टिल्ड वेरिएंट्स** (1.5B → 70B) अधिक व्यावहारिक हैं: वे ज्ञान-आसवन (knowledge distillation) के माध्यम से Qwen-2.5 और Llama-3 बेस आर्किटेक्चर में R1 के रीजनिंग पैटर्न को विरासत में लेते हैं और सामान्य GPU पर चलते हैं।

## मुख्य विशेषताएँ

* **स्पष्ट चेन-ऑफ-थॉट** — हर उत्तर एक `<think>` ब्लॉक से शुरू होता है जहाँ मॉडल अंतिम उत्तर देने से पहले तर्क करता है, वापस जाँचता है, और स्वयं-सुधार करता है
* **रीइन्फोर्समेंट-लर्निंग से प्रशिक्षित** — रीजनिंग क्षमता हाथ से लिखे गए चेन-ऑफ-थॉट डेटा के बजाय RL रिवॉर्ड सिग्नल्स से उभरती है
* **छह डिस्टिल्ड वेरिएंट्स** — 1.5B, 7B, 8B, 14B, 32B, 70B पैरामीटर मॉडल्स, जिन्हें पूर्ण 671B से Qwen और Llama आर्किटेक्चर में डिस्टिल किया गया है
* **Apache 2.0 लाइसेंस** — पूरी तरह व्यावसायिक, कोई रॉयल्टी नहीं, कोई उपयोग-प्रतिबंध नहीं
* **व्यापक फ्रेमवर्क समर्थन** — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI सभी बिना किसी अतिरिक्त सेटअप के काम करते हैं
* **AIME 2024 Pass\@1: 79.8%** — प्रतियोगिता गणित में OpenAI o1 के बराबर
* **Codeforces 2029 Elo** — प्रतिस्पर्धी प्रोग्रामिंग में o1 के 1891 से बेहतर

## मॉडल वेरिएंट

| वैरिएंट                 | पैरामीटर          | आर्किटेक्चर  | FP16 VRAM | Q4 VRAM  | Q4 Disk  |
| ----------------------- | ----------------- | ------------ | --------- | -------- | -------- |
| DeepSeek-R1 (पूर्ण MoE) | 671B (37B सक्रिय) | DeepSeek MoE | \~1.3 TB  | \~350 GB | \~340 GB |
| R1-Distill-Llama-70B    | 70B               | Llama 3      | 140 GB    | 40 GB    | 42 GB    |
| R1-Distill-Qwen-32B     | 32B               | Qwen 2.5     | 64 GB     | 22 GB    | 20 GB    |
| R1-Distill-Qwen-14B     | 14B               | Qwen 2.5     | 28 GB     | 10 GB    | 9 GB     |
| R1-Distill-Llama-8B     | 8B                | Llama 3      | 16 GB     | 6 GB     | 5.5 GB   |
| R1-Distill-Qwen-7B      | 7B                | Qwen 2.5     | 14 GB     | 5 GB     | 4.5 GB   |
| R1-Distill-Qwen-1.5B    | 1.5B              | Qwen 2.5     | 3 GB      | 2 जीबी   | 1.2 GB   |

### वेरिएंट चुनना

| उपयोग-प्रकरण                                  | अनुशंसित वेरिएंट       | Clore पर GPU                                                                                                                |
| --------------------------------------------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| त्वरित प्रयोग, एज टेस्टिंग                    | R1-Distill-Qwen-1.5B   | कोई भी GPU                                                                                                                  |
| बजट डिप्लॉयमेंट, तेज इन्फरेंस                 | R1-Distill-Qwen-7B     | RTX 3090 ($0.07–0.21/घंटा)                                                                                                  |
| एकल-GPU प्रोडक्शन का आदर्श विकल्प             | R1-Distill-Qwen-14B Q4 | [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) ($0.14–0.42/घंटा)   |
| कीमत के मुकाबले सर्वोत्तम गुणवत्ता (अनुशंसित) | R1-Distill-Qwen-32B Q4 | [RTX 4090 24 GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) या A100 40 GB |
| अधिकतम डिस्टिल्ड गुणवत्ता                     | R1-Distill-Llama-70B   | 2× A100 80 GB                                                                                                               |
| अनुसंधान, पूर्ण-निष्ठा रीजनिंग                | DeepSeek-R1 671B       | 8× H100 क्लस्टर                                                                                                             |

### HuggingFace रिपॉज़िटरीज़

| वैरिएंट           | रिपॉज़िटरी                                                                                                    |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| पूर्ण R1          | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Llama-70B distill | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B distill  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B distill   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1.5B distill | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## आवश्यकताएँ

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

| घटक        | न्यूनतम (7B Q4) | अनुशंसित (32B Q4) |
| ---------- | --------------- | ----------------- |
| GPU VRAM   | 6 GB            | 24 GB             |
| System RAM | 16 GB           | 32 GB             |
| डिस्क      | 10 GB           | 30 GB             |
| CUDA       | 12.8+           | 12.8+             |
| Docker     | 24.0+           | 25.0+             |

## Ollama क्विक स्टार्ट

Ollama quantization, डाउनलोडिंग, और सर्विंग को अपने-आप संभालता है — चल रहे DeepSeek-R1 तक पहुँचने का सबसे तेज़ रास्ता।

### इंस्टॉल करें और चलाएँ

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# पुल करें और चलाएँ (अपना वेरिएंट चुनें):
ollama run deepseek-r1:1.5b    # एज / टेस्टिंग
ollama run deepseek-r1:7b      # बजट — किसी भी 8 GB+ GPU पर फिट
ollama run deepseek-r1:14b     # RTX 4090 का आदर्श विकल्प
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB
```

### उदाहरणात्मक इंटरैक्टिव सत्र

```
>>> सिद्ध करें कि √2 अपरिमेय है।

<think>
मैं विरोधाभास द्वारा प्रमाण का उपयोग करूँगा।
मान लें कि √2 परिमेय है, इसलिए √2 = p/q जहाँ p,q पूर्णांक हैं और gcd(p,q) = 1।
तब 2 = p²/q², जिससे p² = 2q² मिलता है।
इसका अर्थ है कि p² सम है, इसलिए p भी सम होना चाहिए। p = 2k लिखें।
स्थानापन्न करें: (2k)² = 2q² → 4k² = 2q² → q² = 2k²।
तो q² भी सम है, जिसका अर्थ है q सम है।
लेकिन यदि p और q दोनों सम हैं, तो gcd(p,q) ≥ 2, जो हमारी धारणा के विरुद्ध है।
</think>

**सिद्धि कि √2 अपरिमेय है (विरोधाभास द्वारा):**

मान लें √2 = p/q न्यूनतम रूप में है (gcd(p,q) = 1)। वर्ग करने पर p² = 2q² मिलता है।
चूँकि p² सम है, p सम है — p = 2k लिखें। तब 4k² = 2q², इसलिए q² = 2k²,
जिसका अर्थ है q भी सम है। यह gcd(p,q) = 1 के विरुद्ध है। ∎
```

### OpenAI-संगत API का उपयोग करें

```bash
# Ollama को सर्वर के रूप में शुरू करें (यदि पहले से नहीं चल रहा है)
ollama serve &

# curl के माध्यम से क्वेरी करें
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "पूर्णांकों पर x^4 - 1 का पूर्ण गुणनखंड करें।"}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Python क्लाइंट (OpenAI SDK के माध्यम से)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "सबसे लंबा palindromic substring खोजने के लिए एक Python फ़ंक्शन लिखें।"}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## vLLM उत्पादन सेटअप

vLLM निरंतर batching, PagedAttention, और prefix caching के साथ multi-user serving के लिए उच्चतम throughput प्रदान करता है।

### एकल GPU — 7B / 14B

```bash
pip install vllm

# किसी भी 16 GB+ GPU पर 7B
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# RTX 4090 (24 GB) पर 14B
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92
```

### बहु-GPU — 32B (अनुशंसित)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \\
    --max-model-len 32768 \\
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching
```

> **सुझाव:** 32B Q4 GPTQ या AWQ चेकपॉइंट एकल RTX 4090 (24 GB) पर फिट बैठता है:
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

### बहु-GPU — 70B

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \\
    --gpu-memory-utilization 0.90
```

### vLLM endpoint को क्वेरी करें

```bash
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "हल करें: ऐसे सभी अभाज्य p खोजें कि p^2 + 2 भी अभाज्य हो।"}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (साथ में `<think>` टैग पार्सिंग)

जब आपको जनरेशन पर सूक्ष्म नियंत्रण चाहिए या R1 को Python पाइपलाइन में एकीकृत करना हो, तब HuggingFace Transformers का उपयोग करें।

### बुनियादी जनरेशन

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch, re

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "पहले 100 धनात्मक पूर्णांकों का योग क्या है?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)
```

### पार्सिंग `<think>` टैग्स

```python
def parse_r1_response(text: str) -> dict:
    """DeepSeek-R1 response को सोचने और उत्तर भागों में विभाजित करें।"""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"मॉडल ने {result['thinking_tokens']} शब्दों तक तर्क किया")
print(f"उत्तर: {result['answer']}")
```

### साथ में स्ट्रीमिंग `<think>` state tracking

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused")

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "ax² + bx + c = 0 से द्विघात सूत्र व्युत्पन्न करें।"}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[तर्क] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[उत्तर] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Clore.ai पर Docker डिप्लॉयमेंट

### Ollama Docker (सबसे सरल)

**Docker image:** `ollama/ollama` **पोर्ट:** `22/tcp, 11434/http`

```bash
# Clore इंस्टेंस पर
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \\
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# मॉडल को पुल करें और सर्व करें
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### vLLM Docker (प्रोडक्शन)

**Docker image:** `vllm/vllm-openai:latest` **पोर्ट:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Clore.ai पर डिप्लॉय करें:

1. खोलें [clore.ai/marketplace](https://clore.ai/marketplace)
2. के अनुसार फ़िल्टर करें **2× GPU, कुल 48 GB+ VRAM** (उदा. 2× RTX 4090 या A100 80 GB)
3. Docker image को सेट करें `vllm/vllm-openai:latest`
4. पोर्ट मैप करें **8000** को HTTP के रूप में
5. ऊपर दिए गए compose फ़ाइल से कमांड को startup command में पेस्ट करें
6. health check पास हो जाने के बाद HTTP endpoint के माध्यम से कनेक्ट करें

## Clore.ai डिप्लॉयमेंट के लिए सुझाव

### सही GPU चुनना

| बजट           | GPU              | दैनिक लागत   | सर्वोत्तम वेरिएंट                  |
| ------------- | ---------------- | ------------ | ---------------------------------- |
| न्यूनतम       | RTX 3090 (24 GB) | $0.30 – 1.00 | R1-Distill-Qwen-7B या 14B Q4       |
| मानक          | RTX 4090 (24 GB) | $0.50 – 2.00 | R1-Distill-Qwen-14B FP16 या 32B Q4 |
| प्रोडक्शन     | A100 80 GB       | $3 – 8       | R1-Distill-Qwen-32B FP16           |
| उच्च गुणवत्ता | 2× A100 80 GB    | $6 – 16      | R1-Distill-Llama-70B FP16          |

### प्रदर्शन अनुकूलन

* **Temperature 0.6** रीजनिंग कार्यों के लिए अनुशंसित डिफ़ॉल्ट है — DeepSeek के अपने पेपर्स इसी मान का उपयोग करते हैं
* **सेट करें `max_tokens` उदारता से** — रीजनिंग मॉडल लंबे `<think>` ब्लॉक उत्पन्न करते हैं; गैर-तुच्छ समस्याओं के लिए 4096+
* **prefix caching सक्षम करें** (`--enable-prefix-caching` vLLM में) जब साझा सिस्टम प्रॉम्प्ट का उपयोग कर रहे हों
* **concurrency सीमित करें** (`--max-num-seqs 16`) रीजनिंग workloads के लिए — प्रत्येक अनुरोध मानक चैट से अधिक compute उपयोग करता है
* **Q4 quantization का उपयोग करें** ताकि 32B को एकल 24 GB GPU पर न्यूनतम गुणवत्ता हानि के साथ फिट किया जा सके (distill पहले से ही R1 के ज्ञान को संपीड़ित करता है)

### context length संबंधी विचार

रीजनिंग मॉडल मानक चैट मॉडल्स की तुलना में अधिक context उपयोग करते हैं क्योंकि `<think>` ब्लॉक:

| कार्य जटिलता            | सामान्य सोच की लंबाई | आवश्यक कुल context |
| ----------------------- | -------------------- | ------------------ |
| सरल अंकगणित             | \~100 tokens         | \~300 tokens       |
| कोड जनरेशन              | \~500–1000 tokens    | \~2000 tokens      |
| प्रतियोगिता गणित (AIME) | \~2000–4000 tokens   | \~5000 tokens      |
| बहु-चरणीय शोध विश्लेषण  | \~4000–8000 tokens   | \~10000 tokens     |

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

### मेमोरी से बाहर (OOM)

```bash
# संदर्भ लंबाई घटाएँ
--max-model-len 8192    # 32768 के बजाय

# समवर्ती sequences सीमित करें
--max-num-seqs 8

# quantization का उपयोग करें
--quantization awq      # या gptq
```

### मॉडल कोई `<think>` ब्लॉक

कुछ system prompts सोचने की प्रक्रिया को दबा देते हैं। "be concise" या "don't explain your reasoning." जैसी निर्देशों से बचें। एक न्यूनतम system prompt या बिल्कुल न इस्तेमाल करें:

```python
# अच्छा — तर्क को संरक्षित करता है
messages = [{"role": "user", "content": "..."}]

# खराब — सोचने की प्रक्रिया को दबा सकता है
messages = [
    {"role": "system", "content": "बहुत संक्षिप्त रहें। कोई व्याख्या नहीं।"},
    {"role": "user", "content": "..."}
]
```

### दोहरावदार या लूपिंग `<think>` आउटपुट

तर्क श्रृंखला में यादृच्छिकता कम करने के लिए temperature घटाएँ:

```python
temperature = 0.0   # निर्धारक — गणित/कोड के लिए सर्वोत्तम
temperature = 0.3   # थोड़ी भिन्नता — विश्लेषण के लिए अच्छा
```

### धीमा पहला टोकन (उच्च TTFT)

यह अपेक्षित है — मॉडल `<think>` दृश्यमान उत्तर से पहले tokens उत्पन्न करता है। जहाँ latency-संवेदनशील अनुप्रयोगों में रीजनिंग की आवश्यकता नहीं है, वहाँ [DeepSeek-V3](/guides/guides_v2-hi/language-models/deepseek-v3.md) का उपयोग करें।

### Clore इंस्टेंस पर डाउनलोड अटक जाता है

कुछ providers पर HuggingFace downloads धीमे हो सकते हैं। मॉडल को persistent volume में पहले से cache करें:

```bash
# एक बार volume में डाउनलोड करें
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# vLLM को स्थानीय path पर इंगित करें
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## अधिक पढ़ें

* [DeepSeek-R1 पेपर](https://arxiv.org/abs/2501.12948) — *रीइन्फोर्समेंट लर्निंग के माध्यम से LLMs में तर्क क्षमता को प्रोत्साहित करना*
* [DeepSeek-R1 GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — model cards वाला आधिकारिक repository
* [DeepSeek-V3 गाइड](/guides/guides_v2-hi/language-models/deepseek-v3.md) — उसी प्रयोगशाला का non-reasoning सामान्य-उद्देश्य मॉडल
* [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) — व्यापक production serving सेटअप
* [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) — किसी भी मॉडल के लिए सरल स्थानीय डिप्लॉयमेंट
* [Open WebUI गाइड](/guides/guides_v2-hi/language-models/open-webui.md) — native `<think>` टैग रेंडरिंग वाला चैट UI
* [Qwen 2.5 गाइड](/guides/guides_v2-hi/language-models/qwen25.md) — अधिकांश R1 distills द्वारा उपयोग की जाने वाली बेस आर्किटेक्चर


---

# 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/language-models/deepseek-r1.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.