Mistral Medium 3.5 (128B Dense, 256K)

Clore.ai पर Mistral Medium 3.5 डिप्लॉय करें — 128B डेंस, 256K संदर्भ, दोहरे-मोड रीजनिंग के साथ अप्रैल 2026 में जारी। 4× H100 या 2× H200 पर प्रोडक्शन vLLM/SGLang सेटअप।

स्थिति (अप्रैल 2026): Mistral Medium 3.5 को जारी किया गया था 29 अप्रैल, 2026 Mistral AI द्वारा Mistral Medium 3 के उत्तराधिकारी के रूप में। वेट्स यहाँ उपलब्ध हैं huggingface.co/mistralai/Mistral-Medium-3.5 के अंतर्गत Mistral Research License (MRL) अनुसंधान के लिए; यह Mistral Commercial License मूल्यांकन से आगे उत्पादन उपयोग के लिए आवश्यक है। vLLM (≥ 0.8.x) और SGLang पहले दिन से समर्थन के साथ आते हैं।

Mistral Medium 3.5 एक 128B घना ट्रांसफॉर्मर के साथ एक 256K-टोकन कॉन्टेक्स्ट विंडो और एक मूल रीजनिंग टॉगल जो तेज़ "instant" उत्तरों और लंबे chain-of-thought "deep" ट्रेस के बीच उसी चेकपॉइंट में स्विच करता है। यह रिलीज़ पहले अलग-अलग Mistral लाइनों — Medium 3 (सामान्य निर्देश), Codestral (कोड), और Mistral के रीजनिंग प्रीव्यू — को एक ही टॉगल-योग्य मॉडल में समेटती है, जो उन इंजीनियरिंग टीमों के लिए मुख्य बदलाव है जो कई वेट्स संभाल रही थीं।

Clore.ai उपयोगकर्ताओं के लिए, व्यावहारिक निहितार्थ आकार निर्धारण है। FP8 में 128B घना मॉडल लगभग 128 GB KV कैश से पहले, इसलिए यह नहीं पूर्ण प्रिसिजन पर एकल 80 GB GPU में फिट नहीं होता — आपको चाहिए 4× H100 80 GB (FP8) या 2× H200 141 GB इसे vLLM के माध्यम से साफ़-सुथरे ढंग से सर्व करने के लिए। मार्केटप्लेस पर यह लगभग आता है bare metal 4× H100 सेटअप के लिए या ~$4.16/घंटा 2× H200 के लिए, जो अधिकांश टीमों के लिए सबसे उपयुक्त बिंदु है। एकल-H100 डिप्लॉयमेंट केवल आक्रामक Q4 GGUF क्वांटाइज़ेशन (~70 tok/s via llama.cpp) के साथ ही काम करते हैं, और संपीड़ित करने पर 256 K कॉन्टेक्स्ट सबसे पहले गायब होता है।

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

• 128B घने पैरामीटर — कोई MoE रूटिंग ट्रिक नहीं, अनुमानित VRAM और लेटेंसी प्रोफ़ाइल, sparse मॉडलों की तुलना में fine-tune करना आसान

• 256K कॉन्टेक्स्ट विंडो — पूरे कोडबेस का विश्लेषण, लंबे दस्तावेज़ों पर RAG, बिना truncation के बहु-टर्न एजेंट लूप

• दो-मोड रीजनिंग — टॉगल reasoning_mode=instant ~चैट लेटेंसी के लिए या reasoning_mode=deep एक <think> उत्तर से पहले ट्रेस

• एकीकृत निर्देश + कोड + रीजनिंग — वेट्स का एक ही सेट Medium 3 + Codestral + रीजनिंग प्रीव्यू की जगह लेता है

• फ़ंक्शन कॉलिंग और संरचित आउटपुट — मूल JSON schema enforcement, OpenAI-संगत tool-call फ़ॉर्मेट

• ओपन वेट्स — शोध के लिए MRL, वाणिज्यिक लाइसेंस उपलब्ध; वेट्स आपके बॉक्स पर ही रहते हैं और कभी भी vendor API तक round-trip नहीं होते

