Mistral Small 3.1

Clore.ai पर Mistral Small 3.1 (24B) डिप्लॉय करें — आदर्श सिंगल-GPU प्रोडक्शन मॉडल

Mistral Small 3.1, जिसे Mistral AI ने मार्च 2025 में जारी किया, एक है 24 अरब पैरामीटर वाला डेंस मॉडल जो अपनी क्षमता से कहीं ऊपर प्रदर्शन करता है। 128K कॉन्टेक्स्ट विंडो, मूल विज़न क्षमताओं, सर्वोत्तम-श्रेणी की फ़ंक्शन कॉलिंग, और एक Apache 2.0 लाइसेंस, शायद यह एकल RTX 4090 पर चलाने योग्य सबसे अच्छा मॉडल है। क्वांटाइज़ किए जाने पर यह अधिकांश बेंचमार्क पर GPT-4o Mini और Claude 3.5 Haiku से बेहतर प्रदर्शन करता है, और उपभोक्ता हार्डवेयर पर आराम से फिट हो जाता है।

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

• 24B डेंस पैरामीटर — MoE की कोई जटिलता नहीं, तैनाती सीधी-सादी

• 128K संदर्भ विंडो — RULER 128K स्कोर 81.2%, GPT-4o Mini (65.8%) से बेहतर

• मूल विज़न — छवियों, चार्टों, दस्तावेज़ों और स्क्रीनशॉट का विश्लेषण करें

• Apache 2.0 लाइसेंस — व्यावसायिक और व्यक्तिगत उपयोग के लिए पूरी तरह खुला

• उन्नत फ़ंक्शन कॉलिंग — JSON आउटपुट के साथ मूल टूल उपयोग, एजेंटिक वर्कफ़्लो के लिए आदर्श

• बहुभाषी — CJK, अरबी, हिंदी और यूरोपीय भाषाओं सहित 25+ भाषाएँ

आवश्यकताएँ

घटक	क्वांटाइज़्ड (Q4)	पूर्ण परिशुद्धता (BF16)
GPU	1× RTX 4090 24GB	2× RTX 4090 या 1× H100
VRAM	~16GB	~55GB
RAM	32GB	64GB
डिस्क	20GB	50GB
CUDA	12.8+	12.8+

Clore.ai की अनुशंसा: क्वांटाइज़्ड इन्फ़रेंस के लिए RTX 4090 ($0.14–0.42/घंटा) — सर्वोत्तम मूल्य/प्रदर्शन अनुपात

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

Mistral Small 3.1 को चलाने का सबसे तेज़ तरीका:

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

# Mistral Small 3.1 चलाएँ (लगभग 14GB Q4 क्वांटाइज़ेशन स्वतः डाउनलोड करता है)
ollama run mistral-small3.1

# या एक विशिष्ट क्वांटाइज़ेशन निर्दिष्ट करें
ollama run mistral-small3.1:24b-instruct-2503-q4_K_M

OpenAI-संगत API के रूप में Ollama

# Ollama सर्वर शुरू करें
ollama serve &

# मॉडल प्राप्त करें
ollama pull mistral-small3.1

# API के माध्यम से क्वेरी करें
curl http://localhost:11434/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small3.1",
    "messages": [
      {"role": "system", "content": "आप एक मददगार कोडिंग सहायक हैं।"},
      {"role": "user", "content": "रेट लिमिटिंग के लिए एक Python डेकोरेटर लिखें"}
    ],
    "temperature": 0.15
  }'

विज़न के साथ Ollama

# विश्लेषण के लिए एक छवि भेजें
curl http://localhost:11434/api/chat -d '{
  "model": "mistral-small3.1",
  "messages": [{
    "role": "user",
    "content": "यह छवि क्या दिखाती है?",
    "images": ["/path/to/image.jpg"]
  }]
}'

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

उच्च थ्रूपुट और समवर्ती अनुरोधों वाले प्रोडक्शन वर्कलोड के लिए:

# vLLM इंस्टॉल करें (v0.8.1+ आवश्यक)
pip install -U vllm

# जांचें कि mistral_common इंस्टॉल है (यह स्वतः होना चाहिए)
python -c "import mistral_common; print(mistral_common.__version__)"

एकल GPU पर सर्व करें (केवल पाठ)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \\
  --tokenizer-mode mistral \\
  --config-format mistral \\
  --load-format mistral \\
  --tool-call-parser mistral \\
  --enable-auto-tool-choice \\
  --max-model-len 32768 \\
  --gpu-memory-utilization 0.90

विज़न के साथ सर्व करें (2 GPU अनुशंसित)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \\
  --tokenizer-mode mistral \\
  --config-format mistral \\
  --load-format mistral \\
  --tool-call-parser mistral \\
  --enable-auto-tool-choice \\
  --limit-mm-per-prompt 'image=10' \\
  --tensor-parallel-size 2 \\
  --max-model-len 65536

सर्वर से क्वेरी करें

from openai import OpenAI

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

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[
        {"role": "system", "content": "आप एक मददगार सहायक हैं। आज 2026-02-20 है।"},
        {"role": "user", "content": "ब्लॉग के लिए CRUD ऑपरेशनों वाला एक संपूर्ण REST API FastAPI में लिखें"}
    ],
    temperature=0.15,
    max_tokens=4096
)
print(response.choices[0].message.content)

HuggingFace Transformers

