Mistral.rs

Blitzschnelle LLM-Inferenz in Rust geschrieben — produktionsreifer Server mit GGUF-, GGML-, SafeTensors-Unterstützung und OpenAI-kompatibler API.

🦀 In Rust entwickelt für maximale Leistung | GGUF- & Vision-Modellunterstützung | Apache-2.0-Lizenz

---

Was ist Mistral.rs?

Mistral.rs ist eine leistungsstarke LLM-Inferenz-Engine, die vollständig in Rustgeschrieben ist. Ursprünglich auf Mistral-Modelle ausgerichtet, unterstützt sie jetzt die gesamte Landschaft moderner LLMs. Das Rust-Ökosystem bietet:

• Kostenlose Abstraktionen — keine Garbage-Collection-Pausen während der Inferenz

• Speichersicherheit — keine Nullzeiger-Ausnahmen oder Speicherlecks

• Deterministische Leistung — konsistente Latenz ohne JVM-/Python-Overhead

• Kompilierungszeit-Optimierungen — SIMD-, Threading- und GPU-Kerne zur Build-Zeit optimiert

Hauptfunktionen

• GGUF-Unterstützung — führe jedes quantisierte Modell aus (Q4_K_M, Q8_0, usw.)

• ISQ (In-Situ-Quantisierung) — quantisiere on-the-fly beim Laden

• PagedAttention — effizienter KV-Cache mit kontinuierlichem Batching

• Vision Language Models — LLaVA-, Phi-3 Vision-, Idefics-Unterstützung

• Spekulatives Decoding — schnellere Inferenz mit Draft-Modellen

• X-LoRA — skalierbare Unterstützung für feinabgestimmte Adapter

• OpenAI-kompatible REST-API — Drop-in-Ersatz

Unterstützte Modellfamilien

Familie	Format	Engine
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

---

Schnellstart auf Clore.ai

Schritt 1: Finden Sie einen GPU-Server

Auf clore.ai Marktplatz:

• Minimum: 8GB VRAM (für 7B Q4-Modelle)

• Empfohlen: RTX 3090/4090 (24GB) für größere Modelle

• CUDA 11.8+ erforderlich

Schritt 2: Mistral.rs Docker bereitstellen

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

Port-Mappings:

Container-Port	Zweck
22	SSH-Zugriff
8080	REST-API-Server

Verfügbare Image-Varianten:

# CUDA (die meisten Clore.ai-Server)
ghcr.io/ericlbuehler/mistral.rs:cuda

# Nur CPU
ghcr.io/ericlbuehler/mistral.rs:cpu

# Metal (Apple Silicon - nicht für Clore.ai)
ghcr.io/ericlbuehler/mistral.rs:metal

Schritt 3: Verbinden und Überprüfen

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

# Überprüfe die mistral.rs-Binärdatei
mistralrs-server --help

---

Den Server starten

Schnellstart mit GGUF-Modell

# Diene ein GGUF-Modell direkt von HuggingFace aus
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 bereitstellen (SafeTensors)

mistralrs-server \
  --port 8080 \
  plain \
  -m mistralai/Mistral-7B-Instruct-v0.3 \
  --isq Q4K

Mit In-Situ-Quantisierung (ISQ) bereitstellen

ISQ quantisiert das Modell zur Ladezeit — kein vorquantisiertes Modell erforderlich:

# Llama 3 8B laden und on-the-fly zu Q4K quantisieren
mistralrs-server \
  --port 8080 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

# Verfügbare ISQ-Optionen:
# Q4_0, Q4_1, Q5_0, Q5_1, Q8_0
# Q2K, Q3K, Q4K, Q5K, Q6K, Q8K
# HQQ4, HQQ8 (Half-Quadratic Quantization)

Vision Language Model

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

Spekulatives Decoding

# Verwende ein kleines Draft-Modell, um die Generierung zu beschleunigen
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  # Spekulative Tokens

Spekulatives Decoding kann eine 2–3× Beschleunigung für die meisten konversationellen Workloads bieten, bei denen das kleine Draft-Modell die nächsten Tokens genau vorhersagt.

---

API-Nutzung