• पहले दिन से vLLM और SGLang समर्थन — production-ready FP8 पाथ, टेन्सर पैरालेलिज़्म, chunked prefill, continuous batching

रीजनिंग मोड

Medium 3.5 पहला Mistral मॉडल है जो एक ही चेकपॉइंट में "fast" और "thinking" दोनों उत्तर देता है। टॉगल लोड समय पर नहीं, बल्कि अनुरोध समय पर नियंत्रित होता है, इसलिए एक vLLM प्रक्रिया उसी कॉलर के लिए दोनों मोड संभालती है।

मोड	कब उपयोग करें	सामान्य TTFT	आउटपुट का स्वरूप
इंस्टेंट (डिफ़ॉल्ट)	चैट, ऑटोकम्प्लीट, वर्गीकरण, और फ़ंक्शन कॉल जहाँ लेटेंसी मायने रखती है	50–250 ms	केवल उत्तर
डीप	कोड समीक्षा, बहु-चरणीय योजना, गणित, कठिन डिबगिंग, एजेंट योजना चरण	पहले उत्तर टोकन से पहले 1–6 सेकंड	<think>...</think> ट्रेस, फिर अंतिम उत्तर

में डीप मोड में मॉडल एक छिपा हुआ reasoning span उत्पन्न करता है (जिसे <think>...</think> चैट टेम्पलेट द्वारा) दिखाई देने वाले उत्तर से पहले लपेटा जाता है। इसमें प्रति टर्न कुछ सौ से कुछ हजार अतिरिक्त टोकन लगते हैं, इसलिए इसे हर अनुरोध के लिए सक्षम न करें — इसे उन कार्यों के लिए रखें जहाँ अन्यथा आप एक छोटे मॉडल को "think step by step." कहकर प्रॉम्प्ट करते। एक उचित पैटर्न है इंस्टेंट को डिफ़ॉल्ट के रूप में रखना और केवल इसे बढ़ाकर डीप tool-call योजना चरणों या अंतिम-उत्तर संश्लेषण के लिए उपयोग करना।

वेंडर द्वारा सुझाया गया सैंपलिंग। Mistral अनुशंसा करता है temperature=0.15 के लिए इंस्टेंट और temperature=0.7 के साथ top_p=0.95 के लिए डीप मोड। शून्य-तापमान सैंपलिंग अक्सर रीजनिंग ट्रेस को जल्दी काट देती है।

अपना डिप्लॉयमेंट चुनें

Clore.ai मार्केटप्लेस पर तीन यथार्थवादी कॉन्फ़िगरेशन। पहले VRAM बजट के आधार पर, फिर थ्रूपुट के आधार पर चुनें।

सेटअप	सटीकता	कुल VRAM	कॉन्टेक्स्ट (व्यावहारिक)	थ्रूपुट	अनुशंसित Clore टियर	नोट्स
1× H100 80 GB	Q4 GGUF (llama.cpp)	80 GB	32K–64K	~50–70 tok/s	सिंगल-GPU, मूल्यांकन/डेव	आक्रामक क्वांटाइज़ेशन; लंबे कोड पर कुछ गुणवत्ता खो दें
4× H100 80 GB	FP8 (vLLM)	320 GB	पूरा 256K	~80–140 tok/s	प्रोडक्शन के लिए सबसे उपयुक्त	TP=4, निरंतर ट्रैफ़िक के लिए tok/$ का सबसे अच्छा अनुपात
2× H200 141 GB	FP8 या BF16	282 GB	पूरा 256K	~90–130 tok/s	उच्च-कॉन्टेक्स्ट, प्रबंधित करने के लिए कम GPU	सरल टोपोलॉजी, 256K पर KV कैश के लिए अतिरिक्त जगह

डिफ़ॉल्ट चयन: 4× H100 80 GB FP8 vLLM के माध्यम से। आपको पूरा 256K कॉन्टेक्स्ट, ~100 tok/s निरंतर, OpenAI-संगत API, और साफ़ टेन्सर-पैरालेल स्केलिंग मिलती है — लगभग एक Claude Opus heavy-use seat की दैनिक लागत में।