सीधे Python एकीकरण और प्रयोग के लिए:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # 4-बिट क्वांटाइज़ेशन — 24GB GPU पर फिट हो जाता है
)

messages = [
    {"role": "system", "content": "आप एक मददगार कोडिंग सहायक हैं।"},
    {"role": "user", "content": "Python में insert, delete और search मेथड्स के साथ एक बाइनरी सर्च ट्री लागू करें"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

output = model.generate(
    input_ids,
    max_new_tokens=2048,
    temperature=0.15,
    do_sample=True
)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

फ़ंक्शन कॉलिंग का उदाहरण

Mistral Small 3.1 टूल उपयोग के लिए सबसे अच्छे छोटे मॉडलों में से एक है:

import json
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "दिए गए टिकर प्रतीक के लिए वर्तमान स्टॉक मूल्य प्राप्त करें",
            "parameters": {
                "type": "object",
                "required": ["ticker"],
                "properties": {
                    "ticker": {"type": "string", "description": "स्टॉक टिकर प्रतीक (जैसे, AAPL)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_portfolio_value",
            "description": "होल्डिंग्स दिए जाने पर कुल पोर्टफोलियो मूल्य की गणना करें",
            "parameters": {
                "type": "object",
                "required": ["holdings"],
                "properties": {
                    "holdings": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "ticker": {"type": "string"},
                                "shares": {"type": "number"}
                            }
                        }
                    }
                }
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[{"role": "user", "content": "AAPL और MSFT की वर्तमान कीमत क्या है?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.15
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Call: {tool_call.function.name}({tool_call.function.arguments})")

Docker त्वरित शुरुआत

# एकल GPU परिनियोजन
docker run --gpus all -p 8000:8000 \\
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \\
  --tokenizer-mode mistral \\
  --config-format mistral \\
  --load-format mistral \\
  --tool-call-parser mistral \\
  --enable-auto-tool-choice \\
  --max-model-len 32768

# विज़न समर्थन के साथ (2 GPU)
docker run --gpus all -p 8000:8000 \\
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \\
  --tokenizer-mode mistral \\
  --config-format mistral \\
  --load-format mistral \\
  --tool-call-parser mistral \\
  --enable-auto-tool-choice \\
  --limit-mm-per-prompt 'image=10' \\
  --tensor-parallel-size 2

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

• RTX 4090 सबसे उपयुक्त विकल्प है: $0.14–0.42/घंटा पर, एकल RTX 4090 Mistral Small 3.1 को क्वांटाइज़्ड रूप में आसानी से चलाता है। सामान्य-उद्देश्य LLM के लिए Clore.ai पर सर्वोत्तम लागत/प्रदर्शन अनुपात।

• कम तापमान का उपयोग करें: Mistral AI अनुशंसा करता है temperature=0.15 अधिकांश कार्यों के लिए। अधिक तापमान इस मॉडल के साथ असंगत आउटपुट पैदा करते हैं।

• RTX 3090 भी काम करता है: $0.07–0.21/घंटा पर, RTX 3090 (24GB) Ollama के साथ Q4 क्वांटाइज़्ड मॉडल आराम से चलाता है। 4090 से थोड़ा धीमा, लेकिन आधी कीमत।

• त्वरित सेटअप के लिए Ollama, प्रोडक्शन के लिए vLLM: Ollama आपको 60 सेकंड में एक काम करने वाला मॉडल देता है। समवर्ती API अनुरोधों और अधिक थ्रूपुट के लिए vLLM पर स्विच करें।

• फ़ंक्शन कॉलिंग इसे खास बनाती है: कई 24B मॉडल चैट कर सकते हैं — बहुत कम ही भरोसेमंद रूप से टूल्स कॉल कर पाते हैं। Mistral Small 3.1 की फ़ंक्शन कॉलिंग GPT-4o Mini के समकक्ष है। एजेंट, API बैकएंड और ऑटोमेशन पाइपलाइन आत्मविश्वास के साथ बनाएँ।

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

समस्या	समाधान
OutOfMemoryError RTX 4090 पर	Ollama के माध्यम से क्वांटाइज़्ड मॉडल का उपयोग करें या load_in_4bit=True Transformers में। पूर्ण BF16 के लिए ~55GB चाहिए।
Ollama मॉडल नहीं मिला	उपयोग करें ollama run mistral-small3.1 (आधिकारिक लाइब्रेरी का नाम)।
vLLM टोकनाइज़र त्रुटियाँ	हमेशा पास करें --tokenizer-mode mistral --config-format mistral --load-format mistral.
खराब आउटपुट गुणवत्ता	सेट करें temperature=0.15. एक सिस्टम प्रॉम्प्ट जोड़ें। Mistral Small तापमान के प्रति संवेदनशील है।
1 GPU पर विज़न काम नहीं कर रहा	विज़न सुविधाओं के लिए अधिक VRAM चाहिए। उपयोग करें --tensor-parallel-size 2 या कम करें --max-model-len.
फ़ंक्शन कॉल खाली लौटते हैं	जोड़ें --tool-call-parser mistral --enable-auto-tool-choice vLLM serve के लिए।

अधिक पढ़ें

• HuggingFace पर Mistral Small 3.1

• Mistral AI ब्लॉग पोस्ट

• Ollama मॉडल पेज

• vLLM प्रलेखन

• Mistral Common लाइब्रेरी

• Mistral AI प्लेटफ़ॉर्म