OpenAI-kompatible Endpunkte

Endpunkt	Methode	Beschreibung
/v1/chat/completions	POST	Chat-Vervollständigungen
/v1/completions	POST	Textvervollständigungen
/v1/models	GET	Modelle auflisten
/v1/images/generations	POST	Bildgenerierung (VLMs)
/v1/re_isq	POST	Geladenes Modell re-quantisieren
/health	GET	Health-Check

Python-Beispiel

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # Standardmäßig keine Authentifizierung erforderlich
)

# Chat-Completion
response = client.chat.completions.create(
    model="llama-3-8b",  # Modellname ist flexibel
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Schreibe eine Python-Funktion, um eine einfach verkettete Liste umzukehren"}
    ],
    temperature=0.1,  # Niedrige Temperatur für Codegenerierung
    max_tokens=1024
)
print(response.choices[0].message.content)

Streaming-Antwort

with client.chat.completions.create(
    model="llama-3-8b",
    messages=[{"role": "user", "content": "Erzähl mir eine Geschichte über einen Roboter."}],
    stream=True,
    max_tokens=512
) als Stream:
    for chunk in stream:
        delta = chunk.choices[0].delta
        if hasattr(delta, 'content') and delta.content:
            print(delta.content, end="", flush=True)
print()

Vision-/Bild-Eingabe

import base64
from pathlib import Path

# Bild laden
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": "Was siehst du auf diesem Bild?"
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)

cURL-Beispiele

# Basis-Chat
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Was ist Rust?"}],
    "temperature": 0.7,
    "max_tokens": 256
  }'

# Modelle auflisten
curl http://localhost:8080/v1/models

# Health-Check
curl http://localhost:8080/health

---

Konfigurationsoptionen

Server-Flags

mistralrs-server \
  --port 8080 \                    # API-Port (Standard: 1234)
  --host 0.0.0.0 \                 # Bind-Adresse
  --log info \                     # Log-Level: off/error/warn/info/debug/trace
  --token-source env:HF_TOKEN \    # HuggingFace Token-Quelle
  --max-seqs 16 \                  # Maximale gleichzeitige Sequenzen
  --no-paged-attn \                # Deaktiviere PagedAttention (für Debugging verwenden)
  --prefix-cache-n 16 \            # Prefix-Cache-Einträge
  plain \                          # Modelltyp-Subbefehl
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

ISQ-Quantisierungsreferenz

ISQ-Option	Bits	Qualität	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

HQQ (Half-Quadratic Quantization) erzielt oft bessere Qualität als GGUF Q4 auf demselben Bit-Level, insbesondere bei auf Anweisungen folgenden Aufgaben.

---

Erweiterte Funktionen

X-LoRA (Mixture of LoRA Adapters)

Führe mehrere feinabgestimmte Adapter aus, die dynamisch pro Token ausgewählt werden:

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

Re-Quantisierung zur Laufzeit

# Quantisierung ändern, ohne neu zu starten
curl http://localhost:8080/v1/re_isq \
  -H "Content-Type: application/json" \
  -d '{"isq_type": "Q8_0"}'

Anfrageprotokollierung

# Anfrageprotokollierung in Datei aktivieren
mistralrs-server \
  --port 8080 \
  --log info \
  --request-logging-file ./requests.jsonl \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

---

Performance-Tuning

Für Durchsatz optimieren

# Höhere max-seqs für gleichzeitige Anfragen
mistralrs-server \
  --port 8080 \
  --max-seqs 32 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

Für niedrige Latenz optimieren

# Niedrigere max-seqs, Prefix-Cache-Sharing deaktivieren
mistralrs-server \
  --port 8080 \
  --max-seqs 4 \
  --prefix-cache-n 0 \
  plain \
  -m meta-llama/Meta-Llama-3-8B-Instruct \
  --isq Q4K

Leistung überwachen

# GPU-Auslastung während der Inferenz beobachten
watch -n 1 nvidia-smi

# Mit nvtop profilieren
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:

---

Vom Quellcode bauen

Falls das Docker-Image nicht zu deiner CUDA-Version passt:

