> 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/mistral-large3.md).

# Mistral Large 3 (675B MoE)

Mistral Large 3 Mistral AI का सबसे शक्तिशाली ओपन-वेट मॉडल है, जिसे दिसंबर 2025 में जारी किया गया था **Apache 2.0 लाइसेंस**। यह एक Mixture-of-Experts (MoE) मॉडल है जिसमें कुल 675B पैरामीटर हैं लेकिन प्रति टोकन केवल 41B सक्रिय होते हैं — जो एक घनी 675B मॉडल की तुलना में कम कंप्यूट पर फ्रंटियर-स्तर का प्रदर्शन देता है। देशी मल्टीमॉडल समर्थन (टेक्स्ट + इमेज), 256K संदर्भ विंडो, और सर्वोत्तम एजेंटिक क्षमताओं के साथ, यह GPT-4o और Claude-श्रेणी के मॉडलों के सीधे प्रतिस्पर्धी है और पूर्ण रूप से स्वयं-होस्ट करने योग्य है।

**HuggingFace:** [mistralai/Mistral-Large-3-675B-Instruct-2512](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) **Ollama:** [mistral-large-3:675b](https://ollama.com/library/mistral-large-3) **लाइसेंस:** Apache 2.0

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

* **कुल 675B / सक्रिय 41B पैरामीटर** — MoE कुशलता का मतलब है कि आपको हर पैरामीटर सक्रिय किए बिना फ्रंटियर प्रदर्शन मिलता है
* **Apache 2.0 लाइसेंस** — वाणिज्यिक और व्यक्तिगत उपयोग के लिए पूरी तरह खुला, कोई प्रतिबंध नहीं
* **मूलतः मल्टीमॉडल** — 2.5B विजन एन्कोडर के माध्यम से टेक्स्ट और इमेज दोनों को समझता है
* **256K संदर्भ विंडो** — विशाल दस्तावेज़ों, कोडबेस और लंबी बातचीतों को संभालता है
* **सर्वोत्तम श्रेणी की एजेंटिक क्षमताएँ** — देशी फंक्शन कॉलिंग, JSON मोड, टूल उपयोग
* **कई परिनियोजन विकल्प** — H200/B200 पर FP8, H100/A100 पर NVFP4, उपभोक्ता GPUs के लिए GGUF क्वांटाइज्ड

## मॉडल आर्किटेक्चर

| घटक             | विवरण                             |
| --------------- | --------------------------------- |
| आर्किटेक्चर     | ग्रेनुलर Mixture-of-Experts (MoE) |
| कुल पैरामीटर    | 675B                              |
| सक्रिय पैरामीटर | 41B (प्रति टोकन)                  |
| विजन एन्कोडर    | 2.5B पैरामीटर                     |
| संदर्भ विंडो    | 256K टोकन                         |
| प्रशिक्षण       | 3,000× H200 GPUs                  |
| रिलीज़          | दिसंबर 2025                       |

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

| कॉन्फ़िगरेशन | बजट (Q4 GGUF) | स्टैंडर्ड (NVFP4) | फुल (FP8)      |
| ------------ | ------------- | ----------------- | -------------- |
| GPU          | 4× RTX 4090   | 8× A100 80GB      | 8× H100/H200   |
| VRAM         | 4×24GB (96GB) | 8×80GB (640GB)    | 8×80GB (640GB) |
| RAM          | 128GB         | 256GB             | 256GB          |
| डिस्क        | 400GB         | 700GB             | 1.4TB          |
| CUDA         | 12.0+         | 12.0+             | 12.0+          |

**अनुशंसित Clore.ai सेटअप:**

* **सर्वोत्तम मूल्य:** 4× RTX 4090 (\~$2–8/दिन) — llama.cpp या Ollama के माध्यम से Q4 GGUF क्वांटाइजेशन चलाएँ
* **प्रोडक्शन गुणवत्ता:** 8× A100 80GB (\~$16–32/दिन) — vLLM के माध्यम से पूर्ण संदर्भ के साथ NVFP4
* **अधिकतम प्रदर्शन:** 8× H100 (\~$24–48/दिन) — FP8, पूर्ण 256K संदर्भ

## Ollama के साथ त्वरित शुरुआत

मल्टी-GPU Clore.ai इंस्टेंस पर Mistral Large 3 चलाने का सबसे तेज़ तरीका:

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

# 675B मॉडल चलाएँ (मल्टी-GPU आवश्यक, Q4 के लिए ~96GB+ VRAM की आवश्यकता)
ollama run mistral-large-3:675b

# छोटे डेंस वेरिएंट्स (सिंगल GPU) के लिए:
ollama run mistral3:14b    # 14B डेंस — RTX 3060+ पर फिट बैठता है
ollama run mistral3:8b     # 8B डेंस — किसी भी GPU पर फिट बैठता है
```

## vLLM के साथ क्विक स्टार्ट (प्रोडक्शन)

OpenAI-संगत API के साथ प्रोडक्शन-ग्रेड सर्विंग के लिए:

```bash
# vLLM इंस्टॉल करें
pip install vllm

# 8× A100/H100 पर NVFP4 क्वांटाइजेशन के साथ सर्व करें
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --host 0.0.0.0 \
    --port 8000

# FP8 के लिए (मूल वज़न, सर्वोच्च गुणवत्ता):
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 131072 \
    --host 0.0.0.0 \
    --port 8000
```

## उपयोग के उदाहरण

### 1. चैट कम्पलीशन (OpenAI-संगत API)

एक बार vLLM चलने के बाद, किसी भी OpenAI-संगत क्लाइंट का उपयोग करें:

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[
        {"role": "system", "content": "आप एक सहायक कोडिंग असिस्टेंट हैं."},
        {"role": "user", "content": "aiohttp और BeautifulSoup का उपयोग करके एक Python async वेब स्क्रैपर लिखें."}
    ],
    temperature=0.1,
    max_tokens=4096
)

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

### 2. फंक्शन कॉलिंग / टूल उपयोग

Mistral Large 3 संरचित टूल कॉलिंग में उत्कृष्ट है:

```python
import json
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "किसी स्थान के लिए वर्तमान मौसम प्राप्त करें",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "शहर का नाम"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Function: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")
```

### 3. विज़न — इमेज विश्लेषण

Mistral Large 3 स्वाभाविक रूप से इमेजेस को समझता है:

```python
import base64
from openai import OpenAI

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

# इमेज एन्कोड करें
with open("diagram.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "इस आर्किटेक्चर डायग्राम का विस्तार से वर्णन करें."},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}}
        ]
    }],
    max_tokens=2048
)

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

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. **A100s पर NVFP4 के साथ शुरू करें** — यह `Mistral-Large-3-675B-Instruct-2512-NVFP4` चेकपॉइंट विशेष रूप से A100/H100 नोड्स के लिए डिज़ाइन किया गया है और FP8 की तुलना में लगभग बिना हानि की गुणवत्ता आधे मेमोरी फुटप्रिंट में प्रदान करता है।
2. **त्वरित प्रयोगों के लिए Ollama का उपयोग करें** — यदि आपके पास 4× RTX 4090 इंस्टेंस है, तो Ollama GGUF क्वांटाइजेशन को स्वचालित रूप से संभालता है। vLLM प्रोडक्शन सेटअप अपनाने से पहले परीक्षण के लिए यह उपयुक्त है।
3. **API को सुरक्षित रूप से एक्सपोज़ करें** — जब Clore.ai इंस्टेंस पर vLLM चला रहे हों, तो SSH टनलिंग (`ssh -L 8000:localhost:8000 root@<ip>`) का उपयोग करें न कि पोर्ट 8000 को सीधे एक्सपोज़ करने के बजाय।
4. **कम करें `max-model-len` VRAM बचाने के लिए** — यदि आपको पूर्ण 256K संदर्भ की आवश्यकता नहीं है, तो सेट करें `--max-model-len 32768` या `65536` ताकि KV-cache मेमोरी उपयोग को काफी कम किया जा सके।
5. **घने विकल्पों पर विचार करें** — सिंगल-GPU सेटअप के लिए, Mistral 3 14B (`mistral3:14b` Ollama में) एकल RTX 4090 पर उत्कृष्ट प्रदर्शन देता है और वही मॉडल परिवार से है।

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

