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, ce qui les rend interchangeables dans vos agents.

Vue d'ensemble

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

Comparaison rapide

---

Étape 1 : Installation

Ajoutez les fournisseurs dont vous avez besoin à votre 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"] }

É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

Normalisation du schéma

Chaque fournisseur normalise automatiquement les schémas d’outil MCP au moment de la requête. Vous n’avez rien à faire — cela fonctionne de manière transparente. Mais voici ce qui se passe en interne :

Accédez au adaptateur par programmation via le trait Llm :

use adk_core::{Llm, SchemaAdapter};

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

Voir Schema Normalization pour la documentation complète.

---

Gemini (Google) ⭐ Par défaut

Idéal pour : Tâches à usage général, tâches multimodales, grands documents

Points forts :

• 🖼️ Multimodal natif (images, vidéo, audio, PDF)
• 📚 Fenêtre de contexte jusqu’à 2M tokens
• 🧠 Mode de réflexion : basé sur le niveau (Gemini 3) et basé sur le budget (Gemini 2.5) avec des signatures de pensée
• 💰 Tarification compétitive
• ⚡ Inférence rapide

Exemple complet 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("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(())
}

Modèles disponibles

Mode de réflexion

Les modèles Gemini 3 prennent en charge une réflexion basée sur des niveaux, tandis que Gemini 2.5 utilise une réflexion basée sur un budget. Lors de l’utilisation du mode de réflexion avec l’appel de fonctions, les modèles Gemini 2.5+ et 3.x renvoient des valeurs thoughtSignature qui doivent être renvoyées telles quelles dans les tours suivants afin de préserver le contexte du raisonnement. ADK-Rust gère cela automatiquement — les signatures sont sérialisées lorsqu’elles sont présentes et omises lorsque 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?;

Exemple de sortie

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

Idéal pour : applications de production, performances fiables, larges capacités

Points forts :

• 🏆 Référence du secteur
• 🔧 Appel d’outil/de fonction उत्कृष्ट
• 📖 Meilleure documentation et écosystème
• 🎯 Sorties cohérentes et prévisibles
• 📋 Sortie structurée avec application du schéma JSON
• 🧠 Contrôle de l’effort de raisonnement pour les modèles de raisonnement o1/o3
• 🆕 Responses API — client dédié pour /v1/responses avec résumés de raisonnement, outils intégrés et état côté serveur

Exemple complet 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("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(())
}

Sortie structurée (schéma JSON)

OpenAI prend en charge une sortie JSON garantie via output_schema. ADK-Rust relie automatiquement cela au response_format de OpenAI et à son 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

Pour le mode strict avec des objets imbriqués, incluez additionalProperties: false à chaque niveau :

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

Effort de raisonnement (modèles o1, o3)

Pour les modèles de raisonnement OpenAI, contrôlez la quantité d’effort de raisonnement appliquée par le modèle :

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

Niveaux disponibles : Low, Medium, High. Un effort plus élevé produit un raisonnement plus approfondi, au prix de la latence et des jetons.

OpenAI-Compatible Local APIs

Utilisez OpenAIConfig::compatible() pour vous connecter à des serveurs locaux (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)?;

Remarque : la sortie structurée (output_schema) nécessite une prise en charge du backend. Le support natif de OpenAI la prend entièrement en charge ; les serveurs locaux peuvent avoir une prise en charge limitée.

Gemini via le point de terminaison compatible OpenAI

Les modèles Gemini sont accessibles via le format de fil d’Ariane Chat Completions OpenAI à https://generativelanguage.googleapis.com/v1beta/openai. Utilisez le préréglage OpenAICompatibleConfig::gemini(...) (dans la fonctionnalité openai) avec un GEMINI_API_KEY pour exécuter Gemini via le même client compatible OpenAI que vous utilisez pour tous les autres fournisseurs :

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

Ce chemin prend en charge le chat, le streaming, l’appel de fonctions, la sortie structurée et l’effort de raisonnement (OpenAI’s reasoning_effort se mappe aux niveaux/budgets de réflexion de Gemini). Les options spécifiques à Gemini — par exemple thinking_config avec include_thoughts, ou cached_content — sont transmises via la carte extensions["openai"]["extra_body"]["google"] de la requête, que le client fusionne telle quelle dans le corps de la requête.

Quand utiliser ceci plutôt que GeminiModel : pour les fonctionnalités Gemini natives (outils côté serveur, l’Interactions API, ThinkingConfig natif, ergonomie multimodale d’abord), préférez GeminiModel. Utilisez le préréglage compatible OpenAI lorsque vous souhaitez un seul client uniforme entre fournisseurs.

Exemples (nécessitent GEMINI_API_KEY ou 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

Effort de raisonnement (modèles o1, o3)

Contrôlez la quantité d’effort de raisonnement appliquée par le modèle avec ReasoningEffort :

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

Niveaux disponibles : Low (le plus rapide), Medium (équilibré), High (le plus approfondi).

Modèles disponibles

Exemple de sortie

👤 User: Write a haiku about Rust programming

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

---

Anthropic (Claude) 🧠 Intelligent

Idéal pour : Raisonnement complexe, applications critiques pour la sécurité, longs documents

Points forts :

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

Exemple complet 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("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(())
}

Modèles disponibles

Exemple de sortie

👤 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 💭 Réflexion

Idéal pour : Résolution de problèmes complexes, mathématiques, codage, tâches de raisonnement

Points forts :

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

Exemple complet 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("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(())
}

Modèles disponibles

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

👤 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 ⚡ Ultra-rapide

Idéal pour : applications en temps réel, chatbots, tâches critiques en matière de vitesse

Points forts :

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

Exemple complet 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 (in 0.2 seconds): 
1. Rust
2. Python
3. JavaScript
4. Go
5. TypeScript

---

Changer de fournisseur

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

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

---

Exemples

Utilisez cargo-adk pour générer des projets spécifiques à un fournisseur avec des dépendances 0.8 validées :

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

Les projets générés sont compilés en CI par scripts/check-cargo-adk-templates.sh. Vous pouvez parcourir et exécuter toute la galerie d’exemples dans l’ADK-Rust Playground intégré à ce site.

---

Liés

• Ollama (Local) - Exécuter des modèles localement avec Ollama
• Modèles locaux (mistral.rs) - Inférence native en Rust
• LlmAgent - Utiliser des modèles avec des agents
• Outils de fonction - Ajouter des outils aux agents

---

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

Que devient le contenu qu’un fournisseur ne peut pas transporter

Content peut exprimer davantage que ce qu’un transport de fournisseur unique accepte, donc chaque adaptateur doit décider quoi faire du reste. Ces décisions sont désormais enregistrées plutôt qu’appliquées de manière invisible. Chaque partie est classée :

Les rétrogradations et les omissions émettent un avertissement tracing lorsqu’elles sont enregistrées, en indiquant le type de part, le type MIME et la raison, afin qu’aucune ne passe inaperçue.

Pour voir le résultat avant d’envoyer une requête :

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

Pour refuser une requête qui atteindrait le modèle incomplète plutôt que de recevoir une réponse sur un contenu que le modèle n’a jamais vu :

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 ne couvre que les omissions. Une rétrogradation atteint quand même le modèle, et la refuser reviendrait à rejeter le repli textuel documenté.

Note : le registre est complet par construction. Toute part qui quitte un adaptateur sans sort enregistré — y compris une part ajoutée par une modification future — est enregistrée comme une omission avec un « aucune raison enregistrée » explicite, et adk-model/tests/part_conversion_matrix_tests.rs échoue dessus.

Couverture de Bedrock Converse