# Rust installieren
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Klonen und bauen
git clone https://github.com/EricLBuehler/mistral.rs.git
cd mistral.rs

# Baue mit CUDA-Unterstützung
cargo build --release --features cuda

# Speicherort der Binärdatei
./target/release/mistralrs-server --help

Build-Zeit: Rust-Kompilierung ist langsam. Rechne mit 10–20 Minuten für einen kompletten Build. Verwende sccache um inkrementelle Builds zu beschleunigen: cargo install sccache && RUSTC_WRAPPER=sccache cargo build --release --features cuda

---

Fehlerbehebung

CUDA-Bibliothek nicht gefunden

# Überprüfe CUDA-Bibliotheken
ldconfig -p | grep libcuda
ls /usr/local/cuda/lib64/

# Bibliothekspfad setzen
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH

Modell-Download schlägt fehl

# HuggingFace-Token setzen
export HF_TOKEN=dein_token_hier

# Oder verwende das --token-source-Flag
mistralrs-server \
  --token-source env:HF_TOKEN \
  ...

# Oder zuerst manuell herunterladen
huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --local-dir ./llama3-8b
mistralrs-server ... plain -m ./llama3-8b --isq Q4K

Port 8080 in Benutzung

# Prozess finden und beenden
fuser -k 8080/tcp

# Anderen Port verwenden
mistralrs-server --port 9090 ...

Während der Quantisierung kein Speicher mehr

# ISQ quantisiert auf der GPU — reduziere zuerst andere GPU-Auslastung
# Oder wechsle zu GGUF (vorquantisiert, geringerer Spitzenverbrauch)
mistralrs-server \
  gguf \
  -m TheBloke/Llama-2-7B-Chat-GGUF \
  -f llama-2-7b-chat.Q4_K_M.gguf

ISQ vs GGUF: ISQ quantisiert zur Ladezeit unter Verwendung von GPU-Speicher (vorübergehender Spitzenverbrauch). Wenn du wenig VRAM hast, verwende vorquantisierte GGUF-Dateien von TheBloke oder ähnlichen — sie benötigen während des Ladens weniger Spitzenmemory.

---

Clore.ai GPU-Empfehlungen

Mistral.rs ist eine native Rust-Engine — ihr geringer Overhead bedeutet, dass du mehr Durchsatz pro GPU-Dollar im Vergleich zu Python-basierten Servern erhältst.

GPU	VRAM	Clore.ai-Preis	Empfohlene Verwendung	Durchsatz (Mistral 7B Q4)
RTX 3090	24 GB	~$0.12/Stunde	Beste Budget-Option — 7B Q4/Q8, Vision-Modelle	~120 tok/s
RTX 4090	24 GB	~$0.70/Stunde	Hoher Durchsatz 7B–34B, spekulatives Decoding	~200 tok/s
A100 40GB	40 GB	~$1.20/Stunde	Produktionsbetrieb 34B–70B Q4-Serving	~160 tok/s
A100 80GB	80 GB	~$2.00/Stunde	Volle Präzision 70B, Multi-Modell	~185 tok/s

Warum die RTX 3090 hier glänzt: Die Rust CUDA-Kerne von Mistral.rs vermeiden Python-GIL-Overhead und Garbage-Collection-Pausen, die Python-Server beeinträchtigen. Eine RTX 3090, die Mistral 7B Q4_K_M ausführt, liefert 120 tok/s — vergleichbar mit vLLM auf derselben Hardware zu einem Bruchteil der Kosten (0,12 $/Std. vs. Cloud-Anbieter, die 1–2 $/Std. berechnen).

Spekulatives Decoding: Kombiniere ein großes Modell (34B) mit einem kleinen Draft-Modell (3B) für 2–3× Beschleunigung ohne Qualitätsverlust. Die RTX 4090 ist ideal für dieses Muster.

---

Ressourcen

• 🐙 GitHub: github.com/EricLBuehler/mistral.rs

• 📦 Container-Registry: ghcr.io/ericlbuehler/mistral.rs

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

• 💬 Discord: discord.gg/SZrecqK8qw

• 🤗 GGUF-Modelle: huggingface.co/TheBloke