| समस्या                                | समाधान                                                                                                                         |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `CUDA में आउट ऑफ मेमोरी` vLLM पर      | घटाएँ `--max-model-len` (32768 आज़माएँ), बढ़ाएँ `--tensor-parallel-size`, या NVFP4 चेकपॉइंट का उपयोग करें                      |
| धीमी जनरेशन स्पीड                     | सुनिश्चित करें `--tensor-parallel-size` आपकी GPU गिनती से मेल खाता है; Eagle चेकपॉइंट के साथ स्पेक्युलेटिव डिकोडिंग सक्षम करें |
| Ollama 675B लोड करने में विफल होता है | सुनिश्चित करें कि आपके पास GPUs पर 96GB+ VRAM है; बड़े मॉडलों के लिए Ollama को आवश्यकता है `OLLAMA_NUM_PARALLEL=1` के लिए      |
| `tokenizer_mode mistral` त्रुटियाँ    | आपको सभी तीन फ़्लैग पास करने होंगे: `--tokenizer-mode mistral --config-format mistral --load-format mistral`                   |
| विजन काम नहीं कर रहा                  | सुनिश्चित करें कि इमेजेस लगभग 1:1 आस्पेक्ट अनुपात के करीब हों; सर्वोत्तम परिणामों के लिए बहुत चौड़ी/पतली इमेज से बचें          |
| डाउनलोड बहुत धीमा                     | उपयोग करें `huggingface-cli download mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4` के साथ `HF_TOKEN` सेट करें            |

## अधिक पढ़ने के लिए

* [Mistral 3 घोषणा ब्लॉग](https://mistral.ai/news/mistral-3) — बेंचमार्क के साथ आधिकारिक लॉन्च पोस्ट
* [HuggingFace मॉडल कार्ड](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) — परिनियोजन निर्देश और बेंचमार्क परिणाम
* [NVFP4 क्वांटाइज्ड संस्करण](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4) — A100/H100 के लिए अनुकूलित
* [GGUF क्वांटाइज्ड (Unsloth)](https://huggingface.co/unsloth/Mistral-Large-3-675B-Instruct-2512-GGUF) — llama.cpp और Ollama के लिए
* [vLLM दस्तावेज़ीकरण](https://docs.vllm.ai/) — प्रोडक्शन सर्विंग फ्रेमवर्क
* [Red Hat Day-0 गाइड](https://developers.redhat.com/articles/2025/12/02/run-mistral-large-3-ministral-3-vllm-red-hat-ai) — चरण-दर-चरण vLLM परिनियोजन


---

# 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/mistral-large3.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.