सर्वर आवश्यकताएँ

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 के रूप में अनुरोध पर बेची जाती है। देखें GPU मूल्य और उपलब्धता किसी deployment का आकार तय करने से पहले।

घटक	न्यूनतम (Q4 सिंगल-GPU)	अनुशंसित (FP8, 4× H100)	उच्च-कॉन्टेक्स्ट (2× H200)
GPU VRAM	80 GB (1× H100)	4× 80 GB = 320 GB	2× 141 GB = 282 GB
System RAM	128 GB	256 GB	256 GB
डिस्क (NVMe)	200 GB	400 GB	400 GB
नेटवर्क	HF डाउनलोड के लिए 1 Gbps+	1 Gbps+	1 Gbps+
CUDA	12.8+	12.8+	12.8+
ड्राइवर	≥ 555	≥ 555	≥ 555
स्टार्टअप समय	3–6 मिनट (cold pull)	6–12 मिनट (cold pull, 4 shards)	5–10 मिनट

पहला cold start मुख्य रूप से HuggingFace डाउनलोड द्वारा निर्धारित होता है — FP8 वेट्स लगभग 128 GB, BF16 लगभग 256 GB. पर एक persistent volume माउंट करें /root/.cache/huggingface ताकि आपको यह bandwidth लागत प्रति सर्वर केवल एक बार चुकानी पड़े।

CLORE.AI पर त्वरित परिनियोजन

सबसे तेज़ रास्ता आधिकारिक vllm/vllm-openai इमेज है, जिसमें टेन्सर पैरालेलिज़्म आपके GPU की संख्या पर सेट है। नीचे का उदाहरण 4× H100 instance मानता है।

Docker image:

vllm/vllm-openai:latest

पोर्ट:

22/tcp
8000/http

स्टार्टअप कमांड (4× H100, FP8):

vllm serve mistralai/Mistral-Medium-3.5-FP8 \
    --tensor-parallel-size 4 \
    --max-model-len 65536 \\
    --gpu-memory-utilization 0.90 \
    --enable-chunked-prefill \
    --enable-auto-tool-choice \\
    --tool-call-parser mistral \\
    --reasoning-parser mistral \
    --tokenizer-mode mistral \\
    --config-format mistral \\
    --load-format mistral \\
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \\
    --port 8000

विकल्प — 2× H200 BF16:

vllm serve mistralai/Mistral-Medium-3.5 \
    --tensor-parallel-size 2 \\
    --max-model-len 131072 \
    --gpu-memory-utilization 0.92 \
    --enable-chunked-prefill \
    --enable-auto-tool-choice \\
    --tool-call-parser mistral \\
    --reasoning-parser mistral \
    --tokenizer-mode mistral \\
    --config-format mistral \\
    --load-format mistral \\
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \\
    --port 8000

से शुरू करें --max-model-len 65536 भले ही हार्डवेयर में इससे अधिक फिट हो सके। KV कैश मेमोरी कॉन्टेक्स्ट के साथ रेखीय रूप से बढ़ती है, और अधिकांश वर्कलोड कभी 256K तक नहीं पहुँचते। जब आप अनुरोध मिश्रण की पुष्टि कर लें, तब इसे बढ़ाएँ।

SGLang विकल्प (लंबे prefill के लिए Hopper पर अक्सर तेज़):

python3 -m sglang.launch_server \\
    --model-path mistralai/Mistral-Medium-3.5-FP8 \
    --tp-size 4 \
    --tool-call-parser mistral \\
    --reasoning-parser mistral \
    --mem-fraction-static 0.88 \
    --context-length 65536 \
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \\
    --port 8000

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

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर Clore.ai पर (उदा. abc123.clorecloud.net). बदलें localhost:8000 के साथ https://YOUR_HTTP_PUB_URL नीचे के उदाहरणों में, जब सर्वर के बाहर से कॉल करें।

