mistral.rs एकीकरण

LLMs को नेटिव Rust अनुमान के साथ स्थानीय रूप से चलाएँ - कोई बाहरी सर्वर नहीं, कोई API कुंजी नहीं।

---

mistral.rs क्या है?

mistral.rs एक उच्च-प्रदर्शन वाला Rust अनुमान इंजन है जो LLMs को सीधे आपके हार्डवेयर पर चलाता है। ADK-Rust इसे adk-mistralrs क्रेट के माध्यम से एकीकृत करता है, जो Gemma 4 समर्थन के साथ v0.8.0 पर पिन किया गया है।

मुख्य विशेषताएँ:

• 🦀 नेटिव Rust - कोई Python नहीं, कोई बाहरी सर्वर नहीं
• 🔒 पूरी तरह से ऑफ़लाइन - कोई API कुंजी या इंटरनेट की आवश्यकता नहीं
• ⚡ हार्डवेयर त्वरण - CUDA, Metal (3.1 bfloat16), CPU अनुकूलन
• 📦 क्वांटिज़ेशन - सीमित हार्डवेयर पर बड़े मॉडल चलाने के लिए ISQ, MXFP4, GGUF, UQFF
• 🔧 LoRA एडेप्टर - हॉट-स्वैपिंग के साथ फाइन-ट्यून किए गए मॉडल का समर्थन
• 👁️ मल्टीमॉडल - विजन, ऑडियो और वीडियो समझ (Gemma 4, Qwen 3 VL)
• 🎤 स्पीच - Voxtral रीयल-टाइम स्पीच रिकॉग्निशन
• 🎯 मल्टी-मॉडल - एक ही इंस्टेंस से कई मॉडल सर्व करें

---

चरण 1: निर्भरताएँ जोड़ें

adk-mistralrs को crates.io पर एक वर्कस्पेस सदस्य के रूप में प्रकाशित किया गया है। इसे एक मानक निर्भरता के रूप में जोड़ें:

[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"

हार्डवेयर त्वरण के लिए, फ़ीचर फ़्लैग जोड़ें:

# 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"] }

---

चरण 2: मूल उदाहरण

HuggingFace से एक मॉडल लोड करें और इसे स्थानीय रूप से चलाएँ:

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

क्या होता है:

1. पहली बार चलाने पर HuggingFace से मॉडल डाउनलोड होता है (मॉडल के आधार पर ~2-8GB)
2. मॉडल को ~/.cache/huggingface/ में स्थानीय रूप से कैश किया जाता है
3. बाद के रन तुरंत कैश से लोड होते हैं

---

चरण 3: क्वांटिज़ेशन के साथ मेमोरी कम करें

बड़े मॉडल को बहुत सारी RAM की आवश्यकता होती है। मेमोरी कम करने के लिए ISQ (In-Situ Quantization) का उपयोग करें:

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

क्वांटिज़ेशन स्तर:

चरण 4: LoRA अडैप्टर (फाइन-ट्यून किए गए मॉडल)

विशेष कार्यों के लिए LoRA अडैप्टर के साथ मॉडल लोड करें:

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

रनटाइम पर अडैप्टर को हॉट-स्वैप करें:

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

---

चरण 5: विजन मॉडल (छवि समझ)

विजन-लैंग्वेज मॉडल के साथ छवियों को प्रोसेस करें:

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

---

चरण 6: मल्टी-मॉडल सर्विंग

एक ही इंस्टेंस से कई मॉडल सर्व करें:

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

---

मॉडल स्रोत

HuggingFace हब (डिफ़ॉल्ट)

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

स्थानीय डायरेक्टरी

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

प्री-क्वांटाइज़्ड GGUF

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

---

अनुशंसित मॉडल

---

हार्डवेयर त्वरण

macOS (एप्पल सिलिकॉन)

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

M1/M2/M3 मैक पर मेटल त्वरण स्वचालित होता है।

NVIDIA GPU

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

CUDA टूलकिट 11.8+ की आवश्यकता है।

केवल CPU

किसी सुविधा की आवश्यकता नहीं है - CPU डिफ़ॉल्ट है।

---

क्रेट को मान्य करें

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

---

समस्या निवारण

मेमोरी से बाहर

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

धीमा पहला लोड

• पहली बार चलाने पर मॉडल डाउनलोड होता है (~2-8GB)
• बाद के रन कैश्ड मॉडल का उपयोग करते हैं

मॉडल नहीं मिला

• जांचें कि HuggingFace model ID सही है
• पहले डाउनलोड के लिए इंटरनेट कनेक्शन सुनिश्चित करें

---

संबंधित

• Model Providers - क्लाउड LLM प्रदाता
• Ollama - वैकल्पिक स्थानीय मॉडल सर्वर
• LlmAgent - एजेंटों के साथ मॉडल का उपयोग करना

---

पिछला: ← Ollama (स्थानीय) | अगला: Function Tools →