मॉडल प्रदाता (क्लाउड)

adk-rust adk-model क्रेट के माध्यम से कई क्लाउड LLM प्रदाताओं का समर्थन करता है। सभी प्रदाता Llm ट्रेट को लागू करते हैं, जिससे वे आपके agents में विनिमेय हो जाते हैं।

अवलोकन

┌─────────────────────────────────────────────────────────────────────┐
│                     Cloud Model Providers                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   • Gemini (Google)    ⭐ Default    - Multimodal, large context    │
│   • OpenAI (GPT-4o)    🔥 Popular    - Best ecosystem               │
│   • Anthropic (Claude) 🧠 Smart      - Best reasoning               │
│   • DeepSeek           💭 Thinking   - Chain-of-thought, cheap      │
│   • Groq               ⚡ Ultra-Fast  - Fastest inference           │
│                                                                     │
│   For local/offline models, see:                                    │
│   • Ollama     → ollama.md                                          │
│   • mistral.rs → mistralrs.md                                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

स्थानीय/ऑफ़लाइन मॉडलों के लिए, देखें: • Ollama → ollama.md • mistral.rs → mistralrs.md

त्वरित तुलना

---

चरण 1: इंस्टॉलेशन

अपनी Cargo.toml में आपको आवश्यक प्रदाताओं को जोड़ें:

[dependencies]
# Pick one or more providers:
adk-model = { version = "0.2", features = ["gemini"] }        # Google Gemini (default)
adk-model = { version = "0.2", features = ["openai"] }        # OpenAI GPT-4o
adk-model = { version = "0.2", features = ["anthropic"] }     # Anthropic Claude
adk-model = { version = "0.2", features = ["deepseek"] }      # DeepSeek
adk-model = { version = "0.2", features = ["groq"] }          # Groq (ultra-fast)

# Or all cloud providers at once:
adk-model = { version = "0.2", features = ["all-providers"] }

चरण 2: अपनी API कुंजी सेट करें

export GOOGLE_API_KEY="your-key"      # Gemini
export OPENAI_API_KEY="your-key"      # OpenAI
export ANTHROPIC_API_KEY="your-key"   # Anthropic
export DEEPSEEK_API_KEY="your-key"    # DeepSeek
export GROQ_API_KEY="your-key"        # Groq

---

जेमिनी (गूगल) ⭐ डिफ़ॉल्ट

इसके लिए सर्वश्रेष्ठ: सामान्य उद्देश्य, मल्टीमॉडल कार्य, बड़े दस्तावेज़

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

• 🖼️ नेटिव मल्टीमॉडल (छवियाँ, वीडियो, ऑडियो, PDF)
• 📚 2M टोकन तक कॉन्टेक्स्ट विंडो
• 💰 प्रतिस्पर्धी मूल्य निर्धारण
• ⚡ तीव्र अनुमान