1. चैट — इंस्टेंट मोड (डिफ़ॉल्ट)

कम लेटेंसी वाला उत्तर, कोई दिखाई देने वाला reasoning trace नहीं। चैट UI, ऑटोकम्प्लीट, वर्गीकरण के लिए अच्छा।

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "system", "content": "आप एक वरिष्ठ बैकएंड इंजीनियर हैं।"},
      {"role": "user", "content": "प्रति API key token bucket के साथ rate-limit करने वाला एक Go HTTP middleware लिखें."}
    ],
    "temperature": 0.15,
    "max_tokens": 1024,
    "extra_body": {"reasoning_mode": "instant"}
  }'

2. चैट — डीप मोड (रीजनिंग टॉगल)

सक्षम करता है <think> अंतिम उत्तर से पहले ट्रेस। कठिन डिबगिंग, योजना, गणित के लिए उपयोग करें।

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "user", "content": "एक उपयोगकर्ता रिपोर्ट करता है कि हमारा payment webhook 1% ऑर्डरों के लिए दो बार fire होता है। संभावना के क्रम में सबसे संभावित मूल कारणों पर जाएँ और एक diagnostic plan प्रस्तावित करें."}
    ],
    "temperature": 0.7,
    "top_p": 0.95,
    "max_tokens": 4096,
    "extra_body": {"reasoning_mode": "deep"}
  }'

प्रतिक्रिया में एक reasoning_content फ़ील्ड होगा (vLLM <think>...</think> span को दृश्यमान संदेश से पार्स करता है) साथ ही content। अपने उत्पाद के अनुसार ट्रेस को हटाएँ या दिखाएँ।

3. Python — OpenAI-संगत क्लाइंट

from openai import OpenAI

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

# इंस्टेंट मोड — चैट
response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "आप एक मददगार कोडिंग सहायक हैं।"},
        {"role": "user", "content": "पढ़ने में आसानी के लिए इस Python फ़ंक्शन को refactor करें."}
    ],
    temperature=0.15,
    max_tokens=1024,
    extra_body={"reasoning_mode": "instant"}
)
print(response.choices[0].message.content)

# डीप मोड — योजना चरण
plan = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "user", "content": "2TB orders table के लिए zero downtime के साथ MongoDB से PostgreSQL में migration की योजना बनाएं."}
    ],
    temperature=0.7,
    max_tokens=4096,
    extra_body={"reasoning_mode": "deep"}
)

msg = plan.choices[0].message
print("सोच:\n", getattr(msg, "reasoning_content", ""))
print("\nउत्तर:\n", msg.content)

4. संरचित आउटपुट — JSON Schema

Medium 3.5 vLLM के response_formatके माध्यम से JSON-schema-निर्देशित decoding का समर्थन करता है। तब उपयोगी जब downstream consumer एक parser हो, मानव नहीं।

from openai import OpenAI

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

schema = {
    "type": "object",
    "properties": {
        "severity": {"type": "string", "enum": ["low", "medium", "high", "critical"]},
        "categories": {
            "type": "array",
            "items": {"type": "string", "enum": ["auth", "payments", "db", "ui", "infra"]}
        },
        "summary": {"type": "string", "maxLength": 240},
        "next_action": {"type": "string"}
    },
    "required": ["severity", "categories", "summary", "next_action"],
    "additionalProperties": False
}

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "आने वाली bug report को वर्गीकृत करें। सख्त JSON लौटाएँ."},
        {"role": "user", "content": "ईमेल में apostrophes वाले उपयोगकर्ताओं के लिए login विफल हो जाता है, और /webapi/login से 500 लौटाता है."}
    ],
    temperature=0.0,
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "triage", "schema": schema, "strict": True}
    },
    extra_body={"reasoning_mode": "instant"}
)

import json
print(json.loads(response.choices[0].message.content))

5. फ़ंक्शन कॉलिंग

