Modellanbieter (Cloud)

ADK-Rust unterstützt über das adk-model-Crate mehrere Cloud-LLM-Anbieter. Alle Anbieter implementieren das Llm-Trait, wodurch sie in Ihren Agenten austauschbar sind.

Übersicht

┌─────────────────────────────────────────────────────────────────────┐
│                     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                                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Schneller Vergleich

---

Schritt 1: Installation

Fügen Sie die benötigten Anbieter zu Ihrem Cargo.toml hinzu:

[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"] }

Schritt 2: Legen Sie Ihren API-Schlüssel fest

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-Normalisierung

Jeder Anbieter normalisiert MCP-Tool-Schemas automatisch zum Zeitpunkt der Anfrage. Sie müssen nichts weiter tun – es funktioniert transparent. Aber so läuft es im Hintergrund ab:

Greifen Sie programmatisch über das Llm-Trait auf den Adapter zu:

use adk_core::{Llm, SchemaAdapter};

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

Eine vollständige Dokumentation finden Sie unter Schema-Normalisierung.

---

Gemini (Google) ⭐ Standard

Am besten geeignet für: Allgemeine Zwecke, multimodale Aufgaben, große Dokumente

Wichtige Highlights:

• 🖼️ Native Multimodalität (Bilder, Videos, Audio, PDF)
• 📚 Kontextfenster mit bis zu 2 Millionen Token
• 🧠 Denkmodus: stufenbasiert (Gemini 3) und budgetbasiert (Gemini 2.5) mit Gedanken-Signaturen
• 💰 Wettbewerbsfähige Preise
• ⚡ Schnelle Inferenz

Vollständiges funktionierendes Beispiel

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

Verfügbare Modelle

Denkmodus

Gemini 3-Modelle unterstützen stufenbasiertes Denken, während Gemini 2.5 budgetbasiertes Denken verwendet. Bei der Verwendung des Denkmodus mit Funktionsaufrufen geben Gemini 2.5+- und 3.x-Modelle thoughtSignature-Werte zurück, die in nachfolgenden Durchläufen zurückgegeben werden müssen, um den Kontext der Schlussfolgerung zu bewahren. ADK-Rust übernimmt dies automatisch – Signaturen werden serialisiert, wenn sie vorhanden sind, und weggelassen, wenn 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?;

Beispielausgabe

👤 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) 🔥 Beliebt

Am besten geeignet für: Produktionsanwendungen, zuverlässige Leistung, umfassende Funktionen

Wichtige Highlights:

• 🏆 Industriestandard
• 🔧 Hervorragende Unterstützung für Tools und Funktionsaufrufe
• 📖 Beste Dokumentation und bestes Ökosystem
• 🎯 Konsistente, vorhersehbare Ausgaben
• 📋 Strukturierte Ausgabe mit JSON-Schema-Durchsetzung
• 🧠 Steuerung des Schlussfolgerungsaufwands für GPT-5.6-Schlussfolgerungsmodelle
• 🆕 Responses API – dedizierter Client für /v1/responses mit Zusammenfassungen der Schlussfolgerungen, integrierten Tools und serverseitigem Zustand

Vollständiges funktionierendes Beispiel

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

Strukturierte Ausgabe (JSON-Schema)

OpenAI unterstützt garantierte JSON-Ausgabe über output_schema. ADK-Rust bindet dies automatisch an OpenAIs 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

Für den strikten Modus mit verschachtelten Objekten muss additionalProperties: false auf jeder Ebene eingefügt werden:

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

Schlussfolgerungsaufwand

Bei OpenAI-Schlussfolgerungsmodellen kann gesteuert werden, wie viel Schlussfolgerungsaufwand das Modell anwendet:

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

Das vollständige Vokabular umfasst None, Minimal, Low, Medium, High, XHigh und Max; die Verfügbarkeit hängt vom Modell und von API ab. GPT-5.6 Chat Completions unterstützt bis zu XHigh; verwende OpenAIResponsesClient für Max. Das ursprüngliche dreistufige ReasoningEffort API bleibt aus Gründen der Abwärtskompatibilität verfügbar.

OpenAI-kompatible lokale APIs

Verwende OpenAIConfig::compatible(), um eine Verbindung zu lokalen Servern (Ollama, vLLM, LM Studio) herzustellen:

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

Hinweis: Strukturierte Ausgabe (output_schema) erfordert Unterstützung durch das Backend. OpenAI unterstützt sie vollständig; lokale Server bieten möglicherweise nur eingeschränkte Unterstützung.

Gemini über den OpenAI-kompatiblen Endpunkt

Gemini-Modelle sind über das OpenAI-Chat-Completions-Drahtformat unter https://generativelanguage.googleapis.com/v1beta/openai erreichbar. Verwende die Voreinstellung OpenAICompatibleConfig::gemini(...) (unter dem Feature openai) mit einem GEMINI_API_KEY, um Gemini über denselben OpenAI-kompatiblen Client auszuführen, den du für alle anderen Anbieter verwendest:

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

Dieser Pfad unterstützt Chat, Streaming, Funktionsaufrufe, strukturierte Ausgabe und den Reasoning-Aufwand (reasoning_effort von OpenAI wird auf die Gemini-Denkstufen bzw. -Budgets abgebildet). Gemini-spezifische Optionen – beispielsweise thinking_config mit include_thoughts oder cached_content – werden über die extensions["openai"]["extra_body"]["google"]-Map der Anfrage übergeben, die der Client wortgetreu in den Anfragekörper übernimmt.

