Modell-Provider (Cloud)

ADK-Rust unterstützt mehrere Cloud-LLM-Provider über die adk-model-Crate. Alle Provider implementieren den Llm-Trait und sind somit in Ihren Agents austauschbar.

Übersicht

┌─────────────────────────────────────────────────────────────────────┐
│                     Cloud Model Providers                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   • Gemini (Google)    ⭐ Default    - Multimodal, large context    │
│   • OpenAI (GPT-4o)    🔥 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 Provider zu Ihrer Cargo.toml hinzu:

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

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

Schritt 2: API-Schlüssel festlegen

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

---

Gemini (Google) ⭐ Standard

Am besten für: Allzweck, multimodale Aufgaben, große Dokumente

Wichtige Merkmale:

• 🖼️ Nativ multimodal (Bilder, Video, Audio, PDF)
• 📚 Bis zu 2M token Kontextfenster
• 💰 Wettbewerbsfähige Preise
• ⚡ Schnelle Inferenz

Komplettes Arbeitsbeispiel

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.0-flash")?;

    let agent = LlmAgentBuilder::new("gemini_assistant")
        .description("Gemini-betriebener Assistent")
        .instruction("Du bist ein hilfreicher Assistent, der von Google Gemini betrieben wird. Fasse dich kurz.")
        .model(Arc::new(model))
        .build()?;

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

Verfügbare Modelle

Beispielausgabe

👤 Nutzer: Was ist auf diesem Bild? [lädt Foto einer Katze hoch]

🤖 Gemini: Ich sehe eine flauschige orange getigerte Katze, die auf einem Fensterbrett sitzt. 
Die Katze scheint nach draußen zu schauen, wobei Sonnenlicht ihr Fell beleuchtet. 
Sie hat grüne Augen und auffällige gestreifte Markierungen, die typisch für getigerte Katzen sind.

---

OpenAI (GPT-4o) 🔥 Beliebt

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

Wichtige Merkmale:

• 🏆 Industriestandard
• 🔧 Hervorragende Tool-/Funktionsaufrufe
• 📖 Beste Dokumentation und Ökosystem
• 🎯 Konsistente, vorhersagbare Ausgaben

Komplettes Arbeitsbeispiel

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

    let agent = LlmAgentBuilder::new("openai_assistant")
        .description("OpenAI-betriebener Assistent")
        .instruction("Du bist ein hilfreicher Assistent, der von OpenAI GPT-4o betrieben wird. Fasse dich kurz.")
        .model(Arc::new(model))
        .build()?;

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

Verfügbare Modelle

Beispielausgabe

👤 Nutzer: Schreibe ein Haiku über die Rust-Programmierung

🤖 GPT-4o: Speicher so sicher,
Ownership schützt jedes Byte –
Compiler, mein Freund.

---

Anthropic (Claude) 🧠 Intelligent

Am besten geeignet für: Komplexes Denken, sicherheitskritische Anwendungen, lange Dokumente

Wichtige Highlights:

• 🧠 Außergewöhnliche Denkfähigkeit
• 🛡️ Am stärksten auf Sicherheit ausgerichtet
• 📚 Kontext von 200K Tokens
• ✍️ Exzellente Schreibqualität

Vollständiges Arbeitsbeispiel

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

    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: Erkläre Quantenverschränkung einem 10-Jährigen

🤖 Claude: Stell dir vor, du hast zwei magische Münzen. Wenn du sie wirfst, landen sie immer
auf dieselbe Weise – beide zeigen Kopf oder beide zeigen Zahl – selbst wenn eine Münze auf der Erde
und die andere auf dem Mond ist! Wissenschaftler nennen das „Verschränkung“. Die Münzen
sind auf eine besondere Weise verbunden, die wir nicht sehen können, wie unsichtbare beste Freunde,
die immer genau zur gleichen Zeit die gleiche Entscheidung treffen.

---

DeepSeek 💭 Denken

Am besten geeignet für: Komplexe Problemlösung, Mathematik, Programmierung, Denkaufgaben

Wichtige Highlights:

• 💭 Denkmodus – zeigt schrittweises Denken
• 💰 Sehr kostengünstig (10x günstiger als GPT-4)
• 🔄 Kontext-Caching für wiederholte Präfixe
• 🧮 Stark in Mathematik und Programmierung

Vollständiges Arbeitsbeispiel

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-Modell
    let model = DeepSeekClient::chat(&api_key)?;
    
    // ODER: Reasoning-Modell mit Denkmodus
    // 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: Was ist 17 × 23?

🤖 DeepSeek: <thinking>
Lass mich das aufschlüsseln:
17 × 23 = 17 × (20 + 3)
       = 17 × 20 + 17 × 3
       = 340 + 51
       = 391
</thinking>

Die Antwort ist 391.

---

Groq ⚡ Ultraschnell

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

Wichtige Highlights:

• ⚡ Schnellste Inferenz - 10x schneller als Konkurrenten
• 🔧 LPU (Language Processing Unit)-Technologie
• 💰 Wettbewerbsfähige Preise
• 🦙 Führt LLaMA, Mixtral, 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::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(())
}

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 denselben Llm trait, daher ist das Wechseln einfach:

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

// Ändere einfach das Modell - alles andere bleibt gleich!
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // Wähle eines:
    // GeminiModel::new(&api_key, "gemini-2.0-flash")?
    // OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-4o"))?
    // AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-4-20250514"))?
    // DeepSeekClient::chat(&api_key)?
    // GroqClient::llama70b(&api_key)?
);

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

---

Beispiele

# Gemini (Standard)
cargo run --example quickstart

# OpenAI
cargo run --example openai_basic --features openai

# Anthropic
cargo run --example anthropic_basic --features anthropic

# DeepSeek
cargo run --example deepseek_basic --features deepseek
cargo run --example deepseek_reasoner --features deepseek  # Denkmodus

# Groq
cargo run --example groq_basic --features groq

---

Verwandtes

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

---

Zurück: ← Echtzeit Agents | Weiter: Ollama (Lokal) →