from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "search_orders",
        "description": "user ID और वैकल्पिक date range के आधार पर orders database खोजें",
        "parameters": {
            "type": "object",
            "properties": {
                "user_id": {"type": "string"},
                "start_date": {"type": "string", "format": "date"},
                "end_date": {"type": "string", "format": "date"}
            },
            "required": ["user_id"]
        }
    }
}]

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[{"role": "user", "content": "अप्रैल 2026 में उपयोगकर्ता u_4821 के सभी ऑर्डर ढूँढें."}],
    tools=tools,
    tool_choice="auto",
    temperature=0.1
)

for call in response.choices[0].message.tool_calls or []:
    print(call.function.name, call.function.arguments)

प्रदर्शन सुझाव

1. Hopper पर FP8 चेकपॉइंट को प्राथमिकता दें। Mistral-Medium-3.5-FP8 वेंडर द्वारा दिया गया FP8 बिल्ड है और Hopper-class हार्डवेयर पर नगण्य गुणवत्ता हानि के साथ BF16 से लगभग 2× हल्का है। यह 4× H100 और 2× H200 दोनों के लिए सही डिफ़ॉल्ट है।

2. टेन्सर पैरालेलिज़्म = GPU count। 4× H100 के लिए उपयोग करें --tensor-parallel-size 4; 2× H200 के लिए उपयोग करें --tensor-parallel-size 2। एकल नोड पर pipeline parallelism आमतौर पर 128B घने मॉडल के लिए throughput घटाता है।

3. सीमित करें max-model-len को उतना ही जितना आप वास्तव में उपयोग करते हैं। 256K पर KV cache बहुत बड़ा है — पूर्ण कॉन्टेक्स्ट पर एकल sequence 30–50 GB खा सकता है। सेट करें --max-model-len 65536 (या 32768) जब तक अधिक की सत्यापित आवश्यकता न हो, और केवल profiling के बाद बढ़ाएँ।

4. chunked prefill सक्षम करें। --enable-chunked-prefill जब बड़े prompts अभी भी process हो रहे हों, तब decode tokens को बहने देता रहता है। 100K+ prompts के लिए यह "responsive" और "timed out." के बीच का अंतर है।

5. वेट्स को cache करें। पर एक Docker volume माउंट करें /root/.cache/huggingface और उसे restarts में reuse करें। हर cold boot पर 128 GB फिर से डाउनलोड करना "vLLM seems slow to start." का सबसे आम कारण है।

6. मामूली अतिरिक्त headroom के लिए KV-cache quantization। 4× H100 पर आप --kv-cache-dtype fp8के साथ अधिक concurrent sessions निचोड़ सकते हैं। वेंडर near-lossless quality रिपोर्ट करता है; production में बदलने से पहले अपने eval set पर सत्यापित करें।

7. इस्तेमाल न करें डीप मोड को हर अनुरोध के लिए। रीजनिंग ट्रेस के वास्तविक टोकन और वास्तविक लेटेंसी लगती है। कार्य प्रकार के आधार पर रूट करें: वर्गीकरण, ऑटोकम्प्लीट, और tool-arg generation बने रहें इंस्टेंट; योजना और सत्यापन चरण बढ़कर डीप.

8. स्पेक्युलेटिव डिकोडिंग मदद करती है। vLLM और SGLang दोनों draft-model speculative decoding का समर्थन करते हैं (उदा. Ministral 3B draft के साथ)। लंबे कोड completions पर यह आम तौर पर बिना गुणवत्ता लागत के 1.3–1.7× throughput देता है।

बेंचमार्क

वेंडर द्वारा प्रकाशित संख्याएँ — स्वतंत्र रूप से सत्यापित करें। नीचे दी गई तालिका Mistral AI की 29 अप्रैल, 2026 की घोषणा से ली गई है। स्वतंत्र तृतीय-पक्ष पुनरुत्पादन (LMSys, EQ-Bench, SWE-Bench leaderboard) अभी भी आ रहे हैं। इसे दिशा-सूचक मानें, आधिकारिक नहीं।

