# Mistral.rs **Inférence LLM ultra-rapide écrite en Rust** — serveur prêt pour la production avec prise en charge GGUF, GGML, SafeTensors et API compatible OpenAI. > 🦀 **Conçu en Rust** pour des performances maximales | prise en charge GGUF et modèles vision | Licence Apache-2.0 *** ## Qu'est-ce que Mistral.rs ? Mistral.rs est un moteur d'inférence LLM haute performance écrit entièrement en **Rust**. À l'origine centré sur les modèles Mistral, il prend désormais en charge l'ensemble des LLM modernes. La fondation Rust offre : * **Abstractions sans coût** — pas de pauses de collecte de déchets pendant l'inférence * **Sécurité mémoire** — pas d'exceptions de pointeur nul ni de fuites mémoire * **Performances déterministes** — latence cohérente sans frais JVM/Python * **Optimisations au moment de la compilation** — SIMD, multithreading et noyaux GPU optimisés à la compilation ### Fonctionnalités clés * **Prise en charge GGUF** — exécutez n'importe quel modèle quantifié (Q4\_K\_M, Q8\_0, etc.) * **ISQ (In-Situ Quantization)** — quantification à la volée au moment du chargement * **PagedAttention** — cache KV efficace avec lotissement continu * **Modèles Vision-Langage** — prise en charge de LLaVA, Phi-3 Vision, Idefics * **Décodage spéculatif** — inférence plus rapide avec des modèles draft * **X-LoRA** — prise en charge d'adaptateurs fine-tunés évolutive * **API REST compatible OpenAI** — remplacement prêt à l'emploi ### Familles de modèles prises en charge | Famille | Format | Moteur | | --------------- | ----------------- | --------- | | 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 | Vision | | Phi-3 Vision | SafeTensors | Vision | *** ## Démarrage rapide sur Clore.ai ### Étape 1 : Trouver un serveur GPU Sur [clore.ai](https://clore.ai) place de marché : * **Minimum :** 8 Go de VRAM (pour les modèles 7B Q4) * **Recommandé :** RTX 3090/4090 (24 Go) pour les modèles plus gros * CUDA 11.8+ requis ### Étape 2 : Déployer Mistral.rs Docker ``` Image Docker : ghcr.io/ericlbuehler/mistral.rs:cuda ``` **Mappages de ports :** | Port du conteneur | Usage | | ----------------- | ---------------- | | `22` | Accès SSH | | `8080` | Serveur API REST | **Variantes d'image disponibles :** ```bash # CUDA (la plupart des serveurs Clore.ai) ghcr.io/ericlbuehler/mistral.rs:cuda # CPU seulement ghcr.io/ericlbuehler/mistral.rs:cpu # Metal (Apple Silicon - pas pour Clore.ai) ghcr.io/ericlbuehler/mistral.rs:metal ``` ### Étape 3 : Connecter et vérifier ```bash ssh root@ -p # Vérifier le binaire mistral.rs mistralrs-server --help ``` *** ## Exécution du serveur ### Démarrage rapide avec un modèle GGUF ```bash # Servir un modèle GGUF directement depuis HuggingFace mistralrs-server \ --port 8080 \ --log info \ gguf \ -m TheBloke/Llama-2-7B-Chat-GGUF \ -f llama-2-7b-chat.Q4_K_M.gguf ``` ### Servir Mistral 7B (SafeTensors) ```bash mistralrs-server \ --port 8080 \ plain \ -m mistralai/Mistral-7B-Instruct-v0.3 \ --isq Q4K ``` ### Servir avec quantification In-Situ (ISQ) ISQ quantifie le modèle au moment du chargement — aucun modèle pré-quantifié nécessaire : ```bash # Charger Llama 3 8B et quantifier en Q4K à la volée mistralrs-server \ --port 8080 \ plain \ -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K # Options ISQ disponibles : # Q4_0, Q4_1, Q5_0, Q5_1, Q8_0 # Q2K, Q3K, Q4K, Q5K, Q6K, Q8K # HQQ4, HQQ8 (Quantification demi-quadratique) ``` ### Modèle Vision-Langage ```bash mistralrs-server \ --port 8080 \ vision-plain \ -m llava-hf/llava-1.5-7b-hf \ --isq Q4K ``` ### Décodage spéculatif ```bash # Utiliser un petit modèle draft pour accélérer la génération 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 # Tokens spéculatifs ``` {% hint style="success" %} **Décodage spéculatif** peut fournir **un gain de vitesse de 2–3x** pour la plupart des charges de travail conversationnelles où le petit modèle draft prédit correctement les tokens suivants. {% endhint %} *** ## Utilisation de l'API ### Endpoints compatibles OpenAI | Point de terminaison | Méthode | Description | | ------------------------ | ------- | ------------------------------ | | `/v1/chat/completions` | POST | Complétions de chat | | `/v1/completions` | POST | Complétions de texte | | `/v1/models` | GET | Lister les modèles | | `/v1/images/generations` | POST | Génération d'images (VLMs) | | `/v1/re_isq` | POST | Re-quantifier le modèle chargé | | `/health` | GET | Vérification de l'état | ### Exemple Python ```python from openai import OpenAI client = OpenAI( base_url="http://:/v1", api_key="none" # Aucune authentification requise par défaut ) # Complétion de chat response = client.chat.completions.create( model="llama-3-8b", # Le nom du modèle est flexible messages=[ {"role": "system", "content": "You are a helpful coding assistant."}, {"role": "user", "content": "Écrire une fonction Python pour inverser une liste chaînée"} ], temperature=0.1, # Temp faible pour la génération de code max_tokens=1024 ) print(response.choices[0].message.content) ``` ### Réponse en streaming ```python with client.chat.completions.create( model="llama-3-8b", messages=[{"role": "user", "content": "Raconte-moi une histoire sur un robot."}], 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() ``` ### Entrée vision/image ```python import base64 from pathlib import Path # Charger l'image 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": "Que voyez-vous dans cette image ?" } ] } ] ) print(response.choices[0].message.content) ``` ### Exemples cURL ```bash # Chat basique curl http://localhost:8080/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "mistral-7b", "messages": [{"role": "user", "content": "Qu'est-ce que Rust ?"}], "temperature": 0.7, "max_tokens": 256 }' # Lister les modèles curl http://localhost:8080/v1/models # Vérification de l'état curl http://localhost:8080/health ``` *** ## Options de configuration ### Flags du serveur ```bash mistralrs-server \ --port 8080 \ # Port de l'API (par défaut : 1234) --host 0.0.0.0 \ # Adresse de liaison --log info \ # Niveau de journalisation : off/error/warn/info/debug/trace --token-source env:HF_TOKEN \ # Source du token HuggingFace --max-seqs 16 \ # Séquences concurrentes maximales --no-paged-attn \ # Désactiver PagedAttention (à utiliser pour le débogage) --prefix-cache-n 16 \ # Entrées du cache de préfixe plain \ # Sous-commande type de modèle -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K ``` ### Référence de quantification ISQ | Option ISQ | Bits | Qualité | VRAM (7B) | | ---------- | ---- | ------- | --------- | | `Q2K` | 2 | ★★☆☆☆ | \~2,5 Go | | `Q3K` | 3 | ★★★☆☆ | \~3,5 Go | | `Q4_0` | 4 | ★★★★☆ | \~4,5 Go | | `Q4K` | 4 | ★★★★☆ | \~4,5 Go | | `Q5K` | 5 | ★★★★★ | \~5,5 Go | | `Q6K` | 6 | ★★★★★ | \~6,5 Go | | `Q8_0` | 8 | ★★★★★ | \~8GB | | `HQQ4` | 4 | ★★★★☆ | \~4,5 Go | | `HQQ8` | 8 | ★★★★★ | \~8GB | {% hint style="info" %} **HQQ (Quantification demi-quadratique)** atteint souvent une meilleure qualité que GGUF Q4 au même niveau de bits, en particulier pour les tâches suivant des instructions. {% endhint %} *** ## Fonctionnalités avancées ### X-LoRA (Mélange d'adaptateurs LoRA) Exécuter plusieurs adaptateurs fine-tunés sélectionnés dynamiquement par token : ```bash mistralrs-server \ --port 8080 \ x-lora-plain \ -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K \ -x ./xlora-config.json ``` ### Re-quantifier à l'exécution ```bash # Changer la quantification sans redémarrer curl http://localhost:8080/v1/re_isq \ -H "Content-Type: application/json" \ -d '{"isq_type": "Q8_0"}' ``` ### Journalisation des requêtes ```bash # Activer la journalisation des requêtes vers un fichier mistralrs-server \ --port 8080 \ --log info \ --request-logging-file ./requests.jsonl \ plain \ -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K ``` *** ## Optimisation des performances ### Optimiser pour le débit ```bash # Plus de max-seqs pour les requêtes concurrentes mistralrs-server \ --port 8080 \ --max-seqs 32 \ plain \ -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K ``` ### Optimiser pour une faible latence ```bash # Moins de max-seqs, désactiver le partage du cache de préfixe mistralrs-server \ --port 8080 \ --max-seqs 4 \ --prefix-cache-n 0 \ plain \ -m meta-llama/Meta-Llama-3-8B-Instruct \ --isq Q4K ``` ### Surveiller les performances ```bash # Surveiller l'utilisation du GPU pendant l'inférence watch -n 1 nvidia-smi # Profiler avec 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: ``` *** ## Compilation depuis les sources Si l'image Docker ne correspond pas à votre version de CUDA : ```bash # Installer Rust curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source ~/.cargo/env # Cloner et compiler git clone https://github.com/EricLBuehler/mistral.rs.git cd mistral.rs # Compiler avec le support CUDA cargo build --release --features cuda # Emplacement du binaire ./target/release/mistralrs-server --help ``` {% hint style="warning" %} **Temps de compilation :** La compilation Rust est lente. Prévoyez 10–20 minutes pour une compilation complète. Utilisez `sccache` pour accélérer les compilations incrémentales : `cargo install sccache && RUSTC_WRAPPER=sccache cargo build --release --features cuda` {% endhint %} *** ## Dépannage ### Bibliothèque CUDA introuvable ```bash # Vérifier les bibliothèques CUDA ldconfig -p | grep libcuda ls /usr/local/cuda/lib64/ # Définir le chemin des bibliothèques export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH ``` ### Échec du téléchargement du modèle ```bash # Définir le token HuggingFace export HF_TOKEN=your_token_here # Ou utiliser l'option --token-source mistralrs-server \ --token-source env:HF_TOKEN \ ... # Ou télécharger manuellement d'abord huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --local-dir ./llama3-8b mistralrs-server ... plain -m ./llama3-8b --isq Q4K ``` ### Port 8080 utilisé ```bash # Trouver et tuer le processus fuser -k 8080/tcp # Utiliser un port différent mistralrs-server --port 9090 ... ``` ### Mémoire insuffisante pendant la quantification ```bash # ISQ quantifie sur GPU — réduisez d'abord l'utilisation GPU par d'autres processus # Ou passez à GGUF (pré-quantifié, pic mémoire inférieur) mistralrs-server \ gguf \ -m TheBloke/Llama-2-7B-Chat-GGUF \ -f llama-2-7b-chat.Q4_K_M.gguf ``` {% hint style="danger" %} **ISQ vs GGUF :** ISQ quantifie au moment du chargement en utilisant la mémoire GPU (pic temporaire). Si vous manquez de VRAM, utilisez des fichiers GGUF pré-quantifiés depuis TheBloke ou similaires — ils utilisent un pic mémoire inférieur lors du chargement. {% endhint %} *** ## Recommandations GPU Clore.ai Mistral.rs est un moteur natif Rust — son faible overhead signifie que vous obtenez plus de débit par dollar GPU comparé aux serveurs basés sur Python. | GPU | VRAM | Prix Clore.ai | Utilisation recommandée | Débit (Mistral 7B Q4) | | --------- | ----- | ------------- | -------------------------------------------------- | --------------------- | | RTX 3090 | 24 Go | \~0,12 $/h | Meilleure option budget — 7B Q4/Q8, modèles vision | \~120 tok/s | | RTX 4090 | 24 Go | \~0,70 $/h | Haut débit 7B–34B, décodage spéculatif | \~200 tok/s | | A100 40GB | 40 Go | \~1,20 $/h | Production 34B–70B Q4 en service | \~160 tok/s | | A100 80GB | 80 Go | \~2,00 $/h | Précision totale 70B, multi-modèle | \~185 tok/s | **Pourquoi le RTX 3090 excelle ici :** Les noyaux Rust CUDA de Mistral.rs évitent les frais du GIL Python et les pauses de collecte de déchets qui pénalisent les serveurs Python. Un RTX 3090 exécutant Mistral 7B Q4\_K\_M fournit \~\~120 tok/s — comparable à vLLM sur le même matériel pour une fraction du coût (\~\~0,12 $/h contre les fournisseurs cloud facturant 1–2 $/h). **Décodage spéculatif :** Associez un grand modèle (34B) à un petit modèle draft (3B) pour un gain de 2–3× sans perte de qualité. Le RTX 4090 est idéal pour ce schéma. *** ## Ressources * 🐙 **GitHub :** [github.com/EricLBuehler/mistral.rs](https://github.com/EricLBuehler/mistral.rs) * 📦 **Registre de conteneurs :** [ghcr.io/ericlbuehler/mistral.rs](https://ghcr.io/ericlbuehler/mistral.rs) * 📚 **Documentation :** [ericlbuehler.github.io/mistral.rs](https://ericlbuehler.github.io/mistral.rs/mistralrs/) * 💬 **Discord :** [discord.gg/SZrecqK8qw](https://discord.gg/SZrecqK8qw) * 🤗 **Modèles GGUF :** [huggingface.co/TheBloke](https://huggingface.co/TheBloke) --- # Agent Instructions: 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: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/mistral-rs.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.