Fournisseurs de modèles (Cloud)

ADK-Rust prend en charge plusieurs fournisseurs de LLM cloud via la crate adk-model. Tous les fournisseurs implémentent le trait Llm, les rendant interchangeables dans vos agents.

Vue d'ensemble

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

Comparaison rapide

---

Étape 1 : Installation

Ajoutez les fournisseurs dont vous avez besoin à votre Cargo.toml :

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

Étape 2 : Définissez votre clé 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

---

Gemini (Google) ⭐ Par défaut

Idéal pour : Usage général, tâches multimodales, documents volumineux

Points forts :

• 🖼️ Multimodal natif (images, vidéo, audio, PDF)
• 📚 Fenêtre contextuelle jusqu'à 2 millions de tokens
• 💰 Tarification compétitive
• ⚡ Inférence rapide

Exemple de Fonctionnement Complet

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

Modèles Disponibles

Exemple de Sortie

👤 Utilisateur : Qu'y a-t-il sur cette image ? [télécharge une photo de chat]

🤖 Gemini : Je vois un chat tigré roux et moelleux assis sur un rebord de fenêtre. 
Le chat semble regarder à l'extérieur, la lumière du soleil illuminant sa fourrure. 
Il a les yeux verts et des marques rayées distinctives typiques des chats tigrés.

---

OpenAI (GPT-4o) 🔥 Populaire

Idéal pour : Applications de production, performances fiables, vastes capacités

Points forts :

• 🏆 Standard de l'industrie
• 🔧 Excellent appel d'outils/fonctions
• 📖 Meilleure documentation et écosystème
• 🎯 Sorties cohérentes et prévisibles

Exemple de Fonctionnement Complet

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-powered assistant")
        .instruction("You are a helpful assistant powered by OpenAI GPT-4o. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

Modèles Disponibles

Exemple de Sortie

👤 Utilisateur : Écris un haïku sur la programmation Rust

🤖 GPT-4o : Mémoire si sûre,
La propriété garde chaque octet—
Compilateur, mon ami.

---

Anthropic (Claude) 🧠 Intelligent

Idéal pour : le raisonnement complexe, les applications critiques pour la sécurité, les documents longs

Points forts :

• 🧠 Capacité de raisonnement exceptionnelle
• 🛡️ Le plus axé sur la sécurité
• 📚 Contexte de 200K tokens
• ✍️ Excellente qualité de rédaction

Exemple de travail complet

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

Modèles disponibles

Exemple de sortie

👤 User: Expliquez l'intrication quantique à un enfant de 10 ans

🤖 Claude: Imagine que tu as deux pièces magiques. Quand tu les lances, elles atterrissent toujours
de la même manière - soit les deux sur pile, soit les deux sur face - même si une pièce est sur Terre
et l'autre sur la Lune ! Les scientifiques appellent cela "l'intrication". Les pièces
sont connectées d'une manière spéciale que nous ne pouvons pas voir, comme des meilleurs amis invisibles
qui font toujours le même choix au même moment.

---

DeepSeek 💭 Réflexion

Idéal pour : la résolution de problèmes complexes, les mathématiques, le codage, les tâches de raisonnement

Points forts :

• 💭 Mode réflexion - affiche le raisonnement en chaîne de pensée
• 💰 Très rentable (10 fois moins cher que GPT-4)
• 🔄 Mise en cache du contexte pour les préfixes répétés
• 🧮 Fort en mathématiques et en codage

Exemple de travail complet

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")?;
    
    // Modèle de chat standard
    let model = DeepSeekClient::chat(&api_key)?;
    
    // OU : Modèle de raisonnement avec mode de pensée
    // 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(())
}

Modèles disponibles

Exemple de sortie (raisonneur avec mode de réflexion)

👤 User: Quel est le résultat de 17 × 23 ?

🤖 DeepSeek: <thinking>
Permettez-moi de détailler cela :
17 × 23 = 17 × (20 + 3)
       = 17 × 20 + 17 × 3
       = 340 + 51
       = 391
</thinking>

La réponse est 391.

---

Groq ⚡ Ultra-Rapide

Idéal pour : Les applications en temps réel, les chatbots, les tâches critiques en termes de vitesse

Points clés :

• ⚡ Inférence la plus rapide - 10x plus rapide que les concurrents
• 🔧 Technologie LPU (Language Processing Unit)
• 💰 Prix compétitifs
• 🦙 Exécute les modèles LLaMA, Mixtral, Gemma

Exemple complet et fonctionnel

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

Modèles disponibles

Exemple de sortie

👤 User: Quick! Name 5 programming languages

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

---

Changer de fournisseur

Tous les fournisseurs implémentent le même trait Llm, le changement est donc facile :

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

// Changez simplement le modèle - tout le reste reste identique !
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // Choisissez-en un :
    // 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()?;

---

Exemples

# Gemini (par défaut)
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  # Mode réflexion

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

---

Articles connexes

• Ollama (Local) - Exécutez des modèles localement avec Ollama
• Modèles locaux (mistral.rs) - Inférence Rust native
• LlmAgent - Utiliser des modèles avec des agents
• Function Tools - Ajouter des tools aux agents

---

Précédent : ← Agents en temps réel | Suivant : Ollama (Local) →