पूर्ण कार्यशील उदाहरण

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.0-flash")?;

    let agent = LlmAgentBuilder::new("gemini_assistant")
        .description("Gemini-powered assistant")
        .instruction("You are a helpful assistant powered by Google Gemini. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

उपलब्ध मॉडल

उदाहरण आउटपुट

👤 उपयोगकर्ता: इस छवि में क्या है? [बिल्ली की तस्वीर अपलोड करता है]

🤖 Gemini: मुझे खिड़की के किनारे बैठी हुई एक रोएंदार नारंगी टैबी बिल्ली दिख रही है। 
बिल्ली बाहर देख रही है, जिसकी फर पर सूरज की रोशनी पड़ रही है। 
इसकी हरी आँखें और टैबी बिल्लियों के विशिष्ट धारीदार निशान हैं।

---

OpenAI (GPT-4o) 🔥 लोकप्रिय

इसके लिए सर्वश्रेष्ठ: प्रोडक्शन ऐप्स, विश्वसनीय प्रदर्शन, व्यापक क्षमताएं

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

• 🏆 उद्योग मानक
• 🔧 उत्कृष्ट टूल/फंक्शन कॉलिंग
• 📖 सर्वोत्तम दस्तावेज़ीकरण और इकोसिस्टम
• 🎯 सुसंगत, अनुमानित आउटपुट

पूर्ण कार्यशील उदाहरण

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("OPENAI_API_KEY")?;
    let model = OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-4o"))?;

    let agent = LlmAgentBuilder::new("openai_assistant")
        .description("OpenAI-powered assistant")
        .instruction("You are a helpful assistant powered by OpenAI GPT-4o. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

उपलब्ध मॉडल

उदाहरण आउटपुट

👤 उपयोगकर्ता: रस्ट प्रोग्रामिंग पर एक हाइकू लिखें

🤖 GPT-4o: स्मृति इतनी सुरक्षित,
हर बाइट की रक्षा ओनरशिप करे—
कंपाइलर, मेरे दोस्त।

---

Anthropic (Claude) 🧠 स्मार्ट

इसके लिए सबसे अच्छा: जटिल तर्क, सुरक्षा-महत्वपूर्ण ऐप्स, लंबे दस्तावेज़

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

• 🧠 असाधारण तर्क क्षमता
• 🛡️ सबसे अधिक सुरक्षा-केंद्रित
• 📚 200K टोकन संदर्भ
• ✍️ उत्कृष्ट लेखन गुणवत्ता

पूर्ण कार्यशील उदाहरण

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("ANTHROPIC_API_KEY")?;
    let model = AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-4-20250514"))?;

    let agent = LlmAgentBuilder::new("anthropic_assistant")
        .description("Anthropic-powered assistant")
        .instruction("You are a helpful assistant powered by Anthropic Claude. Be concise and thoughtful.")
        .model(Arc::new(model))
        .build()?;

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

उपलब्ध मॉडल

उदाहरण आउटपुट

👤 User: Explain quantum entanglement to a 10-year-old

🤖 Claude: Imagine you have two magic coins. When you flip them, they always 
land the same way - both heads or both tails - even if one coin is on Earth 
and the other is on the Moon! Scientists call this "entanglement." The coins 
are connected in a special way that we can't see, like invisible best friends 
who always make the same choice at the exact same time.

---

DeepSeek 💭 सोच

इसके लिए सबसे अच्छा: जटिल समस्या-समाधान, गणित, कोडिंग, तर्क संबंधी कार्य

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

• 💭 सोच मोड - विचारों की श्रृंखला का तर्क दिखाता है
• 💰 बहुत लागत प्रभावी (GPT-4 से 10 गुना सस्ता)
• 🔄 दोहराए गए प्रीफिक्स के लिए संदर्भ कैशिंग
• 🧮 गणित और कोडिंग में मजबूत

पूर्ण कार्यशील उदाहरण

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("DEEPSEEK_API_KEY")?;
    
    // Standard chat model
    let model = DeepSeekClient::chat(&api_key)?;
    
    // OR: Reasoning model with thinking mode
    // let model = DeepSeekClient::reasoner(&api_key)?;

    let agent = LlmAgentBuilder::new("deepseek_assistant")
        .description("DeepSeek-powered assistant")
        .instruction("You are a helpful assistant powered by DeepSeek. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

उपलब्ध मॉडल

उदाहरण आउटपुट (सोच मोड के साथ तर्ककर्ता)

👤 User: What's 17 × 23?

🤖 DeepSeek: <thinking>
Let me break this down:
17 × 23 = 17 × (20 + 3)
       = 17 × 20 + 17 × 3
       = 340 + 51
       = 391
</thinking>

The answer is 391.

Groq ⚡ अल्ट्रा-फ़ास्ट

इसके लिए सबसे अच्छा: रीयल-टाइम एप्लिकेशन, चैटबॉट, गति-महत्वपूर्ण कार्य

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

• ⚡ सबसे तेज़ इनफेरेंस - प्रतिस्पर्धियों से 10 गुना तेज़
• 🔧 LPU (Language Processing Unit) तकनीक
• 💰 प्रतिस्पर्धी मूल्य निर्धारण
• 🦙 LLaMA, Mixtral, Gemma models चलाता है

पूर्ण कार्यशील उदाहरण

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("GROQ_API_KEY")?;
    let model = GroqClient::llama70b(&api_key)?;

    let agent = LlmAgentBuilder::new("groq_assistant")
        .description("Groq-powered assistant")
        .instruction("You are a helpful assistant powered by Groq. Be concise and fast.")
        .model(Arc::new(model))
        .build()?;

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

उपलब्ध Models

उदाहरण आउटपुट

👤 उपयोगकर्ता: जल्दी! 5 प्रोग्रामिंग भाषाओं के नाम बताएं

🤖 Groq (0.2 सेकंड में): 
1. Rust
2. Python
3. JavaScript
4. Go
5. TypeScript

---

प्रोवाइडर्स बदलना

सभी प्रोवाइडर्स समान Llm trait लागू करते हैं, इसलिए स्विच करना आसान है:

use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

// बस model बदलें - बाकी सब वैसा ही रहता है!
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // एक चुनें:
    // GeminiModel::new(&api_key, "gemini-2.0-flash")?
    // OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-4o"))?
    // AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-4-20250514"))?
    // DeepSeekClient::chat(&api_key)?
    // GroqClient::llama70b(&api_key)?
);

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

---

उदाहरण

# Gemini (डिफ़ॉल्ट)
cargo run --example quickstart

# OpenAI
cargo run --example openai_basic --features openai

# Anthropic
cargo run --example anthropic_basic --features anthropic

# DeepSeek
cargo run --example deepseek_basic --features deepseek
cargo run --example deepseek_reasoner --features deepseek  # सोचने का मोड

# Groq
cargo run --example groq_basic --features groq

---

संबंधित

• Ollama (लोकल) - Ollama के साथ models को स्थानीय रूप से चलाएँ
• लोकल Models (mistral.rs) - नेटिव Rust इनफेरेंस
• LlmAgent - agents के साथ models का उपयोग करना
• FunctionTool - agents में tools जोड़ना

---

पिछला: ← Realtime Agents | अगला: Ollama (लोकल) →