Retour au blog

Démarrer avec adk-rust : Votre premier agent IA dans Rust

Libérez la puissance des agents IA avec Rust. Ce guide vous montre comment construire, exécuter et déployer votre premier agent intelligent.

26 octobre 202312 min de lecture
adk-rustRustAgent IAGoogle GeminiDéveloppementTutoriel

Table des matières

  • 1. Introduction à adk-rust
  • 2. Prérequis et configuration
  • 3. Création de votre premier projet ADK
  • 4. Anatomie d'un agent adk-rust
  • 5. Implémentation de votre agent IA simple
  • 6. Construction et exécution de votre agent
  • 7. Étapes suivantes

1. Introduction à adk-rust

Le défi du développement d'agents

La construction d'agents intelligents capables de tâches complexes a longtemps été un domaine semé d'embûches. L'orchestration de grands modèles linguistiques (LLMs), la gestion de l'état, le traitement d'entrées diverses et le déploiement efficace de ces agents nécessitent souvent des solutions sur mesure et un effort d'ingénierie considérable. Cette complexité peut constituer un obstacle majeur pour les développeurs souhaitant intégrer de puissantes capacités d'IA dans leurs applications.

Voici adk-rust : Rationaliser le développement d'agents IA

L'Agent Development Kit (ADK) vise à rendre le développement d'agents IA plus proche du développement logiciel traditionnel, et `adk-rust` est son implémentation robuste en Rust. Il fournit un cadre flexible et modulaire conçu pour développer et déployer des agents IA sophistiqués. Bien qu'optimisé pour Gemini et l'écosystème Google, `adk-rust` est agnostique au modèle et au déploiement, assurant compatibilité et flexibilité sur diverses plateformes. Ce guide vous accompagnera dans la configuration de votre environnement, la création de votre premier projet `adk-rust` et le déploiement d'un assistant IA de base, vous offrant une base solide pour vos projets d'agents.

2. Prérequis et configuration

Avant de nous lancer dans la création d'agents, assurons-nous que votre environnement de développement est prêt. Vous aurez besoin d'une chaîne d'outils Rust récente et de la bibliothèque adk-rust ajoutée à votre projet. adk-rust nécessite également une clé Google API pour interagir avec des modèles comme Gemini. Tout d'abord, assurez-vous que Rust est installé. Sinon, la méthode recommandée est via rustup :
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Assurez-vous que votre version de Rust est 1.75 ou supérieure :
rustc --version
Ensuite, nous ajouterons adk-rust comme dépendance. Nous ajouterons également tokio pour les opérations asynchrones et dotenv pour gérer les variables d'environnement comme votre clé API. Vous pouvez les ajouter avec cargo add une fois que vous avez créé votre projet (ce que nous ferons à l'étape suivante) :
cargo add adk-rust
cargo add tokio --features full
cargo add dotenv
Alternativement, vous pouvez les ajouter manuellement à votre fichier Cargo.toml :
[dependencies]
adk-rust = "0.1"
tokio = { version = "1.40", features = ["full"] }
dotenv = "0.15"
Enfin, vous aurez besoin d'une clé Google API pour Gemini. Obtenez-la depuis Google AI Studio ou Google Cloud Console. Créez un fichier .env dans le répertoire racine de votre projet et ajoutez-y votre clé :
GOOGLE_API_KEY="YOUR_GEMINI_API_KEY_HERE"

3. Création de votre premier projet ADK

Une fois votre environnement configuré, créons un nouveau projet Rust, qui servira de conteneur pour notre agent adk-rust. Nous utiliserons la commande standard cargo new pour commencer. Ouvrez votre terminal et exécutez :
cargo new my_first_adk_agent
cd my_first_adk_agent
Cette commande initialise un nouveau projet Rust nommé my_first_adk_agent. La structure du projet généré sera familière aux développeurs Rust :
my_first_adk_agent/
├── Cargo.toml          # Project manifest and dependencies
└── src/
    └── main.rs         # Your agent's main logic goes here
Vous pouvez maintenant exécuter les commandes cargo add de la section précédente dans ce répertoire my_first_adk_agent. N'oubliez pas de créer manuellement un fichier .env dans le répertoire racine (my_first_adk_agent/) pour votre GOOGLE_API_KEY.

4. Anatomie d'un agent adk-rust

Un agent adk-rust est généralement construit autour du LlmAgentBuilder et exécuté à l'aide du Launcher. L'idée principale est de définir la persona de votre agent, ses instructions et les LLM qu'il doit utiliser. Examinons les composants essentiels que vous trouverez dans le fichier src/main.rs d'un agent adk-rust. Dans adk-rust, un LlmAgent est configuré avec une description, une instruction (agissant comme une invite système pour le LLM) et un modèle de langage spécifique (comme Gemini). Le Launcher prend ensuite cet agent et gère l'exécution, fournissant une console interactive ou une interface de serveur web. Cette abstraction simplifie l'interaction de l'agent avec le monde extérieur. Vous trouverez ci-dessous l'équivalent complet du 'Hello World' pour un agent adk-rust. Copiez ce code dans votre fichier src/main.rs. Nous détaillerons chaque partie dans la section suivante.
use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    // 1. Load environment variables from .env file
    dotenv::dotenv().ok();
    
    // 2. Get API key from environment
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    // 3. Create the Gemini model
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    // 4. Build your agent
    let agent = LlmAgentBuilder::new("my_assistant")
        .description("A helpful AI assistant")
        .instruction("You are a friendly and helpful assistant. Answer questions clearly and concisely.")
        .model(Arc::new(model))
        .build()?;

    // 5. Run the agent with the CLI launcher
    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

