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

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

अवलोकन

┌─────────────────────────────────────────────────────────────────────┐
│                     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 में आवश्यक प्रदाता जोड़ें:

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

# Or all cloud providers at once:
adk-model = { version = "2.1.0", 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

स्कीमा सामान्यीकरण

प्रत्येक प्रदाता अनुरोध के समय MCP टूल स्कीमा को स्वचालित रूप से सामान्यीकृत करता है। आपको कुछ भी करने की आवश्यकता नहीं है — यह पारदर्शी रूप से काम करता है। लेकिन पर्दे के पीछे यह होता है:

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

use adk_core::{Llm, SchemaAdapter};

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

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

---

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-3.7-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 मान लौटाते हैं, जिन्हें तर्क संदर्भ बनाए रखने के लिए बाद के टर्न में वापस भेजना आवश्यक है। ADK-Rust इसे स्वचालित रूप से संभालता है — हस्ताक्षर मौजूद होने पर क्रमबद्ध किए जाते हैं और 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) 🔥 लोकप्रिय

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

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

• 🏆 उद्योग मानक
• 🔧 उत्कृष्ट टूल/फ़ंक्शन कॉलिंग
• 📖 सर्वोत्तम दस्तावेज़ीकरण और इकोसिस्टम
• 🎯 सुसंगत, पूर्वानुमेय आउटपुट
• 📋 JSON स्कीमा प्रवर्तन के साथ संरचित आउटपुट
• 🧠 GPT-5.6 रीजनिंग मॉडल के लिए रीजनिंग प्रयास नियंत्रण
• 🆕 Responses API — /v1/responses के लिए समर्पित क्लाइंट, जिसमें रीजनिंग सारांश, अंतर्निहित टूल और सर्वर-साइड स्थिति शामिल है

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

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

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

संरचित आउटपुट (JSON स्कीमा)

OpenAI output_schema के माध्यम से सुनिश्चित JSON आउटपुट का समर्थन करता है। 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.6-terra"))?;

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

नेस्टेड ऑब्जेक्ट के साथ सख्त मोड के लिए, प्रत्येक स्तर पर 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
}))

रीजनिंग प्रयास

OpenAI रीजनिंग मॉडल के लिए, यह नियंत्रित करें कि मॉडल कितना रीजनिंग प्रयास लागू करता है:

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

let config = OpenAIConfig::new(&api_key, "gpt-5.6-terra");
let model = OpenAIClient::new_with_reasoning_effort(
    config,
    OpenAIReasoningEffort::XHigh,
)?;

पूर्ण शब्दावली None, Minimal, Low, Medium, High, XHigh, और Max है; उपलब्धता मॉडल और API पर निर्भर करती है। GPT-5.6 Chat Completions अधिकतम XHigh का समर्थन करता है; Max के लिए OpenAIResponsesClient का उपयोग करें। मूल तीन-मूल्य वाला ReasoningEffort API पश्चगामी संगतता के लिए उपलब्ध रहता है।

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

स्थानीय सर्वरों (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)?;

नोट: संरचित आउटपुट (output_schema) के लिए बैकएंड समर्थन आवश्यक है। नेटिव OpenAI इसका पूर्ण समर्थन करता है; स्थानीय सर्वरों में सीमित समर्थन हो सकता है।

OpenAI-संगत एंडपॉइंट के माध्यम से Gemini

Gemini मॉडल OpenAI Chat Completions वायर फ़ॉर्मैट के माध्यम से https://generativelanguage.googleapis.com/v1beta/openai पर उपलब्ध हैं। OpenAICompatibleConfig::gemini(...) प्रीसेट (openai फ़ीचर के अंतर्गत) को GEMINI_API_KEY के साथ उपयोग करके Gemini को उसी OpenAI-संगत क्लाइंट के माध्यम से चलाएँ, जिसका उपयोग आप अन्य सभी प्रदाताओं के लिए करते हैं:

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

यह पथ चैट, स्ट्रीमिंग, फ़ंक्शन कॉलिंग, संरचित आउटपुट और रीज़निंग प्रयास का समर्थन करता है (OpenAI का reasoning_effort, Gemini के थिंकिंग स्तरों/बजट से मैप होता है)। Gemini-विशिष्ट विकल्प — जैसे include_thoughts के साथ thinking_config, या cached_content — अनुरोध के extensions["openai"]["extra_body"]["google"] मैप के माध्यम से पास किए जाते हैं, जिसे क्लाइंट अनुरोध बॉडी में शब्दशः मर्ज करता है।

इसे GeminiModel की बजाय कब उपयोग करें: नेटिव Gemini सुविधाओं (सर्वर-साइड टूल, Interactions API, नेटिव ThinkingConfig, मल्टीमॉडल-प्रथम एर्गोनॉमिक्स) के लिए GeminiModel को प्राथमिकता दें। प्रदाताओं के बीच एकल समान क्लाइंट चाहिए होने पर OpenAI-संगत प्रीसेट का उपयोग करें।

उदाहरण (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

पुराना रीज़निंग-एफ़र्ट API

मूल तीन-स्तरीय ReasoningEffort API संगतता के लिए अभी भी उपलब्ध है:

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

let config = OpenAIConfig::new(&api_key, "gpt-5")
    .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-5"))?;

    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 मॉडल चलाता है

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

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::new(GroqConfig::gpt_oss_120b(&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-3.7-flash")?
    // OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-5.6-terra"))?
    // AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-5"))?
    // DeepSeekClient::chat(&api_key)?
    // GroqClient::new(GroqConfig::gpt_oss_120b(&api_key))?
);

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

---

उदाहरण

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

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

जनरेट किए गए projects को CI में scripts/check-cargo-adk-templates.sh द्वारा compile किया जाता है। पूरी example gallery adk-playground repo में maintain की जाती है।

---

संबंधित

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

---

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

उस content के साथ क्या होता है जिसे कोई provider carry नहीं कर सकता

Content किसी भी एक provider transport द्वारा स्वीकार किए जाने की तुलना में अधिक अभिव्यक्त कर सकता है, इसलिए प्रत्येक adapter को यह तय करना पड़ता है कि शेष content के साथ क्या करना है। अब वे निर्णय अदृश्य रूप से लागू किए जाने के बजाय record किए जाते हैं। प्रत्येक भाग को वर्गीकृत किया जाता है:

डाउनग्रेड और विलोपन दर्ज किए जाते समय 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 कवरेज