Benchmark	Mistral Medium 3.5 (वेंडर)	संदर्भ बिंदु (वेंडर द्वारा उद्धृत)
MMLU-Pro	~78%	Llama 4 Maverick ~76%, GPT-5.4 ~81%
HumanEval	~92%	Codestral 25.01 ~88%, GLM-5.1 ~94%
LiveCodeBench (अप्रैल 2026)	~68%	GLM-5.1 ~72%, Llama 4 Maverick ~64%
AIME 2025 (डीप मोड)	~62%	GPT-5.4 ~73%, GLM-5.1 ~58%
GPQA Diamond (डीप मोड)	~59%	Claude Opus 4.6 ~63%, GLM-5.1 ~57%
लंबा-कॉन्टेक्स्ट रिकॉल (128K)	~95%	Llama 4 Maverick ~93%

Mistral जिस स्थिति को लक्षित कर रहा है: सामान्य कार्यों पर लगभग Llama 4 Maverick / GLM-5.1 स्तर, कोडिंग में कम अंतर, अलग रीजनिंग टॉगल. इसे GPT-5.4 / Claude Opus 4.6 के प्रतिद्वंद्वी के रूप में पेश नहीं किया गया है।

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

समस्या	समाधान
CUDA out of memory लोड पर (4× H100)	शायद आप गलती से BF16 लोड कर रहे हैं। FP8 चेकपॉइंट (Mistral-Medium-3.5-FP8) का उपयोग करें या घटाएँ --max-model-len 32768.
CUDA out of memory 256K कॉन्टेक्स्ट के साथ अनुरोध के बीच में	KV कैश फट गया। कम करें --max-model-len, सक्षम करें --kv-cache-dtype fp8, या सीमित करें --max-num-seqs (8 आज़माएँ)।
डीप मोड खाली reasoning_content	पुष्टि करें --reasoning-parser mistral vLLM में सेट है और कि temperature ≥ 0.5। शून्य-तापमान सैंपलिंग ट्रेस को काट देती है।
डीप मोड में पहली टोकन तक धीमा समय	अपेक्षित — डीप मोड एक <think> span उत्पन्न करता है किसी भी दृश्य आउटपुट से पहले। क्लाइंट को stream=true के साथ स्ट्रीम करें और एक "सोच रहा है…" UI स्थिति दिखाएँ।
403 Forbidden HuggingFace डाउनलोड से	Mistral Medium 3.5 है गेटेड। मॉडल कार्ड पर MRL स्वीकार करें और HF_TOKEN को कंटेनर env में सेट करें।
tokenizer_mode mistral त्रुटियाँ	सभी तीन फ़्लैग एक साथ आवश्यक हैं: --tokenizer-mode mistral --config-format mistral --load-format mistral.
टूल कॉल्स चुपचाप छोड़ दिए जाते हैं	दोनों सेट करें --enable-auto-tool-choice और --tool-call-parser mistral। parser के बिना, vLLM tool args को साधारण टेक्स्ट के रूप में लौटाता है।
~32 समवर्ती सत्रों के बाद थ्रूपुट गिर जाता है	आप KV-cache eviction पर पहुँच गए हैं। कम करें --max-model-len, बढ़ाएँ --gpu-memory-utilization को 0.92 तक, या दूसरी replica पर scale out करें।
वाणिज्यिक उपयोग को रोकने वाली लाइसेंस त्रुटि	MRL केवल शोध के लिए है। भुगतान करने वाले उपयोगकर्ताओं को सर्व करने से पहले वाणिज्यिक लाइसेंस के लिए Mistral sales से संपर्क करें।

FAQ

Q: Mistral Medium 3.5 बनाम Llama 4 Maverick — मुझे किसे चुनना चाहिए?

दोनों समान वेट वर्ग में हैं (Maverick 400B कुल में 17B-active MoE है; Medium 3.5 128B dense है)। चुनें Medium 3.5 यदि आप अनुमानित VRAM/लेटेंसी, एक चेकपॉइंट में dual-mode reasoning toggle, और बेहतर कोड प्रदर्शन चाहते हैं। चुनें Llama 4 Maverick यदि आपको बिना शर्त वाणिज्यिक उपयोग के लिए permissive licensing चाहिए (Llama 4 community-licensed है, Medium 3.5 को production के लिए Mistral commercial license चाहिए) या यदि आप प्रति-अनुरोध MoE द्वारा दी गई सस्ती inference cost per token चाहते हैं।

