> 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-v3.md).

# DeepSeek-V3

CLORE.AI GPUs पर असाधारण तार्किक क्षमता वाले राज्य-ऑफ-द-आर्ट ओपन-सोर्स LLM DeepSeek-V3 चलाएँ।

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

{% hint style="info" %}
**अपडेट: DeepSeek-V3-0324 (मार्च 2024)** — DeepSeek-V3 के नवीनतम संशोधन में कोड जेनरेशन, गणितीय तर्क और सामान्य समस्या-समाधान में महत्वपूर्ण सुधार हैं। देखें [चेंजलॉग](#whats-new-in-deepseek-v3-0324) विवरण के लिए अनुभाग।
{% endhint %}

## क्यों DeepSeek-V3?

* **राज्य-ऑफ-द-आर्ट** - GPT-4o और Claude 3.5 Sonnet के साथ प्रतिस्पर्धा करता है
* **671B MoE** - कुल 671B पैरामीटर्स, प्रति टोकन 37B सक्रिय (एफिशिएंट इन्फरेंस)
* **सुधरा हुआ तर्क** - DeepSeek-V3-0324 गणित और कोड में उल्लेखनीय रूप से बेहतर है
* **कुशल** - MoE आर्किटेक्चर घनी (dense) मॉडलों की तुलना में कम्प्यूटेशनल लागत कम करता है
* **ओपन सोर्स** - MIT लाइसेंस के तहत पूरी तरह से खुला वेट्स
* **लंबा संदर्भ** - 128K टोकन संदर्भ विंडो

## DeepSeek-V3-0324 में क्या नया है

DeepSeek-V3-0324 (मार्च 2024 संशोधन) प्रमुख क्षेत्रों में महत्वपूर्ण सुधार लाता है:

### कोड जेनरेशन

* **+8-12% HumanEval पर** मूल V3 की तुलना में
* मल्टी-फाइल कोडबेस और जटिल रीफ़ैक्टरिंग कार्यों में बेहतर
* आधुनिक फ्रेमवर्क्स की बेहतर समझ (FastAPI, Pydantic v2, LangChain v0.3)
* छूट के बिना पूर्ण, चलने योग्य कोड उत्पन्न करने में अधिक विश्वसनीय

### गणितीय तर्क

* **MATH-500 पर +5%** बेंचमार्क
* स्टेप-बाय-स्टेप प्रमाण निर्माण में बेहतर
* मल्टी-स्टेप समस्याओं के लिए संख्यात्मक सटीकता में सुधार
* मध्य-समाधान में गलतियों की पहचान और सुधार करने की बढ़ी हुई क्षमता

### सामान्य तर्क

* तर्कसंगत निष्कर्ष और कारणात्मक इनफेरेंस में मजबूत
* मल्टी-स्टेप योजना कार्यों में बेहतर
* एज केसेस और अस्पष्ट प्रॉम्प्ट्स पर अधिक सुसंगत प्रदर्शन
* जटिल, बहु-प्रतिबंध अनुरोधों पर निर्देश पालन में सुधार

## CLORE.AI पर त्वरित डिप्लॉय

**Docker इमेज:**

```
vllm/vllm-openai:latest
```

**पोर्ट:**

```
22/tcp
8000/http
```

**कमांड (मल्टी-GPU आवश्यक):**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 8 \
    --trust-remote-code
```

## अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर**:

1. जाएँ **मेरे ऑर्डर** पृष्ठ
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए उदाहरणों में।

### जांचें कि यह काम कर रहा है

```bash
# जाँचें कि सेवा तैयार है या नहीं
curl https://your-http-pub.clorecloud.net/health

# उपलब्ध मॉडल सूचीबद्ध करें
curl https://your-http-pub.clorecloud.net/v1/models

# संस्करण प्राप्त करें
curl https://your-http-pub.clorecloud.net/version
```

{% hint style="warning" %}
**महत्वपूर्ण:** DeepSeek-V3 को आवश्यक है **8x A100 80GB** GPU और पर्याप्त डाउनलोड समय। मॉडल डाउनलोड होने तक HTTP 502 15-30 मिनट तक बना रह सकता है।
{% endhint %}

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

| मॉडल              | पैरामीटर | Active | आवश्यक VRAM | HuggingFace                                                                                             |
| ----------------- | -------- | ------ | ----------- | ------------------------------------------------------------------------------------------------------- |
| DeepSeek-V3-0324  | 671B     | 37B    | 8x80GB      | [deepseek-ai/DeepSeek-V3-0324](https://huggingface.co/deepseek-ai/DeepSeek-V3-0324)                     |
| DeepSeek-V3       | 671B     | 37B    | 8x80GB      | [deepseek-ai/DeepSeek-V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)                               |
| DeepSeek-V3-Base  | 671B     | 37B    | 8x80GB      | [deepseek-ai/DeepSeek-V3-Base](https://huggingface.co/deepseek-ai/DeepSeek-V3-Base)                     |
| DeepSeek-V2.5     | 236B     | 21B    | 4x80GB      | [deepseek-ai/DeepSeek-V2.5](https://huggingface.co/deepseek-ai/DeepSeek-V2.5)                           |
| DeepSeek-V2-Lite  | 16B      | 2.4B   | 16GB        | [deepseek-ai/DeepSeek-V2-Lite](https://huggingface.co/deepseek-ai/DeepSeek-V2-Lite)                     |
| DeepSeek-Coder-V2 | 236B     | 21B    | 4x80GB      | [deepseek-ai/DeepSeek-Coder-V2-Instruct](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Instruct) |

## हार्डवेयर आवश्यकताएँ

### फुल प्रिसिशन

| मॉडल             | न्यूनतम       | अनुशंसित     |
| ---------------- | ------------- | ------------ |
| DeepSeek-V3-0324 | 8x A100 80GB  | 8x H100 80GB |
| DeepSeek-V2.5    | 4x A100 80GB  | 4x H100 80GB |
| DeepSeek-V2-Lite | RTX 4090 24GB | A100 40GB    |

### क्वांटाइज़्ड (AWQ/GPTQ)

| मॉडल             | क्वांटाइज़ेशन | VRAM   |
| ---------------- | ------------- | ------ |
| DeepSeek-V3-0324 | INT4          | 4x80GB |
| DeepSeek-V2.5    | INT4          | 2x80GB |
| DeepSeek-V2-Lite | INT4          | 8GB    |

## इंस्टॉलेशन

### vLLM का उपयोग (अनुशंसित)

```bash
pip install vllm==0.7.3

# DeepSeek-V3-0324 (नवीनतम, 8 GPUs)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# मूल V3 (अभी भी उपलब्ध)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000
```

### Transformers का उपयोग करना

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

model_name = "deepseek-ai/DeepSeek-V3-0324"

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

messages = [{"role": "user", "content": "क्वांटम कंप्यूटिंग को सरल शब्दों में समझाइए."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Ollama का उपयोग करना

```bash
# DeepSeek-V3 खींचें (महत्वपूर्ण संसाधन आवश्यक)
ollama pull deepseek-v3

# या हल्का वेरिएंट
ollama pull deepseek-coder-v2:16b

# चलाएँ
ollama run deepseek-v3
```

## API उपयोग

### OpenAI-अनुकूल API (vLLM)

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "आप एक सहायक AI असिस्टेंट हैं."},
        {"role": "user", "content": "प्राइम नंबर खोजने के लिए एक Python फ़ंक्शन लिखें."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)
```

### स्ट्रीमिंग

```python
stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "मशीन लर्निंग समझाइए"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "फ्रांस की राजधानी क्या है?"}
        ],
        "temperature": 0.7
    }'
```

## DeepSeek-V2-Lite (सिंगल GPU)

सीमित हार्डवेयर वाले उपयोगकर्ताओं के लिए:

```bash
# vLLM का उपयोग
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \
    --host 0.0.0.0

# Ollama का उपयोग
ollama run deepseek-coder-v2:16b
```

```python
# सिंगल GPU पर Transformers का उपयोग
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)
```

## कोड जेनरेशन

DeepSeek-V3-0324 कोड के लिए सर्वश्रेष्ठ-इन-क्लास है:

```python
prompt = """एक बाइनरी सर्च ट्री के लिए Python क्लास लिखें जिसमें:
- insert
- search
- delete
- in-order traversal
Include type hints and docstrings."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # कोड के लिए कम रखें
)

print(response.choices[0].message.content)
```

उन्नत कोड कार्य जिनमें V3-0324 उत्कृष्ट है:

```python
# मल्टी-फाइल रीफ़ैक्टरिंग
prompt = """मेरे पास एक Flask एप्लिकेशन है जिसमें सारा कोड app.py में है (500 लाइन)।
इसे application factory पैटर्न का उपयोग करके ब्लूप्रिंट्स के साथ रीफ़ैक्टर करें:
- auth (लॉगिन, रजिस्टर, लॉगआउट)
- api (REST endpoints)
- admin (डैशबोर्ड)
संपूर्ण फ़ाइल संरचना और सभी फाइलें दिखाएं."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)
```

## गणित एवं तर्क

```python
# जटिल गणित समस्या
prompt = """साबित कीजिए कि किसी भी पूर्णांक n >= 1 के लिए, योग 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6 होता है।
गणितीय इन्डक्शन का उपयोग करें और सभी चरण स्पष्ट रूप से दिखाएँ."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # गणित के लिए बहुत कम
)

print(response.choices[0].message.content)
```

## मल्टी-GPU कॉन्फ़िगरेशन

### 8x GPU (फुल मॉडल — V3-0324)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --trust-remote-code
```

### 4x GPU (V2.5)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2.5 \
    --tensor-parallel-size 4 \
    --max-model-len 16384 \
    --trust-remote-code
```

## प्रदर्शन

### थ्रूपुट (टोकन/सेकंड)

| मॉडल                  | GPUs         | संदर्भ | टोकन/सेकंड |
| --------------------- | ------------ | ------ | ---------- |
| DeepSeek-V3-0324      | 8x H100      | 32K    | \~85       |
| DeepSeek-V3-0324      | 8x A100 80GB | 32K    | \~52       |
| DeepSeek-V3-0324 INT4 | 4x A100 80GB | 16K    | \~38       |
| DeepSeek-V2.5         | 4x A100 80GB | 16K    | \~70       |
| DeepSeek-V2.5         | 2x A100 80GB | 8K     | \~45       |
| DeepSeek-V2-Lite      | RTX 4090     | 8K     | \~40       |
| DeepSeek-V2-Lite      | RTX 3090     | 4K     | \~25       |

### पहले टोकन तक का समय (TTFT)

| मॉडल             | कॉन्फ़िगरेशन | TTFT     |
| ---------------- | ------------ | -------- |
| DeepSeek-V3-0324 | 8x H100      | \~750ms  |
| DeepSeek-V3-0324 | 8x A100      | \~1100ms |
| DeepSeek-V2.5    | 4x A100      | \~500ms  |
| DeepSeek-V2-Lite | RTX 4090     | \~150ms  |

### मेमोरी उपयोग

| मॉडल             | प्रिसिशन | आवश्यक VRAM |
| ---------------- | -------- | ----------- |
| DeepSeek-V3-0324 | FP16     | 8x 80GB     |
| DeepSeek-V3-0324 | INT4     | 4x 80GB     |
| DeepSeek-V2.5    | FP16     | 4x 80GB     |
| DeepSeek-V2.5    | INT4     | 2x 80GB     |
| DeepSeek-V2-Lite | FP16     | 20GB        |
| DeepSeek-V2-Lite | INT4     | 10GB        |

## बेंचमार्क्स

### DeepSeek-V3-0324 बनाम प्रतियोगिता

| बेंचमार्क         | V3-0324 | V3 (मूल) | GPT-4o | Claude 3.5 Sonnet |
| ----------------- | ------- | -------- | ------ | ----------------- |
| MMLU              | 88.5%   | 87.1%    | 88.7%  | 88.3%             |
| HumanEval         | 90.2%   | 82.6%    | 90.2%  | 92.0%             |
| MATH-500          | 67.1%   | 61.6%    | 76.6%  | 71.1%             |
| GSM8K             | 92.1%   | 89.3%    | 95.8%  | 96.4%             |
| LiveCodeBench     | 72.4%   | 65.9%    | 71.3%  | 73.8%             |
| Codeforces रेटिंग | 1850    | 1720     | 1780   | 1790              |

*नोट: MATH-500 में V3 → V3-0324 सुधार +5.5 प्रतिशत अंक है।*

## Docker Compose

```yaml
version: '3.8'

services:
  deepseek:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## GPU आवश्यकताओं का सारांश

| उपयोग का मामला       | अनुशंसित सेटअप     | लागत/घंटा |
| -------------------- | ------------------ | --------- |
| फुल DeepSeek-V3-0324 | 8x A100 80GB       | \~$2.00   |
| DeepSeek-V2.5        | 4x A100 80GB       | \~$1.00   |
| डेवलपमेंट/टेस्टिंग   | RTX 4090 (V2-Lite) | \~$0.10   |
| प्रोडक्शन API        | 8x H100 80GB       | \~$3.00   |

## लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें:

| GPU कॉन्फ़िगरेशन | घंटात्मक दर | दैनिक दर |
| ---------------- | ----------- | -------- |
| RTX 4090 24GB    | \~$0.10     | \~$2.30  |
| A100 40GB        | \~$0.17     | \~$4.00  |
| A100 80GB        | \~$0.25     | \~$6.00  |
| 4x A100 80GB     | \~$1.00     | \~$24.00 |
| 8x A100 80GB     | \~$2.00     | \~$48.00 |

*कीमतें प्रदाता के अनुसार विभिन्न होती हैं। जाँच करें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* उपयोग करें **स्पॉट** डेवलपमेंट के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* स्केल अप करने से पहले परीक्षण के लिए DeepSeek-V2-Lite का उपयोग करें

## समस्याओं का निवारण

### आउट ऑफ़ मेमोरी

```bash
# संदर्भ लंबाई घटाएं
--max-model-len 8192

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

# 12GB GPU पर V2-Lite के लिए
--gpu-memory-utilization 0.85
--max-model-len 4096
```

### मॉडल डाउनलोड धीमा

```bash
# प्री-डाउनलोड
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# या मिरर का उपयोग करें
export HF_ENDPOINT=https://hf-mirror.com
```

### trust\_remote\_code त्रुटि

```bash
# DeepSeek मॉडलों के लिए हमेशा यह फ्लैग शामिल करें
--trust-remote-code
```

### मल्टी-GPU काम नहीं कर रहा

```bash
# NCCL जांचें
nvidia-smi topo -m

# NCCL वेरिएबल सेट करें
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0
```

## DeepSeek बनाम अन्य

| फ़ीचर        | DeepSeek-V3-0324  | Llama 3.1 405B | Mixtral 8x22B     |
| ------------ | ----------------- | -------------- | ----------------- |
| पैरामीटर     | 671B (37B सक्रिय) | 405B           | 176B (44B सक्रिय) |
| संदर्भ       | 128K              | 128K           | 64K               |
| कोड          | **उत्कृष्ट**      | बहुत अच्छा     | अच्छा             |
| गणित         | **उत्कृष्ट**      | अच्छा          | अच्छा             |
| न्यूनतम VRAM | 8x80GB            | 8x80GB         | 2x80GB            |
| लाइसेंस      | MIT               | Llama 3.1      | Apache 2.0        |

**DeepSeek-V3 का उपयोग करें जब:**

* सबसे अच्छा तर्क प्रदर्शन आवश्यक हो
* कोड जेनरेशन प्राथमिक उपयोग हो
* गणित/तर्क कार्य महत्वपूर्ण हों
* मल्टी-GPU सेटअप उपलब्ध हो
* पूरी तरह से ओपन-सोर्स वेट्स (MIT लाइसेंस) चाहिए

## अगले कदम

* [vLLM](/guides/guides_v2-hi/language-models/vllm.md) - परिनियोजन सर्वर
* [DeepSeek-R1](/guides/guides_v2-hi/language-models/deepseek-r1.md) - तर्क-विशेषीकृत वेरिएंट
* [DeepSeek Coder](/guides/guides_v2-hi/language-models/deepseek-coder.md) - कोड-विशेष वेरिएंट
* [Ollama](/guides/guides_v2-hi/language-models/ollama.md) - सरल परिनियोजन
* [LLM को फाइन-ट्यून करें](/guides/guides_v2-hi/training/finetune-llm.md) - कस्टम प्रशिक्षण


---

# 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-v3.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.