Mistral.rs

रस्ट में लिखा गया वाक्यहीन तेज़ LLM इन्फ़रेंस — GGUF, GGML, SafeTensors समर्थन और OpenAI-संगत API के साथ उत्पादन-तैयार सर्वर।

🦀 रस्ट में निर्मित अधिकतम प्रदर्शन के लिए | GGUF और विज़न मॉडल समर्थन | Apache-2.0 लाइसेंस

---

Mistral.rs क्या है?

Mistral.rs एक उच्च-प्रदर्शन LLM इन्फ़रेंस इंजन है जो पूरी तरह से रस्टमें लिखा गया है। मूल रूप से Mistral मॉडलों पर केंद्रित, अब यह आधुनिक LLMs के पूरे परिदृश्य का समर्थन करता है। रस्ट फाउंडेशन प्रदान करती है:

• शून्य-लागत अमूर्तताएँ — इन्फ़रेंस के दौरान कोई गार्बेज कलेक्शन विराम नहीं

• मेमोरी सुरक्षा — कोई नल पॉइंटर अपवाद या मेमोरी लीक नहीं

• नियतात्मक प्रदर्शन — JVM/Python ओवरहेड के बिना सुसंगत विलंबता

• समय-निर्माण अनुकूलन — बिल्ड समय पर SIMD, थ्रेडिंग, और GPU कर्नल्स अनुकूलित

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

• GGUF समर्थन — किसी भी क्वांटाइज्ड मॉडल को चलाएँ (Q4_K_M, Q8_0, आदि)

• ISQ (इन-सिटू क्वांटाइज़ेशन) — लोड समय पर ऑन-द-फ्लाई क्वांटाइज़ करें

• PagedAttention — निरंतर बैचिंग के साथ कुशल KV कैश

• विजन लैंग्वेज मॉडल्स — LLaVA, Phi-3 Vision, Idefics समर्थन

• स्पेकुलेटिव डिकोडिंग — ड्राफ्ट मॉडलों के साथ तेज़ इन्फ़रेंस

• X-LoRA — स्केलेबल फाइन-ट्यून्ड एडाप्टर समर्थन

• OpenAI-अनुकूल REST API — ड्रॉप-इन रिप्लेसमेंट

समर्थित मॉडल परिवार

परिवार	फॉर्मैट	इंजन
Llama 2/3	GGUF, SafeTensors	Rust CUDA
Mistral/Mixtral	GGUF, SafeTensors	Rust CUDA
Phi-2/3	GGUF, SafeTensors	Rust CUDA
Gemma	GGUF, SafeTensors	Rust CUDA
Qwen 2	GGUF, SafeTensors	Rust CUDA
Starcoder 2	GGUF	Rust CUDA
LLaVA 1.5/1.6	SafeTensors	विजन
Phi-3 Vision	SafeTensors	विजन

---

Clore.ai पर शीघ्र आरम्भ

चरण 1: एक GPU सर्वर खोजें

पर clore.ai मार्केटप्लेस:

• न्यूनतम: 8GB VRAM (7B Q4 मॉडलों के लिए)

• अनुशंसित: बड़े मॉडलों के लिए RTX 3090/4090 (24GB)

• CUDA 11.8+ आवश्यक

चरण 2: Mistral.rs Docker तैनात करें

Docker इमेज: ghcr.io/ericlbuehler/mistral.rs:cuda

पोर्ट मैपिंग्स:

कंटेनर पोर्ट	उद्देश्य
22	SSH पहुंच
8080	REST API सर्वर

उपलब्ध इमेज वैरिएंट्स:

# CUDA (अधिकांश Clore.ai सर्वरों के लिए)
ghcr.io/ericlbuehler/mistral.rs:cuda

# केवल CPU
ghcr.io/ericlbuehler/mistral.rs:cpu

# Metal (Apple Silicon - Clore.ai के लिए नहीं)
ghcr.io/ericlbuehler/mistral.rs:metal

चरण 3: कनेक्ट और सत्यापित करें

ssh root@<clore-node-ip> -p <ssh-port>

# mistral.rs बाइनरी जांचें
mistralrs-server --help

---

सर्वर चलाना

GGUF मॉडल के साथ त्वरित प्रारंभ

# HuggingFace से सीधे एक GGUF मॉडल सर्व करें
mistralrs-server \
  --port 8080 \
  --log info \
  gguf \
  -m TheBloke/Llama-2-7B-Chat-GGUF \
  -f llama-2-7b-chat.Q4_K_M.gguf

