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

ADK-Rust adk-model crate के माध्यम से कई cloud LLM प्रदाताओं का समर्थन करता है। सभी प्रदाता Llm trait को implement करते हैं, जिससे वे आपके agents में परस्पर विनिमेय हो जाते हैं।

अवलोकन

┌─────────────────────────────────────────────────────────────────────┐
│                     Cloud Model Providers                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   • Gemini (Google)    ⭐ Default    - Multimodal, large context    │
│   • OpenAI (GPT-5)    🔥 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                                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

त्वरित तुलना

---

चरण 1: स्थापना

अपने Cargo.toml में आवश्यक providers जोड़ें:

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

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

चरण 2: अपना API key सेट करें

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

Schema Normalization

प्रत्येक provider request समय पर MCP tool schemas को स्वतः normalize करता है। आपको कुछ भी करने की आवश्यकता नहीं है — यह transparently काम करता है। लेकिन पर्दे के पीछे यह क्या होता है:

एडेप्टर को प्रोग्रामेटिक रूप से Llm trait के माध्यम से एक्सेस करें:

use adk_core::{Llm, SchemaAdapter};

let adapter = model.schema_adapter();
let normalized = adapter.normalize_schema(raw_schema);

पूर्ण दस्तावेज़ीकरण के लिए Schema Normalization देखें।

---

Gemini (Google) ⭐ डिफ़ॉल्ट

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

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

• 🖼️ मूलभूत मल्टीमॉडल (छवियाँ, वीडियो, ऑडियो, PDF)
• 📚 2M टोकन तक का संदर्भ विंडो
• 🧠 थिंकिंग मोड: स्तर-आधारित (Gemini 3) और बजट-आधारित (Gemini 2.5) थॉट सिग्नेचर्स के साथ
• 💰 प्रतिस्पर्धी मूल्य निर्धारण
• ⚡ तेज़ इन्फ़रेंस

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

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.5-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 3 मॉडल स्तर-आधारित थिंकिंग का समर्थन करते हैं, जबकि Gemini 2.5 बजट-आधारित थिंकिंग का उपयोग करता है। फ़ंक्शन कॉलिंग के साथ थिंकिंग मोड का उपयोग करते समय, Gemini 2.5+ और 3.x मॉडल thoughtSignature मान लौटाते हैं, जिन्हें तर्क संदर्भ को बनाए रखने के लिए बाद के टर्न्स में वापस echo करना होता है। ADK-Rust इसे स्वचालित रूप से संभालता है — signatures मौजूद होने पर serialized होते हैं और None होने पर छोड़े जाते हैं।

use adk_gemini::{Gemini, ThinkingLevel};

// Gemini 3: level-based thinking
let response = client.generate_content()
    .with_user_message("Solve this step by step")
    .with_thinking_level(ThinkingLevel::High)
    .with_thoughts_included(true)
    .execute().await?;

// Gemini 2.5: budget-based thinking
let response = client.generate_content()
    .with_user_message("Solve this step by step")
    .with_thinking_budget(2048)
    .with_thoughts_included(true)
    .execute().await?;

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

👤 User: What's in this image? [uploads photo of a cat]

🤖 Gemini: I can see a fluffy orange tabby cat sitting on a windowsill. 
The cat appears to be looking outside, with sunlight illuminating its fur. 
It has green eyes and distinctive striped markings typical of tabby cats.

---

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

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

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

• 🏆 उद्योग मानक
• 🔧 उत्कृष्ट tool/function calling
• 📖 सर्वोत्तम दस्तावेज़ीकरण और ecosystem
• 🎯 सुसंगत, पूर्वानुमेय outputs
• 📋 JSON schema enforcement के साथ Structured output
• 🧠 o1/o3 reasoning models के लिए Reasoning effort नियंत्रण
• 🆕 Responses API — /v1/responses के लिए समर्पित client, reasoning summaries, built-in tools, और server-side state के साथ

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

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-5-mini"))?;

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

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

Structured Output (JSON Schema)

OpenAI, output_schema के माध्यम से guaranteed JSON output का समर्थन करता है। ADK-Rust इसे स्वचालित रूप से OpenAI के response_format API से जोड़ता है:

use adk_rust::prelude::*;
use serde_json::json;
use std::sync::Arc;

let model = OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-5-mini"))?;

let agent = LlmAgentBuilder::new("data_extractor")
    .model(Arc::new(model))
    .instruction("Extract person information from the text.")
    .output_schema(json!({
        "type": "object",
        "properties": {
            "name": { "type": "string" },
            "age": { "type": "number" },
            "email": { "type": "string" }
        },
        "required": ["name", "age"]
    }))
    .build()?;

// Response is guaranteed to be valid JSON matching the schema

