mistral.rs Integration

Führen Sie LLMs lokal mit nativer Rust-Inferenz aus - keine externen Server, keine API-Schlüssel.

---

Was ist mistral.rs?

mistral.rs ist eine hochleistungsfähige Rust-Inferenz-Engine, die LLMs direkt auf Ihrer Hardware ausführt. ADK-Rust integriert es über das adk-mistralrs crate, angeheftet an v0.8.0 mit Gemma 4 Unterstützung.

Wichtige Merkmale:

• 🦀 Native Rust - Kein Python, keine externen Server
• 🔒 Vollständig offline - Keine API-Schlüssel oder Internet erforderlich
• ⚡ Hardwarebeschleunigung - CUDA, Metal (3.1 bfloat16), CPU-Optimierungen
• 📦 Quantisierung - ISQ, MXFP4, GGUF, UQFF zum Ausführen großer Modelle auf begrenzter Hardware
• 🔧 LoRA adapters - Unterstützung für feinabgestimmte Modelle mit Hot-Swapping
• 👁️ Multimodal - Verständnis von Vision, Audio und Video (Gemma 4, Qwen 3 VL)
• 🎤 Sprache - Voxtral Echtzeit-Spracherkennung
• 🎯 Multi-Modell - Mehrere Modelle von einer Instanz aus bereitstellen

---

Schritt 1: Abhängigkeiten hinzufügen

adk-mistralrs wird als Workspace-Mitglied auf crates.io veröffentlicht. Fügen Sie es als Standardabhängigkeit hinzu:

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

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

Für Hardwarebeschleunigung fügen Sie Feature-Flags hinzu:

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

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

---

Schritt 2: Grundlegendes Beispiel

Laden Sie ein Modell von HuggingFace und führen Sie es lokal aus:

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(())
}

Was passiert:

1. Der erste Durchlauf lädt das Modell von HuggingFace herunter (~2-8 GB, je nach Modell)
2. Das Modell wird lokal in ~/.cache/huggingface/ zwischengespeichert.
3. Nachfolgende Durchläufe werden sofort aus dem Cache geladen.

---

Schritt 3: Speicherreduzierung durch Quantisierung

Große Modelle benötigen viel RAM. Verwenden Sie ISQ (In-Situ Quantization), um den Speicherbedarf zu reduzieren:

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(())
}

Quantisierungsstufen:

---

Schritt 4: LoRA-Adapter (Feinabgestimmte Modelle)

Laden Sie Modelle mit LoRA-Adaptern für spezialisierte Aufgaben:

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(())
}

Hot-Swap-Adapter zur Laufzeit:

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

---

Schritt 5: Visionsmodelle (Bildverständnis)

Bilder mit Visions-Sprachmodellen verarbeiten:

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(())
}

---

Schritt 6: Multi-Modell-Bereitstellung

Mehrere Modelle von einer einzigen Instanz aus bereitstellen:

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(())
}

---

Modellquellen

HuggingFace Hub (Standard)

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

Lokales Verzeichnis

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

Vorquantisiertes GGUF

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

---

Empfohlene Modelle

---

Hardware-Beschleunigung

macOS (Apple Silicon)

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

Metal-Beschleunigung ist auf M1/M2/M3 Macs automatisch.

NVIDIA GPU

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

Erfordert CUDA toolkit 11.8+.

Nur CPU

Keine Features erforderlich - CPU ist der Standard.

---

Crate validieren

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

---

Fehlerbehebung

Nicht genügend Arbeitsspeicher

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

Langsamer erster Ladevorgang

• Beim ersten Ausführen wird das Modell heruntergeladen (~2-8 GB)
• Bei späteren Ausführungen wird das zwischengespeicherte Modell verwendet

Modell nicht gefunden

• Überprüfen Sie, ob die HuggingFace-Modell-ID korrekt ist
• Stellen Sie sicher, dass eine Internetverbindung für den ersten Download besteht

---

Verwandtes

• Modellanbieter - Cloud LLM-Anbieter
• Ollama - Alternativer lokaler Modellserver
• LlmAgent - Verwendung von Modellen mit Agents

---

Zurück: ← Ollama (Lokal) | Weiter: Function Tools →