Intégration de mistral.rs

Exécutez LLMs localement avec l’inférence Rust native — sans serveurs externes ni clés API.

---

Qu’est-ce que mistral.rs ?

mistral.rs est un moteur d’inférence Rust haute performance qui exécute directement LLMs sur votre matériel. ADK-Rust l’intègre via le crate adk-mistralrs, épinglé à la version v0.8.0, avec la prise en charge de Gemma 4.

Points forts :

• 🦀 Rust natif — Pas de Python ni de serveurs externes
• 🔒 Entièrement hors ligne — Aucune clé API ni connexion Internet requise
• ⚡ Accélération matérielle — CUDA, Metal (bfloat16 3.1), optimisations CPU
• 📦 Quantification — ISQ, MXFP4, GGUF, UQFF pour exécuter de grands modèles sur du matériel limité
• 🔧 Adaptateurs LoRA — Prise en charge des modèles ajustés avec changement à chaud
• 👁️ Multimodal — Compréhension de la vision, de l’audio et de la vidéo (Gemma 4, Qwen 3 VL)
• 🎤 Parole — Reconnaissance vocale en temps réel avec Voxtral
• 🎯 Multi-modèles — Servir plusieurs modèles depuis une seule instance

---

Étape 1 : Ajouter les dépendances

adk-mistralrs est publié sur crates.io en tant que membre de l’espace de travail. Ajoutez-le comme dépendance standard :

[package]
name = "my-local-agent"
version = "0.1.0"
edition = "2024"

[dependencies]
adk-mistralrs = "2.1.0"
adk-agent = "2.1.0"
adk-rust = "2.1.0"
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"

Pour l’accélération matérielle, ajoutez des indicateurs de fonctionnalité :

# macOS with Apple Silicon
adk-mistralrs = { version = "2.1.0", features = ["metal"] }

# NVIDIA GPU (requires CUDA toolkit)
adk-mistralrs = { version = "2.1.0", features = ["cuda"] }

---

Étape 2 : Exemple de base

Chargez un modèle depuis HuggingFace et exécutez-le localement :

use adk_agent::LlmAgentBuilder;
use adk_mistralrs::{Llm, MistralRsConfig, MistralRsModel, ModelSource};
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Load model from HuggingFace (downloads on first run)
    let config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("microsoft/Phi-3.5-mini-instruct"))
        .build();

    println!("Loading model (this may take a while on first run)...");
    let model = MistralRsModel::new(config).await?;
    println!("Model loaded: {}", model.name());

    // Create agent
    let agent = LlmAgentBuilder::new("local_assistant")
        .description("Local AI assistant powered by mistral.rs")
        .instruction("You are a helpful assistant running locally. Be concise.")
        .model(Arc::new(model))
        .build()?;

    // Run interactive chat
    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

Ce qui se passe :

1. La première exécution télécharge le modèle depuis HuggingFace (environ 2 à 8 Go selon le modèle)
2. Le modèle est mis en cache localement dans ~/.cache/huggingface/
3. Les exécutions suivantes chargent instantanément le modèle depuis le cache

---

Étape 3 : Réduire la mémoire avec la quantification

Les grands modèles nécessitent beaucoup de RAM. Utilisez ISQ (quantification in situ) pour réduire l’utilisation mémoire :

use adk_agent::LlmAgentBuilder;
use adk_mistralrs::{Llm, MistralRsConfig, MistralRsModel, ModelSource, QuantizationLevel};
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Load model with 4-bit quantization for reduced memory
    let config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("microsoft/Phi-3.5-mini-instruct"))
        .isq(QuantizationLevel::Q4_0) // 4-bit quantization
        .paged_attention(true) // Memory-efficient attention
        .build();

    println!("Loading quantized model...");
    let model = MistralRsModel::new(config).await?;
    println!("Model loaded: {}", model.name());

    let agent = LlmAgentBuilder::new("quantized_assistant")
        .instruction("You are a helpful assistant. Be concise.")
        .model(Arc::new(model))
        .build()?;

    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

Niveaux de quantification :

---

Étape 4 : LoRA Adaptateurs (modèles affinés)