Nested objects के साथ strict mode के लिए, प्रत्येक level पर additionalProperties: false शामिल करें:

.output_schema(json!({
    "type": "object",
    "properties": {
        "title": { "type": "string" },
        "metadata": {
            "type": "object",
            "properties": {
                "author": { "type": "string" },
                "tags": { "type": "array", "items": { "type": "string" } }
            },
            "required": ["author"],
            "additionalProperties": false  // Required for nested objects
        }
    },
    "required": ["title", "metadata"],
    "additionalProperties": false  // Auto-injected at root level
}))

Reasoning Effort (o1, o3 Models)

OpenAI reasoning models के लिए, नियंत्रित करें कि मॉडल कितना reasoning effort लागू करता है:

use adk_model::openai::{OpenAIClient, OpenAIConfig, ReasoningEffort};

let config = OpenAIConfig::new(&api_key, "o3-mini")
    .with_reasoning_effort(ReasoningEffort::High);
let model = OpenAIClient::new(config)?;

उपलब्ध स्तर: Low, Medium, High। अधिक effort, latency और tokens की कीमत पर, अधिक गहन reasoning उत्पन्न करता है।

OpenAI-संगत स्थानीय APIs

स्थानीय servers (Ollama, vLLM, LM Studio) से कनेक्ट करने के लिए OpenAIConfig::compatible() का उपयोग करें:

// Ollama exposes OpenAI-compatible API at /v1
let config = OpenAIConfig::compatible(
    "not-needed",                      // API key (ignored by Ollama)
    "http://localhost:11434/v1",       // Base URL
    "llama3.2"                         // Model name
);
let model = OpenAIClient::new(config)?;

नोट: Structured output (output_schema) के लिए backend support आवश्यक है। Native OpenAI इसका पूर्ण समर्थन करता है; स्थानीय servers में सीमित support हो सकता है।

Gemini via the OpenAI-Compatible Endpoint

Gemini models तक OpenAI Chat Completions wire format के माध्यम से https://generativelanguage.googleapis.com/v1beta/openai पर पहुँचा जा सकता है। OpenAICompatibleConfig::gemini(...) preset (openai feature के अंतर्गत) के साथ GEMINI_API_KEY का उपयोग करके Gemini को उसी OpenAI-compatible client के माध्यम से चलाएँ जिसे आप हर अन्य provider के लिए उपयोग करते हैं:

use adk_model::openai_compatible::{OpenAICompatible, OpenAICompatibleConfig};

let api_key = std::env::var("GEMINI_API_KEY")?;
let model = OpenAICompatible::new(
    OpenAICompatibleConfig::gemini(api_key, "gemini-3.5-flash"),
)?;

यह path chat, streaming, function calling, structured output, और reasoning effort का समर्थन करता है (OpenAI का reasoning_effort Gemini thinking levels/budgets से map होता है)। Gemini-विशिष्ट विकल्प — जैसे thinking_config के साथ include_thoughts, या cached_content — request के extensions["openai"]["extra_body"]["google"] map के माध्यम से pass किए जाते हैं, जिसे client verbatim request body में merge करता है।

इसे GeminiModel के बजाय कब उपयोग करें: native Gemini features (server-side tools, Interactions API, native ThinkingConfig, multimodal-first ergonomics) के लिए GeminiModel को प्राथमिकता दें। जब आप providers के बीच एक ही uniform client चाहते हों, तब OpenAI-compatible preset का उपयोग करें।

उदाहरण (GEMINI_API_KEY या GOOGLE_API_KEY आवश्यक हैं):

# Direct client: chat, reasoning effort, extra_body thinking, streaming,
# function calling, structured output.
cargo run -p adk-model --features openai --example gemini_openai_compat

# The same compat client driving a normal LlmAgent in a Runner.
# (Lives in adk-agent: it exercises the agent layer, which sits above adk-model.)
cargo run -p adk-agent --example gemini_openai_compat_agent

Reasoning Effort (o1, o3 Models)

ReasoningEffort के साथ नियंत्रित करें कि मॉडल कितना reasoning effort लागू करता है:

use adk_model::openai::{OpenAIClient, OpenAIConfig, ReasoningEffort};

let config = OpenAIConfig::new(&api_key, "o3-mini")
    .with_reasoning_effort(ReasoningEffort::High);
let model = OpenAIClient::new(config)?;

उपलब्ध स्तर: Low (सबसे तेज़), Medium (संतुलित), High (सबसे गहन)।

उपलब्ध मॉडल

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

👤 User: Write a haiku about Rust programming

🤖 GPT-5: Memory so safe,
Ownership guards every byte—
Compiler, my friend.

---

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-6"))?;

    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 💭 Thinking

