Lanceur

Le Launcher fournit une méthode simple, en une seule ligne, pour exécuter des agents ADK. Dans le niveau minimal par défaut, il s’agit d’un lanceur léger pour console provenant de adk-runner. Activez une fonctionnalité CLI facultative telle que cli-openai lorsque vous avez besoin de l’analyseur d’arguments CLI complet et du mode serveur HTTP.

Vue d’ensemble

Le lanceur est conçu pour rendre le déploiement d’agents aussi simple que possible. Avec une seule ligne de code, vous pouvez :

• Exécuter votre agent dans une console interactive pour les tests et le développement
• Déployer votre agent en tant que serveur HTTP avec une interface web lorsqu’une fonctionnalité cli-* ou le modèle api cargo-adk est utilisé
• Personnaliser le nom de l’application et le stockage des artefacts

Utilisation de base

Mode console (par défaut)

La manière la plus simple d’utiliser le lanceur consiste à le créer avec votre agent et à appeler run() :

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-3.7-flash")?);
    
    let agent = LlmAgentBuilder::new("my_agent")
        .description("A helpful assistant")
        .instruction("You are a helpful assistant.")
        .model(model)
        .build()?;
    
    // Run with the lightweight console launcher
    Launcher::new(Arc::new(agent)).run().await
}

Exécutez votre agent :

# Interactive console (default)
cargo run

# Full CLI mode is available when your app enables a `cli-*` feature

Mode serveur

Pour exécuter votre agent en tant que serveur HTTP avec une interface web, utilisez le modèle api ou activez une fonctionnalité cli-* :

cargo adk new my-api --template api
cd my-api
cargo run

Le serveur démarrera et affichera :

🚀 ADK Server starting on http://localhost:8080
📱 Open http://localhost:8080 in your browser
Press Ctrl+C to stop

Options de configuration

Nom d’application personnalisé

Par défaut, le lanceur utilise le nom de l’agent comme nom de l’application. Vous pouvez le personnaliser :

Launcher::new(Arc::new(agent))
    .app_name("my_custom_app")
    .run()
    .await

Service d’artefacts personnalisé

Fournissez votre propre implémentation de service d’artefacts :

use adk_artifact::InMemoryArtifactService;

let artifact_service = Arc::new(InMemoryArtifactService::new());

Launcher::new(Arc::new(agent))
    .with_artifact_service(artifact_service)
    .run()
    .await

Détails du mode console

En mode console, le lanceur :

1. Crée un service de session en mémoire
2. Crée une session pour l’utilisateur
3. Démarre une boucle REPL interactive
4. Diffuse les réponses de l’agent en temps réel
5. Gère les transferts d’agents dans les systèmes multi-agents

Interaction avec la console

🤖 Agent ready! Type your questions (or 'exit' to quit).

You: What is the capital of France?
Assistant: The capital of France is Paris.

You: exit
👋 Goodbye!

Console multi-agents

Lors de l’utilisation de systèmes multi-agents, la console indique quel agent répond :

You: I need help with my order

[Agent: customer_service]
Assistant: I'll help you with your order. What's your order number?

You: ORDER-12345

🔄 [Transfer requested to: order_lookup]

[Agent: order_lookup]
Assistant: I found your order. It was shipped yesterday.

Détails du mode serveur

En mode serveur, le lanceur :

1. Initialise la télémétrie pour l’observabilité
2. Crée un service de session en mémoire
3. Démarre un serveur HTTP avec des points de terminaison REST API
4. Sert une interface web pour interagir avec votre agent

Solution de secours pour la production

Pour les applications de production qui nécessitent des routes personnalisées, des intergiciels, des métriques ou la maîtrise de la boucle de service, utilisez build_app() :

let app = Launcher::new(Arc::new(agent))
    .with_a2a_base_url("https://agent.example.com")
    .build_app()?;

let app = app.merge(my_admin_routes());
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
axum::serve(listener, app).await?;

