Launcher

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

Aperçu

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 lorsqu'une fonctionnalité cli-* ou le template cargo-adk api 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 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 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 utilisateur web, utilisez le template 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 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 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
Fournit une interface utilisateur 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 middlewares, des métriques ou la gestion 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 que les routes A2A soient explicitement activées.

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 de santé
POST /run_sse - Exécute l'agent avec la diffusion en continu des événements envoyés par le serveur
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 fournit :

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

Arguments de la CLI

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

Commande	Description	Exemple
(aucun)	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 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. 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 le déploiement

Avant de déployer votre agent, utilisez cargo adk build pour vérifier que le projet compile correctement sans réellement déployer :

# 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 s'engager dans un déploiement. C'est particulièrement utile dans les pipelines CI comme barrière avant cargo adk deploy.

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

Bonnes pratiques

Variables d'environnement : Toujours charger les configurations sensibles (clés API) depuis les 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 de 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 PostgresSessionService ou SqliteSessionService au lieu de sessions en mémoire
Vérification pré-déploiement : Exécuter cargo adk build avant de déployer pour détecter les problèmes tôt

API du Serveur - Documentation détaillée de l'API REST
Sessions - Gestion des sessions
Artéfacts - Stockage des artéfacts
Observabilité - Télémétrie et journalisation

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