モデルプロバイダー（クラウド）

ADK-Rust は adk-model crate を通じて複数のクラウド 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.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 キーを設定する

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);

完全なドキュメントについては、Schema Normalization を参照してください。

---

Gemini（Google）⭐ デフォルト

最適用途: 汎用、マルチモーダルタスク、大規模ドキュメント

主な特長:

• 🖼️ ネイティブなマルチモーダル（画像、動画、音声、PDF）
• 📚 最大 2M トークンのコンテキストウィンドウ
• 🧠 Thinking mode: レベルベース（Gemini 3）および予算ベース（Gemini 2.5）、thought signatures 付き
• 💰 競争力のある価格設定
• ⚡ 高速な推論

完全な動作例

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 の値を返し、推論コンテキストを保持するために後続のターンでそれをそのまま返す必要があります。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 スキーマ強制による 構造化出力
• 🧠 o1/o3 推論モデル向けの Reasoning effort 制御
• 🆕 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-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(())
}

構造化出力（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-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

ネストされたオブジェクトで厳格モードを使用するには、各レベルに 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 モデル）

OpenAI 推論モデルでは、モデルが適用する推論 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 ほど、レイテンシとトークンのコストを犠牲にして、より徹底した推論を生成します。

OpenAI 対応のローカル APIs

OpenAIConfig::compatible() を使用してローカルサーバー（Ollama、vLLM、LM Studio）に接続します:

// 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 を使用して、他のすべてのプロバイダーと同じ OpenAI 対応クライアントで Gemini を実行します:

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

この経路は、チャット、ストリーミング、関数呼び出し、構造化出力、および reasoning effort（OpenAI の reasoning_effort は Gemini の思考 レベル/予算にマップされます）をサポートします。Gemini 固有のオプション、たとえば thinking_config と include_thoughts、または 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

Reasoning Effort（o1、o3 モデル）

ReasoningEffort を使って、モデルが適用する推論 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 💭 思考

最適な用途: 複雑な問題解決、数学、コーディング、推論タスク

主な特長:

• 💭 思考モード - 思考の連鎖による推論を表示
• 💰 非常に費用対効果が高い（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(())
}

利用可能なモデル

出力例（思考モード付きの 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 ⚡ 超高速

最適用途: リアルタイムアプリケーション、チャットボット、速度が重要なタスク

主な特長:

• ⚡ 最速の推論 - 他社より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::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()?;

---

例

cargo-adk を使って、0.8 の依存関係が検証されたプロバイダー別プロジェクトを生成します。

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 でモデルをローカル実行する
• Local Models (mistral.rs) - ネイティブ Rust 推論
• LlmAgent - エージェントでモデルを使う
• Function Tools - エージェントにツールを追加する

---

前へ: ← Realtime Agents | 次へ: Ollama (Local) →

プロバイダーが保持できないコンテンツはどうなるか

Content は単一のプロバイダーのトランスポートが受け入れる以上の内容を表現できるため、各アダプターは残りをどう扱うかを決める必要があります。これらの判断は、今では見えない形で適用されるのではなく、記録されます。各部分は分類されます:

ダウングレードと省略は、記録される際に 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 が対象とするのは省略のみです。ダウングレードはそれでもモデルに届き、これを拒否すると、文書化されたテキストのフォールバックも拒否することになります。

Note: 台帳は構成上、完全です。記録された運命を持たずにアダプターを離れるパートは、将来の変更で追加されたものも含めて、明示的な「記録された理由なし」を伴う省略として記録され、adk-model/tests/part_conversion_matrix_tests.rs はそれで失敗します。

Bedrock Converse のカバレッジ