Utilisez build_app_with_a2a(...) si vous souhaitez activer explicitement les routes A2A.

Points de terminaison disponibles

Le serveur expose les points de terminaison REST API suivants :

• GET /health - Point de terminaison de vérification de l’état
• POST /run_sse - Exécuter l’agent avec un flux d’événements envoyés par le serveur
• GET /sessions - Répertorier les sessions
• POST /sessions - Créer une nouvelle session
• GET /sessions/:app_name/:user_id/:session_id - Obtenir les détails d’une session
• DELETE /sessions/:app_name/:user_id/:session_id - Supprimer une session

Consultez la documentation Serveur API pour obtenir les spécifications détaillées des points de terminaison.

Interface web

Le serveur inclut une interface web intégrée accessible à l’adresse http://localhost:8080/ui/. L’interface fournit :

• Une interface de discussion interactive
• L’inspection des sessions, de l’état, des artefacts et de la chronologie des événements
• Des réponses diffusées en temps réel et l’activité des outils
• La délégation exacte de l’équipe et la topologie des transferts
• La découverte des capacités de l’agent et du protocole de l’interface utilisateur

Arguments de CLI

Le lanceur CLI complet prend en charge les commandes suivantes lorsqu’une fonctionnalité cli-* est activée :

Exemple complet

Voici un exemple complet présentant les deux modes :

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    // Load API key
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");
    
    // Create model
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-3.7-flash")?);
    
    // Create agent with tools
    let weather_tool = FunctionTool::new(
        "get_weather",
        "Get the current weather for a location",
        |params, _ctx| async move {
            let location = params["location"].as_str().unwrap_or("unknown");
            Ok(json!({
                "location": location,
                "temperature": 72,
                "condition": "sunny"
            }))
        },
    );
    
    let agent = LlmAgentBuilder::new("weather_agent")
        .description("An agent that provides weather information")
        .instruction("You are a weather assistant. Use the get_weather tool to provide weather information.")
        .model(model)
        .tool(Arc::new(weather_tool))
        .build()?;
    
    // Run with Launcher. Enable a `cli-*` feature for full CLI/server mode.
    Launcher::new(Arc::new(agent))
        .app_name("weather_app")
        .run()
        .await
}

Exécuter en mode console :

cargo run

Exécuter en mode serveur depuis un projet API généré :

cargo adk new weather-api --template api
cd weather-api
cargo run

Vérification avant déploiement

Avant de déployer votre agent, utilisez cargo adk build pour vérifier que le projet se compile correctement sans procéder au déploiement :

# Verify compilation (no deployment)
cargo adk build

# Build with release optimizations
cargo adk build --release

Cela permet de détecter les erreurs de compilation, les dépendances manquantes et les problèmes de configuration avant de procéder au déploiement. C’est particulièrement utile dans les pipelines CI comme étape de contrôle avant cargo adk deploy.

Consultez cargo adk build pour obtenir la documentation complète de la commande.

Bonnes pratiques

1. Variables d’environnement : chargez toujours les configurations sensibles (clés API) depuis des variables d’environnement
2. Gestion des erreurs : utilisez une gestion appropriée des erreurs avec les types Result
3. Arrêt progressif : le Launcher gère correctement Ctrl+C dans les deux modes
4. Sélection des ports : choisissez des ports qui n’entrent pas en conflit avec d’autres services (8080 par défaut)
5. Gestion des sessions : en production, envisagez d’utiliser PostgresSessionService ou SqliteSessionService plutôt que des sessions en mémoire
6. Vérification avant déploiement : exécutez cargo adk build avant le déploiement afin de détecter rapidement les problèmes

Voir aussi

• Serveur API - Documentation détaillée de REST API
• Sessions - Gestion des sessions
• Artefacts - Stockage des artefacts
• Observabilité - Télémétrie et journalisation

---

Précédent : ← Télémétrie | Suivant : Serveur →