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	11.8+	12.0+

Clore.ai सिफारिश: क्वांटाइज़्ड इंफरेंस के लिए RTX 4090 (~$0.5–2/दिन) — सर्वश्रेष्ठ मूल्य/प्रदर्शन अनुपात

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-Compatible 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": "Write a Python decorator for rate limiting"}
    ],
    "temperature": 0.15
  }'

विजन के साथ Ollama

# विश्लेषण के लिए एक छवि भेजें
curl http://localhost:11434/api/chat -d '{
  "model": "mistral-small3.1",
  "messages": [{
    "role": "user",
    "content": "What does this image show?",
    "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 GPUs की सिफारिश)

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": "You are a helpful assistant. Today is 2026-02-20."},
        {"role": "user", "content": "Write a complete REST API in FastAPI with CRUD operations for a blog"}
    ],
    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": "Implement a binary search tree in Python with insert, delete, and search methods"}
]

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": "Get the current stock price for a given ticker symbol",
            "parameters": {
                "type": "object",
                "required": ["ticker"],
                "properties": {
                    "ticker": {"type": "string", "description": "Stock ticker symbol (e.g., AAPL)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_portfolio_value",
            "description": "Calculate total portfolio value given holdings",
            "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": "What's the current price of AAPL and 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 GPUs)
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.5–2/दिन पर, एकल RTX 4090 क्वांटाइज़्ड Mistral Small 3.1 चला सकता है और कुछ जगह बचा कर रखता है। सामान्य-उद्देश्य LLM के लिए Clore.ai पर सर्वश्रेष्ठ लागत/प्रदर्शन अनुपात।

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

• RTX 3090 भी काम करता है: $0.3–1/दिन पर, 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 प्लेटफ़ॉर्म