के लिए सर्वोत्तम: जटिल समस्या-समाधान, गणित, कोडिंग, तर्क कार्य

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

• 💭 Thinking mode - chain-of-thought reasoning दिखाता है
• 💰 बहुत किफायती (GPT-4 से 10x सस्ता)
• 🔄 दोहराए जाने वाले prefixes के लिए context caching
• 🧮 गणित और कोडिंग में मजबूत

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

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

उपलब्ध मॉडल्स

उदाहरण आउटपुट (थिंकिंग मोड के साथ Reasoner)

👤 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 ⚡ अति-तेज़

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

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

• ⚡ सबसे तेज़ inference - प्रतिस्पर्धियों से 10x तेज़
• 🔧 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(())
}

उपलब्ध मॉडल

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

👤 User: Quick! Name 5 programming languages

🤖 Groq (in 0.2 seconds): 
1. Rust
2. Python
3. JavaScript
4. Go
5. TypeScript

---

प्रदाताओं को बदलना

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

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

// Just change the model - everything else stays the same!
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // Pick one:
    // GeminiModel::new(&api_key, "gemini-2.5-flash")?
    // OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-5-mini"))?
    // AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-4-6"))?
    // DeepSeekClient::chat(&api_key)?
    // GroqClient::llama70b(&api_key)?
);

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

---

उदाहरण

सत्यापित 0.8 dependencies के साथ provider-specific projects generate करने के लिए cargo-adk का उपयोग करें:

cargo adk new gemini_agent --provider gemini
cargo adk new openai_agent --template openai
cargo adk new anthropic_agent --provider anthropic

जनरेट किए गए प्रोजेक्ट CI में scripts/check-cargo-adk-templates.sh द्वारा संकलित किए जाते हैं। पूरी उदाहरण गैलरी इस साइट में शामिल ADK-Rust Playground में देखी और चलाई जा सकती है।

---

संबंधित

• Ollama (Local) - Ollama के साथ models को local रूप से चलाएँ
• Local Models (mistral.rs) - Native Rust inference
• LlmAgent - agents के साथ models का उपयोग
• Function Tools - agents में tools जोड़ना

---

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

जब कोई provider सामग्री को ले नहीं सकता, तो क्या होता है

Content किसी भी single provider transport द्वारा स्वीकार की जाने वाली मात्रा से अधिक व्यक्त कर सकता है, इसलिए प्रत्येक adapter को बाकी बचे हिस्से के साथ क्या करना है, यह तय करना होता है। अब उन निर्णयों को invisibly लागू करने के बजाय रिकॉर्ड किया जाता है। हर भाग को वर्गीकृत किया जाता है:

डाउनग्रेड और चूकें दर्ज होते ही tracing चेतावनी जारी करते हैं, जिसमें भाग का प्रकार, MIME प्रकार, और कारण बताया जाता है, ताकि इनमें से कोई भी मौन न रहे।

अनुरोध भेजने से पहले परिणाम देखने के लिए:

use adk_core::{Content, Part};
use adk_model::bedrock::convert::report_for_contents;

let content = Content {
    role: "user".to_string(),
    parts: vec![Part::inline_data("audio/wav", vec![0u8; 16])],
};
let report = report_for_contents(std::slice::from_ref(&content));

for omission in report.omitted_parts() {
    println!("{} was dropped: {}", omission.kind, omission.detail);
}

ऐसा अनुरोध अस्वीकार करने के लिए जो मॉडल तक अधूरा पहुँचे, बजाय इसके कि ऐसी सामग्री के बारे में उत्तर मिले जिसे मॉडल ने कभी देखा ही नहीं:

use adk_core::{Content, Part};
use adk_model::bedrock::convert::report_for_contents;

let content = Content {
    role: "user".to_string(),
    parts: vec![Part::inline_data("video/mp4", vec![0u8; 16])],
};

if let Some(error) = report_for_contents(std::slice::from_ref(&content)).into_error() {
    return Err(error);
}

into_error केवल चूकों को कवर करता है। एक डाउनग्रेड फिर भी मॉडल तक पहुँचता है, और उसे अस्वीकार करना दस्तावेज़ित पाठ्य फ़ॉलबैक को अस्वीकार कर देगा।

नोट: लेज़र निर्माण के अनुसार पूर्ण है। कोई भी भाग जो किसी एडाप्टर को बिना दर्ज किए गए परिणाम के छोड़ता है — जिसमें भविष्य के परिवर्तन से जोड़ा गया भाग भी शामिल है — उसे "कोई दर्ज कारण नहीं" के स्पष्ट उल्लेख के साथ चूक के रूप में दर्ज किया जाता है, और adk-model/tests/part_conversion_matrix_tests.rs उस पर विफल होता है।

Bedrock Converse कवरेज