Launcher

Le Launcher offre un moyen simple et en une seule ligne d'exécuter vos agents ADK avec un support intégré pour le mode console interactif et le mode serveur HTTP. Il gère l'analyse des arguments CLI, la gestion des sessions et fournit une interface cohérente pour le déploiement des agents.

Vue d'ensemble

Le Launcher 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 utilisateur web
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 Launcher est de le créer avec votre agent et d'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-2.5-flash")?);
    
    let agent = LlmAgentBuilder::new("my_agent")
        .description("A helpful assistant")
        .instruction("You are a helpful assistant.")
        .model(model)
        .build()?;
    
    // Run with CLI support (console by default)
    Launcher::new(Arc::new(agent)).run().await
}

Exécutez votre agent :

# Interactive console (default)
cargo run

# Or explicitly specify console mode
cargo run -- chat

Mode Serveur

Pour exécuter votre agent en tant que serveur HTTP avec une interface utilisateur web :

# Start server on default port (8080)
cargo run -- serve

# Start server on custom port
cargo run -- serve --port 3000

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 Launcher utilise le nom de l'agent comme nom d'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 Launcher :

Crée un service de session en mémoire
Crée une session pour l'utilisateur
Démarre une boucle REPL interactive
Diffuse les réponses de l'agent en temps réel
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 Launcher :

Initialise la télémétrie pour l'observabilité
Crée un service de session en mémoire
Démarre un serveur HTTP avec des points de terminaison d'API REST
Sert une interface utilisateur web pour interagir avec votre agent

Points de terminaison disponibles

Le serveur expose les points de terminaison d'API REST suivants :

GET /health - Point de terminaison de vérification de l'état
POST /run_sse - Exécute l'agent avec le streaming d'événements envoyés par le serveur (Server-Sent Events)
GET /sessions - Liste les sessions
POST /sessions - Crée une nouvelle session
GET /sessions/:app_name/:user_id/:session_id - Obtient les détails de la session
DELETE /sessions/:app_name/:user_id/:session_id - Supprime une session

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

Interface utilisateur web

Le serveur inclut une interface utilisateur web intégrée accessible à http://localhost:8080/ui/. L'interface utilisateur offre :

Interface de chat interactive
Gestion des sessions
Réponses en streaming en temps réel
Visualisation multi-agent

Arguments CLI

Le Launcher prend en charge les commandes CLI suivantes :

Commande	Description	Exemple
(aucune)	Console interactive (par défaut)	`cargo run`
`chat`	Console interactive (explicite)	`cargo run -- chat`
`serve`	Mode serveur HTTP	`cargo run -- serve`
`serve --port PORT`	Serveur HTTP sur un port personnalisé	`cargo run -- serve --port 3000`

Exemple complet

Voici un exemple complet montrant 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-2.5-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 (supports both console and server modes via CLI)
    Launcher::new(Arc::new(agent))
        .app_name("weather_app")
        .run()
        .await
}

Exécuter en mode console :

cargo run

Exécuter en mode serveur :

cargo run -- serve --port 8080

Bonnes pratiques

Variables d'environnement: Toujours charger les configurations sensibles (clés API) à partir des variables d'environnement
Gestion des erreurs: Utiliser une gestion des erreurs appropriée avec les types Result
Arrêt gracieux: Le Launcher gère Ctrl+C gracieusement dans les deux modes
Sélection du port: Choisir des ports qui n'entrent pas en conflit avec d'autres services (par défaut 8080)
Gestion de session: En production, envisager d'utiliser DatabaseSessionService au lieu des sessions en mémoire

Liens associés

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

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