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

ADK-Rust は、adk-model クレートを通じて複数のクラウド LLM プロバイダーをサポートします。すべてのプロバイダーは Llm トレイトを実装しているため、エージェント内で相互に置き換えて使用できます。

概要

┌─────────────────────────────────────────────────────────────────────┐
│                     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 を使用してください。元の 3値 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 でアクセスできます。openai 機能の OpenAICompatibleConfig::gemini(...) プリセットを、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"),
)?;

この経路は、チャット、ストリーミング、関数呼び出し、構造化出力、および 推論の強度をサポートします（OpenAI の reasoning_effort は Gemini の思考 レベル／予算にマッピングされます）。include_thoughts を指定した thinking_config や cached_content など、Gemini 固有のオプションは、リクエストの 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

元の3段階 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分の1の価格）
• 🔄 繰り返し使用するプレフィックスのコンテキストキャッシュ
• 🧮 数学とコーディングに強い

完全な動作例

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::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()?;

---

例

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

生成されたプロジェクトは、scripts/check-cargo-adk-templates.sh によって CI でコンパイルされます。完全な例のギャラリーは adk-playground リポジトリで管理されています。

---

関連項目

• Ollama（ローカル） - Ollama を使用してモデルをローカルで実行する
• ローカルモデル（mistral.rs） - ネイティブ Rust 推論
• LlmAgent - エージェントでモデルを使用する
• 関数ツール - エージェントにツールを追加する

---

前へ: ← リアルタイムエージェント | 次へ: Ollama（ローカル） →

プロバイダーが対応できないコンテンツの扱い

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 は省略のみを対象とします。ダウングレードされたパートは引き続きモデルに到達するため、それを拒否すると、文書化されたテキストフォールバックを拒否することになります。

注記: 台帳は構造上完全です。将来の変更によって追加されたものを含め、記録された処理結果なしにアダプターを離れるパートはすべて、「記録された理由なし」と明示された省略として記録され、adk-model/tests/part_conversion_matrix_tests.rs はそれに対して失敗します。

Bedrock Converse の対応範囲