> 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-fr/modeles-de-langage/mistral-rs.md).

# 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](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 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 :**

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

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

```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 chargement — aucun modèle préquantifié n'est 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 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
```

{% hint style="success" %}
**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.
{% endhint %}

***

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

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

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

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

{% hint style="info" %}
**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.
{% endhint %}

***

## Fonctionnalités avancées

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

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

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

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

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

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

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

```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 à partir des 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 la prise en charge 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. 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`
{% 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 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é

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

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

### Mémoire insuffisante pendant la quantification

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

{% hint style="danger" %}
**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.
{% endhint %}

***

## 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](https://clore.ai/bare-metal) | Service de production 34B–70B Q4                       | \~160 tok/s           |
| A100 80 Go | 80 Go | [bare metal](https://clore.ai/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](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
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-fr/modeles-de-langage/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.