> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/mistral-rs.md).

# 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](https://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 सर्वर |

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

```bash
# 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: कनेक्ट और सत्यापित करें

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

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

***

## सर्वर चलाना

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

```bash
# 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) सर्व करें

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

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

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

```bash
# 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 (हाफ-क्वाड्रेटिक क्वांटाइज़ेशन)
```

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

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

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

```bash
# जनरेशन तेज करने के लिए एक छोटा ड्राफ्ट मॉडल उपयोग करें
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  # स्पेकुलेटिव टोकन्स
```

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

***

## 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": "You are a helpful coding assistant."},
        {"role": "user", "content": "एक लिंक्ड लिस्ट को उलटने के लिए एक पायथन फ़ंक्शन लिखें"}
    ],
    temperature=0.1,  # कोड जनरेशन के लिए कम ताप
    max_tokens=1024
)
print(response.choices[0].message.content)
```

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

```python
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()
```

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

```python
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 उदाहरण

```bash
# बुनियादी चैट
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
```

***

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

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

```bash
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     |

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

***

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

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

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

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

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

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

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

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

***

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

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

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

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

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

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

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

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

***

## Docker Compose

```yaml
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 संस्करण से मेल नहीं खाती:

```bash
# 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
```

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

***

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

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

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

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

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

```bash
# 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 उपयोग में है

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

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

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

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

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

***

## 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](https://github.com/EricLBuehler/mistral.rs)
* 📦 **कंटेनर रजिस्ट्री:** [ghcr.io/ericlbuehler/mistral.rs](https://ghcr.io/ericlbuehler/mistral.rs)
* 📚 **डॉक्यूमेंटेशन:** [ericlbuehler.github.io/mistral.rs](https://ericlbuehler.github.io/mistral.rs/mistralrs/)
* 💬 **डिसकोर्ड:** [discord.gg/SZrecqK8qw](https://discord.gg/SZrecqK8qw)
* 🤗 **GGUF मॉडल्स:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/mistral-rs.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.