# DeepSeek-R1 Reasoning Model

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

## अवलोकन

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

पूरा मॉडल उपयोग करता है **मिश्रण-विशेषज्ञ (MoE)** प्रति टोकन 37B सक्रिय पैरामीटर के साथ, जिससे सुर्खियों वाले पैरामीटर काउंट के बावजूद इन्फरेंस संभव हो जाता है। अधिकांश उपयोगकर्ताओं के लिए, **डिस्टिल्ड वेरिएंट्स** (1.5B → 70B) अधिक व्यावहारिक हैं: वे ज्ञान-आसवन के माध्यम से R1 के रीजनिंग पैटर्न Qwen-2.5 और Llama-3 बेस आर्किटेक्चर में विरासत में लेते हैं और सामान्य 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 डिस्क |
| ----------------------- | ----------------- | ------------ | --------- | -------- | -------- |
| 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 GB     | 1.2 GB   |

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

| उपयोग का मामला                                 | अनुशंसित वेरिएंट       | Clore पर GPU                                                                                                                |
| ---------------------------------------------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| त्वरित प्रयोग, एज टेस्टिंग                     | R1-Distill-Qwen-1.5B   | कोई भी GPU                                                                                                                  |
| बजट डिप्लॉयमेंट, तेज इन्फरेंस                  | R1-Distill-Qwen-7B     | RTX 3090 (\~$0.30–1/दिन)                                                                                                    |
| सिंगल-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.50–2/दिन)     |
| पैसे के मुकाबले सबसे अच्छी गुणवत्ता (अनुशंसित) | 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 डिस्टिल | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B डिस्टिल  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B डिस्टिल  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B डिस्टिल  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B डिस्टिल   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1.5B डिस्टिल | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

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

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

## Ollama त्वरित शुरुआत

Ollama क्वांटाइजेशन, डाउनलोडिंग और सर्विंग को स्वतः संभालता है — चल रहे 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": "सबसे लंबा पलिंड्रोमिक सबस्ट्रिंग खोजने के लिए एक Python फ़ंक्शन लिखें."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## vLLM प्रोडक्शन सेटअप

vLLM सतत बैचिंग, PagedAttention, और प्रीफ़िक्स कैशिंग के साथ बहु-उपयोगकर्ता सर्विंग के लिए सबसे अधिक थ्रूपुट देता है।

### सिंगल 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 एंडपॉइंट क्वेरी करें

```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 उत्तर को सोचने और उत्तर वाले भागों में विभाजित करें।"""
    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>` स्ट्रीमिंग

```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 इमेज:** `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 इमेज:** `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 इमेज को सेट करें `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+
* **प्रीफ़िक्स कैशिंग सक्षम करें** (`--enable-prefix-caching` (vLLM में) जब साझा system prompt का उपयोग कर रहे हों
* **कनकरेंसी सीमित करें** (`--max-num-seqs 16`रीजनिंग वर्कलोड के लिए — हर अनुरोध मानक चैट की तुलना में अधिक compute उपयोग करता है
* **Q4 quantization का उपयोग करें** ताकि न्यूनतम गुणवत्ता हानि के साथ 32B को एक सिंगल 24 GB GPU पर फिट किया जा सके (distill पहले से ही R1 के ज्ञान को संपीड़ित करता है)

### कॉन्टेक्स्ट लंबाई से जुड़े विचार

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

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

## Troubleshooting

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

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

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

# क्वांटाइजेशन का उपयोग करें
--quantization awq      # या gptq
```

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

कुछ system prompts सोचने की प्रक्रिया दबा देते हैं। "संक्षिप्त रहें" या "अपना तर्क समझाएँ नहीं" जैसी हिदायतों से बचें। एक न्यूनतम 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>` दृश्य उत्तर से पहले टोकन उत्पन्न करता है। जहां विलंब-संवेदनशील अनुप्रयोगों में रीजनिंग की आवश्यकता नहीं है, वहाँ [DeepSeek-V3](/guides/guides_v2-hi/language-models/deepseek-v3.md) का उपयोग करें।

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

कुछ प्रदाताओं पर HuggingFace डाउनलोड धीमे हो सकते हैं। मॉडल को एक persistent volume में पहले से कैश करें:

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

# vLLM को स्थानीय पथ की ओर इंगित करें
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) — मॉडल कार्ड्स के साथ आधिकारिक रिपॉजिटरी
* [DeepSeek-V3 गाइड](/guides/guides_v2-hi/language-models/deepseek-v3.md) — उसी लैब का गैर-रीजनिंग सामान्य-उद्देश्य मॉडल
* [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) — प्रोडक्शन सर्विंग सेटअप की विस्तृत जानकारी
* [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) — किसी भी मॉडल के लिए सरल लोकल डिप्लॉयमेंट
* [Open WebUI गाइड](/guides/guides_v2-hi/language-models/open-webui.md) — मूल `<think>` टैग रेंडरिंग के साथ चैट UI
* [Qwen 2.5 गाइड](/guides/guides_v2-hi/language-models/qwen25.md) — अधिकांश R1 डिस्टिल्स द्वारा उपयोग किया जाने वाला बेस आर्किटेक्चर


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/deepseek-r1.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.