Mistral 7B (SafeTensors) सर्व करें

mistralrs-server \
  --port 8080 \
  plain \
  -m mistralai/Mistral-7B-Instruct-v0.3 \
  --isq Q4K

इन-सिटू क्वांटाइज़ेशन (ISQ) के साथ सर्व करें

ISQ लोड समय पर मॉडल को क्वांटाइज़ करता है — किसी प्री-क्वांटाइज़्ड मॉडल की आवश्यकता नहीं:

# Llama 3 8B लोड करें और ऑन-द-फ्लाई Q4K में क्वांटाइज़ करें
mistralrs-server \
  --port 8080 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

# उपलब्ध ISQ विकल्प:
# Q4_0, Q4_1, Q5_0, Q5_1, Q8_0
# Q2K, Q3K, Q4K, Q5K, Q6K, Q8K
# HQQ4, HQQ8 (हाफ-क्वाड्रेटिक क्वांटाइज़ेशन)

विजन लैंग्वेज मॉडल

mistralrs-server \
  --port 8080 \
  vision-plain \
  -m llava-hf/llava-1.5-7b-hf \
  --isq Q4K

स्पेकुलेटिव डिकोडिंग

# जनरेशन तेज करने के लिए एक छोटा ड्राफ्ट मॉडल उपयोग करें
mistralrs-server \
  --port 8080 \
  speculative \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K \
  -d meta-llama/Meta-Llama-3-1B-Instruct \
  --draft-isq Q4K \
  -n 5  # स्पेकुलेटिव टोकन्स

स्पेकुलेटिव डिकोडिंग प्रदान कर सकता है 2–3x गति वृद्धि उन अधिकांश वार्तालाप workloads के लिए जहाँ छोटा ड्राफ्ट मॉडल सटीक रूप से अगले टोकन की भविष्यवाणी करता है।

---

API उपयोग

OpenAI-संगत एंडपॉइंट्स

एंडपॉइंट	विधि	विवरण
/v1/chat/completions	POST	चैट कम्प्लीशन्स
/v1/completions	POST	टेक्स्ट कंप्लीशंस
/v1/models	GET	मॉडल सूचीबद्ध करें
/v1/images/generations	POST	इमेज जनरेशन (VLMs)
/v1/re_isq	POST	लोड किए गए मॉडल को फिर से-क्वांटाइज़ करें
/health	GET	हेल्थ चेक

पायथन उदाहरण

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # डिफ़ॉल्ट रूप से कोई प्रमाणिकरण आवश्यक नहीं
)

# चैट कम्प्लीशन
response = client.chat.completions.create(
    model="llama-3-8b",  # मॉडल नाम लचीला है
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "एक लिंक्ड लिस्ट को उलटने के लिए एक पायथन फ़ंक्शन लिखें"}
    ],
    temperature=0.1,  # कोड जनरेशन के लिए कम ताप
    max_tokens=1024
)
print(response.choices[0].message.content)

स्ट्रीमिंग प्रतिक्रिया

with client.chat.completions.create(
    model="llama-3-8b",
    messages=[{"role": "user", "content": "मुझे एक रोबोट के बारे में कहानी सुनाओ."}],
    stream=True,
    max_tokens=512
) as stream:
    for chunk in stream:
        delta = chunk.choices[0].delta
        if hasattr(delta, 'content') and delta.content:
            print(delta.content, end="", flush=True)
print()

विजन/इमेज इनपुट

import base64
from pathlib import Path

# इमेज लोड करें
image_data = base64.b64encode(Path("photo.jpg").read_bytes()).decode()

response = client.chat.completions.create(
    model="llava-1.5-7b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "आप इस छवि में क्या देखते हैं?"
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)

cURL उदाहरण

# बुनियादी चैट
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Rust क्या है?"}],
    "temperature": 0.7,
    "max_tokens": 256
  }'

# मॉडल सूचीबद्ध करें
curl http://localhost:8080/v1/models

# हेल्थ चेक
curl http://localhost:8080/health

---

कॉन्फ़िगरेशन विकल्प

सर्वर फ़्लैग्स

