Mistral.rs

Inférence LLM ultra-rapide écrite en Rust — serveur prêt pour la production avec prise en charge de GGUF, GGML, SafeTensors et une API compatible OpenAI.

🦀 Conçu en Rust pour des performances maximales | prise en charge des modèles GGUF et 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. Initialement axé sur les modèles Mistral, il prend désormais en charge l'ensemble des LLM modernes. La base Rust offre :

• Abstractions sans coût — aucune pause de ramasse-miettes pendant l'inférence

• Sécurité mémoire — pas d'exceptions de pointeur nul ni de fuites mémoire

• Performances déterministes — latence constante sans surcharge JVM/Python

• Optimisations à la compilation — SIMD, threading et noyaux GPU optimisés à la compilation

Caractéristiques clés

• Prise en charge de GGUF — exécutez n'importe quel modèle quantifié (Q4_K_M, Q8_0, etc.)

• ISQ (quantification in situ) — quantification à la volée au chargement

• PagedAttention — cache KV efficace avec batching 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 brouillons

• X-LoRA — prise en charge évolutive des adaptateurs affinés

• API REST compatible avec 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 volumineux

• CUDA 11.8+ requis

Étape 2 : déployer le conteneur Docker Mistral.rs

Image Docker : ghcr.io/ericlbuehler/mistral.rs:cuda

Mappages de ports :

Port du conteneur	Objectif
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 uniquement
ghcr.io/ericlbuehler/mistral.rs:cpu

# Metal (Apple Silicon - pas pour Clore.ai)
ghcr.io/ericlbuehler/mistral.rs:metal

Étape 3 : se 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 chargement — aucun modèle préquantifié n'est 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 brouillon 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  # Jetons spéculatifs

Décodage spéculatif peut offrir une accélération de 2 à 3x pour la plupart des charges de travail conversationnelles où le petit modèle brouillon prédit avec précision les jetons suivants.

---

Utilisation de l’API

Points de terminaison compatibles avec 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 (VLM)
/v1/re_isq	POST	Requantifier le modèle chargé
/health	GET	Vérification de santé

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": "Vous êtes un assistant de codage utile."},
        {"role": "user", "content": "Écrivez une fonction Python pour inverser une liste chaînée"}
    ],
    temperature=0.1,  # Faible température 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 de base
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 santé
curl http://localhost:8080/health

---

Options de configuration

Options 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 jeton HuggingFace
  --max-seqs 16 \\                  # Nombre maximal de séquences simultanées
  --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 du 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.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	★★★★★	~8 Go
HQQ4	4	★★★★☆	~4.5GB
HQQ8	8	★★★★★	~8 Go

HQQ (quantification demi-quadratique) obtient souvent une meilleure qualité que GGUF Q4 au même niveau de bits, surtout pour les tâches de suivi d'instructions.

---

Fonctionnalités avancées

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

Exécute plusieurs adaptateurs affinés sélectionnés dynamiquement par jeton :

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

Requantifier à l'exécution

# Modifier 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 dans un fichier
mistralrs-server \\
  --port 8080 \
  --log info \\
  --request-logging-file ./requests.jsonl \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K

---

Réglage des performances

Optimiser pour le débit

# max-seqs plus élevé pour les requêtes simultanées
mistralrs-server \\
  --port 8080 \
  --max-seqs 32 \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K

Optimiser pour une faible latence

# max-seqs plus faible, 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 à partir des 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 la prise en charge CUDA
cargo build --release --features cuda

# Emplacement du binaire
./target/release/mistralrs-server --help

Temps de compilation : La compilation Rust est lente. Comptez 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 jeton 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

Le port 8080 est déjà utilisé

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

# Utiliser un autre port
mistralrs-server --port 9090 ...

Mémoire insuffisante pendant la quantification

# ISQ quantifie sur le GPU — réduisez d'abord l'utilisation du GPU par d'autres processus
# Ou passer à GGUF (préquantifié, pic mémoire plus faible)
mistralrs-server \\
  gguf \\
  -m TheBloke/Llama-2-7B-Chat-GGUF \\
  -f llama-2-7b-chat.Q4_K_M.gguf

ISQ contre GGUF : ISQ quantifie au chargement en utilisant la mémoire GPU (pic temporaire). Si votre VRAM est limitée, utilisez des fichiers GGUF préquantifiés de TheBloke ou similaires — ils utilisent un pic mémoire plus faible pendant le chargement.

---

Recommandations GPU Clore.ai

Mistral.rs est un moteur natif Rust — sa faible surcharge signifie plus de débit par dollar de GPU qu'avec des serveurs basés sur Python.

GPU	VRAM	Prix Clore.ai	Utilisation recommandée	Débit (Mistral 7B Q4)
RTX 3090	24 Go	0,07–0,21 $/h	Meilleure option économique — 7B Q4/Q8, modèles vision	~120 tok/s
RTX 4090	24 Go	0,14–0,42 $/h	Débit élevé 7B–34B, décodage spéculatif	~200 tok/s
A100 40 Go	40 Go	bare metal	Service de production 34B–70B Q4	~160 tok/s
A100 80 Go	80 Go	bare metal	70B en précision complète, multi-modèle	~185 tok/s

Pourquoi la RTX 3090 excelle ici : Les noyaux Rust CUDA de Mistral.rs évitent la surcharge du GIL Python et les pauses de ramasse-miettes qui pénalisent les serveurs Python. Une RTX 3090 exécutant Mistral 7B Q4_K_M délivre environ ~120 tok/s — comparable à vLLM sur le même matériel pour une fraction du coût ($0.07–0.21/hr vs les fournisseurs cloud facturant $0.07–0.21/hr).

Décodage spéculatif : Associez un grand modèle (34B) à un petit modèle brouillon (3B) pour une accélération de 2 à 3× sans perte de qualité. La RTX 4090 est idéale 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