Mistral.rs

Rust में लिखित बेहद तेज़ LLM इन्फ़रेंस — GGUF, GGML, SafeTensors समर्थन और OpenAI-संगत API के साथ प्रोडक्शन-रेडी सर्वर।

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

Mistral.rs क्या है?

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

शून्य-लागत अमूर्तताएँ — इन्फ़रेंस के दौरान कोई garbage collection pause नहीं
मेमोरी सुरक्षा — null pointer exceptions या memory leaks नहीं
निर्धारित प्रदर्शन — JVM/Python overhead के बिना स्थिर latency
कंपाइल-समय अनुकूलन — SIMD, threading, और GPU kernels को build time पर अनुकूलित किया गया

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

GGUF समर्थन — कोई भी quantized model चलाएँ (Q4_K_M, Q8_0, आदि)
ISQ (इन-सिटू क्वांटाइज़ेशन) — load time पर तुरंत quantize करें
PagedAttention — continuous batching के साथ कुशल KV cache
विज़न भाषा मॉडल — LLaVA, Phi-3 Vision, Idefics समर्थन
अनुमानात्मक decoding — draft models के साथ तेज़ इन्फ़रेंस
X-LoRA — स्केलेबल fine-tuned adapter समर्थन
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 मॉडल को load time पर quantize करता है — पहले से quantized मॉडल की आवश्यकता नहीं:

# Llama 3 8B लोड करें और तुरंत Q4K में quantize करें
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 (Half-Quadratic Quantization)

विज़न भाषा मॉडल

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

अनुमानात्मक decoding

# जनरेशन तेज़ करने के लिए एक छोटा draft model उपयोग करें
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  # Speculative tokens

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

API उपयोग

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

एंडपॉइंट

विधि

विवरण

/v1/chat/completions

POST

चैट पूर्णताएँ

/v1/completions

POST

पाठ पूर्णताएँ

/v1/models

GET

मॉडल सूची

/v1/images/generations

POST

छवि निर्माण (VLMs)

/v1/re_isq

POST

लोड किए गए मॉडल को पुनः क्वांटाइज़ करें

/health

GET

स्वास्थ्य जाँच

Python उदाहरण

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": "आप एक मददगार कोडिंग सहायक हैं।"},
        {"role": "user", "content": "एक लिंक्ड लिस्ट को उलटने के लिए Python फ़ंक्शन लिखें"}
    ],
    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 \\                  # समकालिक sequences की अधिकतम संख्या
  --no-paged-attn \\                # PagedAttention अक्षम करें (debugging के लिए उपयोग करें)
  --prefix-cache-n 16 \\            # Prefix cache प्रविष्टियाँ
  plain \\                          # मॉडल प्रकार सबकमांड
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K

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

ISQ विकल्प

बिट्स

गुणवत्ता

VRAM (7B)

Q2K

★★☆☆☆

~2.5GB

Q3K

★★★☆☆

~3.5GB

Q4_0

★★★★☆

~4.5GB

Q4K

★★★★☆

~4.5GB

Q5K

★★★★★

~5.5GB

Q6K

★★★★★

~6.5GB

Q8_0

★★★★★

~8GB

HQQ4

★★★★☆

~4.5GB

HQQ8

★★★★★

~8GB

HQQ (Half-Quadratic Quantization) अक्सर समान बिट स्तर पर GGUF Q4 की तुलना में बेहतर गुणवत्ता देता है, खासकर निर्देश-पालन कार्यों के लिए।

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

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

प्रति टोकन गतिशील रूप से चुने गए कई fine-tuned adapters चलाएँ:

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

रनटाइम पर पुनः-क्वांटाइज़ करें

# पुनः आरंभ किए बिना quantization बदलें
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

कम latency के लिए अनुकूलित करें

# कम max-seqs, prefix cache sharing अक्षम करें
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 image आपकी CUDA version से मेल नहीं खाती:

# 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 पर quantize करता है — पहले अन्य GPU उपयोग कम करें
# या GGUF पर स्विच करें (पहले से quantized, कम peak memory)
mistralrs-server \\
  gguf \\
  -m TheBloke/Llama-2-7B-Chat-GGUF \\
  -f llama-2-7b-chat.Q4_K_M.gguf

ISQ बनाम GGUF: ISQ load time पर GPU मेमोरी का उपयोग करके quantize करता है (अस्थायी स्पाइक)। यदि आपके पास VRAM कम है, तो TheBloke या इसी तरह के pre-quantized GGUF files उपयोग करें — वे लोडिंग के दौरान कम peak memory लेते हैं।

Clore.ai GPU अनुशंसाएँ

Mistral.rs एक Rust-native इंजन है — इसका कम overhead मतलब Python-based servers की तुलना में आपको प्रति GPU डॉलर अधिक throughput मिलता है।

GPU

VRAM

Clore.ai मूल्य

अनुशंसित उपयोग

थ्रूपुट (Mistral 7B Q4)

RTX 3090

24 GB

$0.07–0.21/hr

सबसे अच्छा बजट विकल्प — 7B Q4/Q8, विज़न मॉडल

~120 tok/s

RTX 4090

24 GB

$0.14–0.42/hr

उच्च-थ्रूपुट 7B–34B, speculative decoding

~200 tok/s

A100 40GB

40 GB

bare metal

प्रोडक्शन 34B–70B Q4 सर्विंग

~160 tok/s

A100 80GB

80 GB

bare metal

पूर्ण-परिशुद्धता 70B, multi-model

~185 tok/s

यहाँ RTX 3090 क्यों उत्कृष्ट है: Mistral.rs के Rust CUDA kernels Python GIL overhead और garbage collection pauses से बचते हैं, जो Python servers को नुकसान पहुँचाते हैं। Mistral 7B Q4_K_M चलाने वाला RTX 3090 लगभग ~120 tok/s देता है — वही hardware पर vLLM के बराबर, लेकिन लागत का एक अंश ($0.07–0.21/घंटा बनाम cloud providers द्वारा $0.07–0.21/घंटा)।

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

संसाधन

🐙 GitHub: github.com/EricLBuehler/mistral.rs
📦 कंटेनर रजिस्ट्री: ghcr.io/ericlbuehler/mistral.rs
📚 दस्तावेज़ीकरण: ericlbuehler.github.io/mistral.rs
💬 Discord: discord.gg/SZrecqK8qw
🤗 GGUF मॉडल: huggingface.co/TheBloke

पिछलाLMDeploy

अगलाअवलोकन

अंतिम अपडेट 12 दिन पहले

क्या यह उपयोगी था?