Q: मैं रीजनिंग मोड कैसे सक्षम करूँ?

पास करें extra_body={"reasoning_mode": "deep"} OpenAI Python client में, या शामिल करें "reasoning_mode": "deep" आपके HTTP JSON बॉडी के शीर्ष स्तर पर। डिफ़ॉल्ट है "तत्काल"। सर्वर पक्ष पर, सुनिश्चित करें कि vLLM को के साथ लॉन्च किया गया था --reasoning-parser mistral ताकि <think> span का पार्स होकर reasoning_content फ़ील्ड में चला जाए, बजाय इसके कि वह content.

प्रश्न: 2× H100 की बजाय 4× H100 क्यों?

KV कैश से पहले FP8 वज़न ~128 GB होते हैं। 2× H100 80 GB आपको कुल 160 GB देता है — वज़न लोड करने के लिए पर्याप्त, लेकिन KV कैश, activations, या यहाँ तक कि मध्यम context window के लिए लगभग कोई जगह नहीं। व्यवहार में 2× H100 8K context के बाद तुरंत OOM हो जाते हैं। एक उपयोगी 256K-सक्षम परिनियोजन के लिए 4× H100 न्यूनतम है; 2× H200 (282 GB) विकल्प है यदि आप प्रति-GPU थोड़ी अधिक लागत पर कम GPUs प्रबंधित करना चाहें।

प्रश्न: क्या मैं Mistral Medium 3.5 का व्यावसायिक रूप से उपयोग कर सकता हूँ?

डिफ़ॉल्ट Mistral Research License (MRL) अनुसंधान और आंतरिक मूल्यांकन की अनुमति देती है, लेकिन नहीं व्यावसायिक उत्पादन। भुगतान करने वाले ग्राहकों के लिए दिखाई देने वाले परिनियोजनों के लिए आपको Mistral Commercial License — Mistral बिक्री टीम से संपर्क करें। यही वही प्रतिबंध है जो पहले Medium 3 और Codestral पर लागू था। यदि व्यावसायिक-अनुकूल लाइसेंसिंग अनिवार्य आवश्यकता है, तो देखें Mistral Small 3.1 (Apache 2.0) या Llama 4 (Llama समुदाय लाइसेंस)।

प्रश्न: क्या Medium 3.5 विज़न या ऑडियो का समर्थन करता है?

नहीं। Medium 3.5 केवल-पाठ है। बहु-मोडल Mistral के लिए, उपयोग करें Mistral Large 3, जो 2.5B विज़न एन्कोडर के साथ आता है। Clore.ai पर अन्य बहु-मोडल विकल्पों के लिए, Qwen3.5-Omni या Gemma 3 देखें।

संबंधित गाइड

• Mistral Large 3 — 675B MoE बहु-मोडल फ्रंटियर मॉडल, Apache 2.0, जब आपको विज़न और सर्वोच्च गुणवत्ता चाहिए

• Mistral & Mixtral — एकल-GPU परिनियोजनों के लिए पुराने Mistral 7B और Mixtral 8x7B/8x22B

• vLLM — उत्पादन सर्विंग फ्रेमवर्क, Medium 3.5 के लिए अनुशंसित बैकएंड

• Llama 4 — इस पैमाने पर सबसे निकट खुली-वेट समकक्ष, उदार लाइसेंस वाली वैकल्पिक

बाहरी लिंक

• HuggingFace पर Mistral Medium 3.5

• Mistral Medium 3.5 FP8 चेकपॉइंट

• Mistral AI घोषणा (29 अप्रैल, 2026)

• Mistral अनुसंधान लाइसेंस

• vLLM दस्तावेज़ीकरण

• SGLang repo

• Clore.ai मार्केटप्लेस — H100 / H200 किराए पर लें bare metal