Démarrage rapide

Ce guide vous montre comment démarrer rapidement avec adk-rust. Vous créerez votre premier agent IA en moins de 10 minutes.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Rust 1.85.0 ou version ultérieure (rustup update stable)
• Une clé API Google pour Gemini

Étape 1 : Créer un nouveau projet

Créez un nouveau projet Rust :

cargo new my_agent
cd my_agent

La structure de votre projet ressemblera à ceci :

my_agent/
├── Cargo.toml
├── src/
│   └── main.rs
└── .env          # Vous le créerez pour votre clé API

Étape 2 : Ajouter des dépendances

Mettez à jour votre Cargo.toml avec les dépendances requises :

[package]
name = "my_agent"
version = "0.1.0"
edition = "2024"

[dependencies]
adk-rust = "0.2.0"
tokio = { version = "1.40", features = ["full"] }
dotenvy = "0.15"

Installez les dépendances :

cargo build

Étape 3 : Configurer votre clé API

Ce projet utilise l'API Gemini, qui nécessite une clé API. Si vous n'en avez pas, créez une clé dans Google AI Studio.

Créez un fichier .env à la racine de votre projet :

Linux / macOS :

echo 'GOOGLE_API_KEY=your-api-key-here' > .env

Windows (PowerShell) :

echo GOOGLE_API_KEY=your-api-key-here > .env

Conseil de sécurité : Ajoutez .env à votre .gitignore pour éviter de commettre votre clé API.

Étape 4 : Écrire votre agent

Remplacez le contenu de src/main.rs par :

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>> {
    // Charge les variables d'environnement du fichier .env
    dotenvy::dotenv().ok();
    
    // Récupère la clé API de l'environnement
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    // Crée le modèle Gemini
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

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

    // Exécute l'agent avec le lanceur CLI
    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

Étape 5 : Exécuter votre agent

Démarrez votre agent en mode console interactif :

cargo run

Vous verrez une invite où vous pourrez discuter avec votre agent :

🤖 Agent prêt ! Saisissez vos questions (ou 'exit' pour quitter).

Vous : Bonjour ! Comment pouvez-vous m'aider ?
Assistant : Bonjour ! Je suis un assistant IA utile. Je peux vous aider avec :
- Répondre aux questions sur divers sujets
- Expliquer des concepts
- Fournir des informations et des suggestions
- Avoir une conversation amicale

Que souhaitez-vous savoir ?

Vous : exit
👋 Au revoir !

Étape 6 : Ajouter un outil

Améliorons votre agent avec l'outil Google Search pour lui donner accès à des informations en temps réel :

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>> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    // Build agent with Google Search tool
    let agent = LlmAgentBuilder::new("search_assistant")
        .description("An assistant that can search the web")
        .instruction("You are a helpful assistant. Use the search tool to find current information when needed.")
        .model(Arc::new(model))
        .tool(Arc::new(GoogleSearchTool::new()))  // Add search capability
        .build()?;

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

    Ok(())
}

Démarrez à nouveau votre agent en mode console interactive :

cargo run

Vous pouvez maintenant demander à votre agent de rechercher sur le web :

You: What's the weather like in Tokyo today?
Assistant: Let me search for that information...
[Using GoogleSearchTool]
Based on current information, Tokyo is experiencing...

Exécution en tant que serveur web

Pour une interface web, exécutez avec la commande serve :

cargo run -- serve

Ceci démarre le serveur sur le port par défaut 8080. Accédez-y à http://localhost:8080.

Pour spécifier un port personnalisé :

cargo run -- serve --port 3000

Ceci démarre le serveur sur le port 3000. Accédez-y à http://localhost:3000.

Comprendre le code

Décomposons ce que fait chaque partie :

Imports

use adk_rust::prelude::*;  // GeminiModel, LlmAgentBuilder, Arc, etc.
use adk_rust::Launcher;    // CLI launcher for console/server modes
use std::sync::Arc;        // Thread-safe reference counting pointer

• prelude::* importe tous les types couramment utilisés : GeminiModel, LlmAgentBuilder, Arc, les types d'erreurs, et plus encore
• Launcher fournit l'interface CLI pour exécuter les agents
• Arc (Atomic Reference Counted) permet le partage sécurisé du model et de l'agent entre les tâches async

Création du modèle

let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

Crée une instance de GeminiModel qui implémente le trait Llm. Le model :

• Gère l'authentification avec votre API key
• Gère les réponses en streaming de l'LLM
• Prend en charge l'appel de fonctions pour les Tool

Construction de l'agent

let agent = LlmAgentBuilder::new("my_assistant")
    .description("A helpful AI assistant")
    .instruction("You are a friendly assistant...")
    .model(Arc::new(model))
    .build()?;

Le pattern builder configure votre agent :

Launcher

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

Le Launcher gère le runtime :

• Mode console (par défaut) : Chat interactif dans votre terminal
• Mode serveur (-- serve) : API REST avec interface web
• Gère l'état de la Session, les réponses en streaming et l'arrêt gracieux

Utilisation d'autres modèles

adk-rust prend en charge plusieurs fournisseurs de LLM prêts à l'emploi. Activez-les via des flags de fonctionnalité dans votre Cargo.toml :

[dependencies]
adk-rust = { version = "0.2.0", features = ["openai", "anthropic", "deepseek", "groq", "ollama"] }

Définissez la clé API appropriée pour votre fournisseur :

# OpenAI
export OPENAI_API_KEY="your-api-key"

# Anthropic
export ANTHROPIC_API_KEY="your-api-key"

# DeepSeek
export DEEPSEEK_API_KEY="your-api-key"

# Groq
export GROQ_API_KEY="your-api-key"

# Ollama (no key needed, just run: ollama serve)

OpenAI

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>> {
    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("assistant")
        .instruction("You are a helpful assistant.")
        .model(Arc::new(model))
        .build()?;

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

    Ok(())
}

Anthropic

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>> {
    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("assistant")
        .instruction("You are a helpful assistant.")
        .model(Arc::new(model))
        .build()?;

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

    Ok(())
}

DeepSeek

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>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("DEEPSEEK_API_KEY")?;

    // Modèle de chat standard
    let model = DeepSeekClient::chat(api_key)?;

    // Ou utilisez reasoner pour le raisonnement en chaîne de pensée
    // let model = DeepSeekClient::reasoner(api_key)?;

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

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

    Ok(())
}

Groq (Inférence Ultra-Rapide)

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>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("GROQ_API_KEY")?;
    let model = GroqClient::new(GroqConfig::llama70b(api_key))?;

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

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

    Ok(())
}

Ollama (Modèles Locaux)

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>> {
    dotenvy::dotenv().ok();

    // Nécessite : ollama serve && ollama pull llama3.2
    let model = OllamaModel::new(OllamaConfig::new("llama3.2"))?;

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

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

    Ok(())
}

Modèles pris en charge

Étapes Suivantes

Maintenant que votre premier agent est en cours d'exécution, explorez ces sujets :

• Configuration de LlmAgent - Toutes les options de configuration
• Function Tools - Créer des outils personnalisés
• Workflow Agents - Construire des pipelines en plusieurs étapes
• Sessions - Gérer l'état de la conversation
• Callbacks - Personnaliser le comportement de l'agent

---

Précédent: Introduction | Suivant: LlmAgent