Chargez des modèles avec des adaptateurs LoRA pour des tâches spécialisées :

use adk_agent::LlmAgentBuilder;
use adk_mistralrs::{AdapterConfig, Llm, MistralRsAdapterModel, MistralRsConfig, ModelSource};
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Load base model with LoRA adapter
    let config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("meta-llama/Llama-3.2-3B-Instruct"))
        .adapter(AdapterConfig::lora("username/my-lora-adapter"))
        .build();

    println!("Loading model with LoRA adapter...");
    let model = MistralRsAdapterModel::new(config).await?;
    println!("Model loaded: {}", model.name());
    println!("Available adapters: {:?}", model.available_adapters());

    let agent = LlmAgentBuilder::new("lora_assistant")
        .instruction("You are a helpful assistant with specialized knowledge.")
        .model(Arc::new(model))
        .build()?;

    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

Échangez les adaptateurs à chaud lors de l’exécution :

model.swap_adapter("another-adapter").await?;

---

Étape 5 : Modèles de vision (compréhension des images)

Traitez les images avec des modèles vision-langage :

use adk_mistralrs::{Llm, MistralRsConfig, MistralRsVisionModel, ModelSource};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("microsoft/Phi-3.5-vision-instruct"))
        .build();

    println!("Loading vision model...");
    let model = MistralRsVisionModel::new(config).await?;
    println!("Model loaded: {}", model.name());

    // Analyze an image
    let image = image::open("photo.jpg")?;
    let response = model.generate_with_image("Describe this image.", vec![image]).await?;

    Ok(())
}

---

Étape 6 : Service multi-modèles

Servez plusieurs modèles depuis une seule instance :

use adk_mistralrs::{MistralRsConfig, MistralRsMultiModel, ModelSource};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let multi = MistralRsMultiModel::new();

    // Add models
    let phi_config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("microsoft/Phi-3.5-mini-instruct"))
        .build();
    multi.add_model("phi", phi_config).await?;

    let gemma_config = MistralRsConfig::builder()
        .model_source(ModelSource::huggingface("google/gemma-2-2b-it"))
        .build();
    multi.add_model("gemma", gemma_config).await?;

    // Set default and route requests
    multi.set_default("phi").await?;
    println!("Available models: {:?}", multi.model_names().await);

    // Route to specific model
    // multi.generate_with_model(Some("gemma"), request, false).await?;

    Ok(())
}

---

Sources des modèles

Hub HuggingFace (par défaut)

ModelSource::huggingface("microsoft/Phi-3.5-mini-instruct")

Répertoire local

ModelSource::local("/path/to/model")

GGUF pré-quantifié

ModelSource::gguf("/path/to/model.Q4_K_M.gguf")

---

Modèles recommandés

---

Accélération matérielle

macOS (Apple Silicon)

adk-mistralrs = { version = "2.1.0", features = ["metal"] }

L’accélération Metal est automatique sur les Mac M1/M2/M3.

GPU NVIDIA

adk-mistralrs = { version = "2.1.0", features = ["cuda"] }

Nécessite le toolkit CUDA 11.8 ou version ultérieure.

CPU uniquement

Aucune fonctionnalité requise : le CPU est utilisé par défaut.

---

Valider le crate

cargo build -p adk-mistralrs
cargo build -p adk-mistralrs --features metal

---

Résolution des problèmes

Mémoire insuffisante

// Enable quantization
.isq(QuantizationLevel::Q4_0)
// Enable paged attention
.paged_attention(true)

Premier chargement lent

• La première exécution télécharge le modèle (environ 2 à 8 Go)
• Les exécutions suivantes utilisent le modèle mis en cache

Modèle introuvable

• Vérifiez que l’identifiant du modèle HuggingFace est correct
• Assurez-vous de disposer d’une connexion Internet pour le premier téléchargement

---

Articles associés

• Fournisseurs de modèles - Fournisseurs de modèles LLM cloud
• Ollama - Serveur de modèles local alternatif
• LlmAgent - Utiliser des modèles avec des agents

---

Précédent : ← Ollama (local) | Suivant : Outils de fonction →