# 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@ -p # 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://:/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)