Wann sollte dies anstelle von GeminiModel verwendet werden?: Für native Gemini-Funktionen (serverseitige Tools, die Interactions API, natives ThinkingConfig, auf multimodale Nutzung ausgerichtete Ergonomie) empfiehlt sich GeminiModel. Verwende die OpenAI-kompatible Voreinstellung, wenn du einen einheitlichen Client für alle Anbieter verwenden möchtest.

Beispiele (erfordern GEMINI_API_KEY oder 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

Veraltete Reasoning-Aufwand-API

Die ursprüngliche dreistufige ReasoningEffort API bleibt aus Kompatibilitätsgründen verfügbar:

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

Verfügbare Stufen: Low (am schnellsten), Medium (ausgewogen), High (am gründlichsten).

Verfügbare Modelle

Beispielausgabe

👤 User: Write a haiku about Rust programming

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

---

Anthropic (Claude) 🧠 Intelligent

Am besten geeignet für: Komplexe Schlussfolgerungen, sicherheitskritische Anwendungen, lange Dokumente

Wichtige Highlights:

• 🧠 Außergewöhnliche Fähigkeit zu Schlussfolgerungen
• 🛡️ Stärkster Fokus auf Sicherheit
• 📚 Kontext mit 200K Tokens
• ✍️ Hervorragende Schreibqualität

Vollständiges funktionierendes Beispiel

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

Verfügbare Modelle

Beispielausgabe

👤 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 💭 Denken

Am besten geeignet für: Komplexe Problemlösung, Mathematik, Programmierung und logische Schlussfolgerungen

Wichtige Highlights:

• 💭 Denkmodus – zeigt den Denkprozess
• 💰 Sehr kostengünstig (10-mal günstiger als GPT-4)
• 🔄 Kontext-Caching für wiederholte Präfixe
• 🧮 Besonders leistungsfähig bei Mathematik und Programmierung

Vollständiges funktionierendes Beispiel

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

Verfügbare Modelle

Beispielausgabe (Reasoner mit Denkmodus)

👤 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 ⚡ Extrem schnell

Am besten geeignet für: Echtzeitanwendungen, Chatbots, geschwindigkeitskritische Aufgaben

Wichtige Highlights:

• ⚡ Schnellste Inferenz – 10-mal schneller als die Konkurrenz
• 🔧 LPU-Technologie (Language Processing Unit)
• 💰 Wettbewerbsfähige Preise
• 🦙 Führt LLaMA-, Mixtral- und Gemma-Modelle aus

Vollständiges funktionierendes Beispiel

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

Verfügbare Modelle

Beispielausgabe

👤 User: Quick! Name 5 programming languages

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

---

Anbieter wechseln

Alle Anbieter implementieren dasselbe Llm-Trait, daher ist der Wechsel einfach:

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

---

Beispiele

Verwenden Sie cargo-adk, um anbieterspezifische Projekte mit validierten 0.8-Abhängigkeiten zu generieren:

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

Die generierten Projekte werden in CI von scripts/check-cargo-adk-templates.sh kompiliert. Die vollständige Beispielgalerie wird im adk-playground-Repository gepflegt.

---

Verwandte Themen

• Ollama (lokal) – Modelle lokal mit Ollama ausführen
• Lokale Modelle (mistral.rs) – Native Rust-Inferenz
• LlmAgent – Modelle mit Agenten verwenden
• Funktionstools – Tools zu Agenten hinzufügen

---

Zurück: ← Echtzeit-Agenten | Weiter: Ollama (lokal) →

Was mit Inhalten geschieht, die ein Anbieter nicht übertragen kann

Content kann mehr ausdrücken, als ein einzelner Anbietertransport akzeptiert. Daher muss jeder Adapter entscheiden, wie mit dem Rest verfahren wird. Diese Entscheidungen werden nun aufgezeichnet, statt unbemerkt angewendet zu werden. Jeder Teil wird klassifiziert:

Herabstufungen und Auslassungen geben bei ihrer Aufzeichnung eine tracing-Warnung aus, in der die Art des Teils, der MIME-Typ und der Grund genannt werden, sodass keine davon unbemerkt bleibt.

Um das Ergebnis vor dem Senden einer Anfrage zu sehen:

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

Um eine Anfrage abzulehnen, die das Modell unvollständig erreichen würde, statt eine Antwort zu Material zu erhalten, das das Modell nie gesehen hat:

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 deckt ausschließlich Auslassungen ab. Eine Herabstufung erreicht weiterhin das Modell, und ihre Ablehnung würde den dokumentierten textuellen Fallback verweigern.

Hinweis: Das Protokoll ist konstruktionsbedingt vollständig. Jeder Teil, der einen Adapter ohne aufgezeichneten Ausgang verlässt — einschließlich eines Teils, der durch eine zukünftige Änderung hinzugefügt wurde — wird als Auslassung mit dem ausdrücklichen Grund „kein aufgezeichneter Grund“ aufgezeichnet, und adk-model/tests/part_conversion_matrix_tests.rs schlägt dabei fehl.

Abdeckung von Bedrock Converse