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 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 :

# 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

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

# Vérifier le binaire mistral.rs
mistralrs-server --help

---

Exécution du serveur

Démarrage rapide avec un modèle GGUF

# 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)

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 :

# 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

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

Décodage spéculatif

# 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

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.

---

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

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/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

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

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

# 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

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

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.

---

Fonctionnalités avancées

X-LoRA (Mélange d'adaptateurs LoRA)

Exécuter plusieurs adaptateurs fine-tunés sélectionnés dynamiquement par token :

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

# 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

# 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

# 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

# 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

# Surveiller l'utilisation du GPU pendant l'inférence
watch -n 1 nvidia-smi

# Profiler avec 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:

---

Compilation depuis les sources

Si l'image Docker ne correspond pas à votre version de CUDA :

# 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

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

---

Dépannage

Bibliothèque CUDA introuvable

# 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

# 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é

# Trouver et tuer le processus
fuser -k 8080/tcp

# Utiliser un port différent
mistralrs-server --port 9090 ...

Mémoire insuffisante pendant la quantification

# 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

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.

---

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

• 📦 Registre de conteneurs : ghcr.io/ericlbuehler/mistral.rs

• 📚 Documentation : ericlbuehler.github.io/mistral.rs

• 💬 Discord : discord.gg/SZrecqK8qw

• 🤗 Modèles GGUF : huggingface.co/TheBloke