mistralrs-server \
  --port 8080 \                    # API पोर्ट (डिफ़ॉल्ट: 1234)
  --host 0.0.0.0 \                 # बाइंड पता
  --log info \                     # लॉग स्तर: off/error/warn/info/debug/trace
  --token-source env:HF_TOKEN \    # HuggingFace टोकन स्रोत
  --max-seqs 16 \                  # अधिकतम समवर्ती सीक्वेंस
  --no-paged-attn \                # PagedAttention अक्षम करें (डिबगिंग के लिए उपयोग करें)
  --prefix-cache-n 16 \            # प्रीफ़िक्स कैश प्रविष्टियाँ
  plain \                          # मॉडल प्रकार सबकमांड
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

ISQ क्वांटाइज़ेशन संदर्भ

ISQ विकल्प	बिट्स	गुणवत्ता	VRAM (7B)
Q2K	2	★★☆☆☆	~2.5GB
Q3K	3	★★★☆☆	~3.5GB
Q4_0	4	★★★★☆	~4.5GB
Q4K	4	★★★★☆	~4.5GB
Q5K	5	★★★★★	~5.5GB
Q6K	6	★★★★★	~6.5GB
Q8_0	8	★★★★★	~8GB
HQQ4	4	★★★★☆	~4.5GB
HQQ8	8	★★★★★	~8GB

HQQ (हाफ-क्वाड्रेटिक क्वांटाइज़ेशन) अक्सर समान बिट स्तर पर GGUF Q4 की तुलना में बेहतर गुणवत्ता प्राप्त करता है, विशेष रूप से निर्देश-अनुसरण कार्यों के लिए।

---

उन्नत सुविधाएँ

X-LoRA (LoRA एडाप्टर का मिश्रण)

प्रति टोकन गतिशील रूप से चुने गए कई फाइन-ट्यून्ड एडाप्टर्स चलाएँ:

mistralrs-server \
  --port 8080 \
  x-lora-plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K \
  -x ./xlora-config.json

रनटाइम पर फिर से-क्वांटाइज़ करें

# बिना पुनः आरंभ किए क्वांटाइज़ेशन बदलें
curl http://localhost:8080/v1/re_isq \
  -H "Content-Type: application/json" \
  -d '{"isq_type": "Q8_0"}'

अनुरोध लॉगिंग

# फ़ाइल में अनुरोध लॉगिंग सक्षम करें
mistralrs-server \
  --port 8080 \
  --log info \
  --request-logging-file ./requests.jsonl \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

---

प्रदर्शन ट्यूनिंग

थ्रूपुट के लिए अनुकूलित करें

# समवर्ती अनुरोधों के लिए उच्चतर max-seqs
mistralrs-server \
  --port 8080 \
  --max-seqs 32 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

कम विलंबता के लिए अनुकूलित करें

# कम max-seqs, प्रीफ़िक्स कैश शेयरिंग अक्षम करें
mistralrs-server \
  --port 8080 \
  --max-seqs 4 \
  --prefix-cache-n 0 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

प्रदर्शन पर नजर रखें

# इन्फ़रेंस के दौरान GPU उपयोग देखें
watch -n 1 nvidia-smi

# nvtop के साथ प्रोफ़ाइल करें
apt-get install nvtop && nvtop

---

Docker Compose

version: '3.8'
services:
  mistral-rs:
    image: ghcr.io/ericlbuehler/mistral.rs:cuda
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - HF_TOKEN=${HUGGING_FACE_HUB_TOKEN}
    ports:
      - "8080:8080"
    volumes:
      - hf-cache:/root/.cache/huggingface
    command: >
      mistralrs-server
      --port 8080
      --host 0.0.0.0
      --log info
      --max-seqs 16
      --token-source env:HF_TOKEN
      plain
      -m meta-llama/Meta-Llama-3-8B-Instruct
      --isq Q4K
    restart: unless-stopped

volumes:
  hf-cache:

---

स्रोत से बिल्ड करना

यदि Docker इमेज आपके CUDA संस्करण से मेल नहीं खाती:

# Rust इंस्टॉल करें
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# क्लोन और बिल्ड करें
git clone https://github.com/EricLBuehler/mistral.rs.git
cd mistral.rs

# CUDA समर्थन के साथ बिल्ड करें
cargo build --release --features cuda

# बाइनरी स्थान
./target/release/mistralrs-server --help

बिल्ड समय: Rust संकलन धीमा है। पूर्ण बिल्ड के लिए 10–20 मिनट की उम्मीद रखें। उपयोग करें sccache इंक्रिमेंटल बिल्ड्स को तेज़ करने के लिए: cargo install sccache && RUSTC_WRAPPER=sccache cargo build --release --features cuda