5. Implémentation de votre agent IA simple

Maintenant, parcourons l'équivalent 'Hello World' pour un agent adk-rust, en nous concentrant sur la façon dont chaque partie du code contribue à la création d'un assistant IA fonctionnel. Vous devriez avoir copié le code de la section précédente dans votre fichier src/main.rs. 1. **Chargement des variables d'environnement** : dotenv::dotenv().ok(); charge les variables de votre fichier .env, rendant votre GOOGLE_API_KEY disponible dans votre application Rust. 2. **Récupération de la clé API** : std::env::var("GOOGLE_API_KEY") récupère votre clé API de l'environnement. L'appel .expect() garantit que le programme paniquera et fournira un message d'erreur clair si la clé n'est pas trouvée, évitant ainsi les échecs silencieux lors de l'initialisation du modèle. 3. **Initialisation du modèle** : let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?; instancie un GeminiModel. Ici, nous fournissons notre clé API et spécifions la version du modèle Gemini souhaitée (gemini-2.5-flash). Cet objet encapsule la logique de connexion et d'interaction avec le service LLM réel, masquant les complexités des appels API. 4. **Construction de l'agent** : C'est ici que vous définissez l'identité et le comportement de base de votre agent à l'aide du LlmAgentBuilder : * LlmAgentBuilder::new("my_assistant") : Commence la construction d'un agent, en lui attribuant un ID unique. * .description("A helpful AI assistant") : Fournit une description lisible par l'homme de l'objectif de votre agent, utile pour la documentation ou l'orchestration de niveau supérieur. * .instruction("You are a friendly and helpful assistant. Answer questions clearly and concisely.") : C'est votre invite système. Elle guide le LLM sous-jacent sur la façon de se comporter, de répondre et sa persona globale. * .model(Arc::new(model)) : Associe l'agent au GeminiModel que nous avons créé. Arc (Atomic Reference Counted) est un pointeur de comptage de références thread-safe, utilisé ici pour la propriété partagée, ce qui est courant dans les applications asynchrones Rust. * .build()? : Finalise la construction de l'agent. Il renvoie un Result, et ? est utilisé pour une propagation d'erreur pratique. 5. **Lancement de l'agent** : Launcher::new(Arc::new(agent)).run().await?; prend votre agent configuré et l'exécute. Le comportement par défaut de Launcher::run() est de démarrer une console interactive où vous pouvez taper des invites à votre agent et voir ses réponses. Le mot-clé await indique qu'il s'agit d'une opération asynchronous, typique des tâches liées aux E/S comme l'interaction avec un LLM.

6. Construire et exécuter votre agent

Une fois que votre fichier src/main.rs est rempli avec le code de l'agent et que votre Cargo.toml est mis à jour avec les dépendances, vous êtes prêt à donner vie à votre agent ! cargo est votre outil principal pour cela. Tout d'abord, construisez votre projet pour compiler le code Rust en un exécutable :
cargo build
Cette commande compile votre agent et ses dépendances. En cas de succès, vous aurez un exécutable dans le répertoire target/debug/ (ou target/release/ si vous construisez avec --release). Pour exécuter votre agent en mode console interactive, ce qui est excellent pour les tests et les interactions rapides, utilisez :
cargo run
Votre terminal deviendra une interface de chat interactive où vous pourrez taper des questions, et votre agent répondra en utilisant le modèle Gemini configuré. Pour quitter, vous pouvez généralement taper exit ou appuyer sur Ctrl+C. adk-rust offre également un moyen d'exécuter votre agent en tant que serveur web, vous permettant d'interagir avec lui via des requêtes HTTP. Ceci est particulièrement utile pour intégrer votre agent dans des applications web ou d'autres services :
cargo run -- serve
Par défaut, cela démarrera le serveur sur http://127.0.0.1:8080. Vous pouvez spécifier un port différent si nécessaire :
cargo run -- serve --port 3000
Maintenant, votre agent est accessible via une API web ! Vous pouvez lui envoyer des requêtes à l'aide d'outils comme curl ou un navigateur web vers le point de terminaison configuré (par exemple, http://127.0.0.1:8080/v1/agent). Cela fait de votre agent IA un service déployable et appelable.

7. Prochaines étapes

Félicitations ! Vous avez réussi à construire et à exécuter votre premier agent IA à l'aide de adk-rust. Ce n'est que le début de ce que vous pouvez accomplir avec le framework. Voici quelques suggestions pour la suite : * **Explorer la documentation ADK** : Plongez plus profondément dans la documentation officielle de adk-rust pour comprendre des fonctionnalités plus avancées, telles que l'intégration avec d'autres composants, la gestion de l'état ou la création de workflows d'agents plus complexes. * **Outils et capacités personnalisés** : Apprenez à équiper votre agent d'outils personnalisés, lui permettant d'interagir avec des API externes, des bases de données ou d'effectuer des calculs spécifiques au-delà de la simple génération de texte. C'est une fonctionnalité puissante pour étendre les capacités de l'agent. * **Options de déploiement** : Examinez différentes stratégies de déploiement pour vos agents adk-rust, qu'il s'agisse de la conteneurisation avec Docker, du déploiement sur des plateformes cloud ou de l'intégration dans des services Rust existants. * **Engagement communautaire** : Rejoignez la communauté adk-rust. Partager vos projets, poser des questions et contribuer aux discussions peut considérablement accélérer votre apprentissage et votre résolution de problèmes. Restez connecté aux dernières évolutions et aux meilleures pratiques.