---

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

CUDA पुस्तकालय नहीं मिला

# CUDA लाइब्रेरी जाँचें
ldconfig -p | grep libcuda
ls /usr/local/cuda/lib64/

# लाइब्रेरी पाथ सेट करें
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH

मॉडल डाउनलोड विफल

# HuggingFace टोकन सेट करें
export HF_TOKEN=your_token_here

# या --token-source फ्लैग का उपयोग करें
mistralrs-server \
  --token-source env:HF_TOKEN \
  ...

# या पहले मैन्युअल रूप से डाउनलोड करें
huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --local-dir ./llama3-8b
mistralrs-server ... plain -m ./llama3-8b --isq Q4K

पोर्ट 8080 उपयोग में है

# प्रक्रिया खोजें और बंद करें
fuser -k 8080/tcp

# अलग पोर्ट उपयोग करें
mistralrs-server --port 9090 ...

क्वांटाइज़ेशन के दौरान मेमोरी समाप्त

# ISQ GPU पर क्वांटाइज़ करता है — पहले अन्य GPU उपयोग कम करें
# या GGUF (प्री-क्वांटाइज़्ड, लोडिंग के दौरान कम पीक मेमोरी) में स्विच करें
mistralrs-server \
  gguf \
  -m TheBloke/Llama-2-7B-Chat-GGUF \
  -f llama-2-7b-chat.Q4_K_M.gguf

ISQ बनाम GGUF: ISQ लोड समय पर GPU मेमोरी का उपयोग करते हुए क्वांटाइज़ करता है (अस्थायी उछाल)। यदि आपके पास VRAM कम है, तो TheBloke या समान स्रोतों से प्री-क्वांटाइज़्ड GGUF फाइलें उपयोग करें — लोडिंग के दौरान वे कम पीक मेमोरी उपयोग करती हैं।

---

Clore.ai GPU सिफारिशें

Mistral.rs एक रस्ट-नेटिव इंजन है — इसका कम ओवरहेड आपको Python-आधारित सर्वरों की तुलना में प्रति GPU डॉलर अधिक थ्रूपुट देता है।

GPU	VRAM	Clore.ai कीमत	अनुशंसित उपयोग	थ्रूपुट (Mistral 7B Q4)
RTX 3090	24 GB	~$0.12/घंटा	सर्वोत्तम बजट विकल्प — 7B Q4/Q8, विज़न मॉडल्स	~120 tok/s
RTX 4090	24 GB	~$0.70/घंटा	उच्च-थ्रूपुट 7B–34B, स्पेकुलेटिव डिकोडिंग	~200 tok/s
A100 40GB	40 GB	~$1.20/घंटा	उत्पादन 34B–70B Q4 सर्विंग	~160 tok/s
A100 80GB	80 GB	~$2.00/घंटा	पूर्ण-प्रिसीजन 70B, मल्टी-मॉडल	~185 tok/s

क्यों RTX 3090 यहाँ उत्कृष्ट है: Mistral.rs के Rust CUDA कर्नल Python GIL ओवरहेड और गार्बेज कलेक्शन विरामों से बचते हैं जो Python सर्वरों को प्रभावित करते हैं। Mistral 7B Q4_K_M चलाते हुए एक RTX 3090 प्रदान करता है 120 tok/s — समान हार्डवेयर पर vLLM के बराबर और लागत का एक हिस्सा ($0.12/hr बनाम क्लाउड प्रदाताओं का $1–2/hr चार्ज)।

स्पेकुलेटिव डिकोडिंग: किसी बड़े मॉडल (34B) को एक छोटे ड्राफ्ट मॉडल (3B) के साथ पेयर करें बिना गुणवत्ता हानि के 2–3× गति वृद्धि के लिए। इस पैटर्न के लिए RTX 4090 आदर्श है।

---

संसाधन

• 🐙 GitHub: github.com/EricLBuehler/mistral.rs

• 📦 कंटेनर रजिस्ट्री: ghcr.io/ericlbuehler/mistral.rs

• 📚 डॉक्यूमेंटेशन: ericlbuehler.github.io/mistral.rs

• 💬 डिसकोर्ड: discord.gg/SZrecqK8qw

• 🤗 GGUF मॉडल्स: huggingface.co/TheBloke