Launcher

El Launcher proporciona una manera simple y de una sola línea de ejecutar sus Agents ADK con soporte incorporado tanto para el modo de consola interactiva como para el modo de servidor HTTP. Maneja el análisis de argumentos CLI, la gestión de Sessiones y proporciona una interfaz consistente para desplegar Agents.

Resumen

El Launcher está diseñado para hacer el despliegue de Agents lo más simple posible. Con una sola línea de código, puede:

Ejecutar su Agent en una consola interactiva para pruebas y desarrollo
Desplegar su Agent como un servidor HTTP con una UI web
Personalizar el nombre de la aplicación y el almacenamiento de artifacts

Uso Básico

Modo Consola (Predeterminado)

La forma más sencilla de usar el Launcher es crearlo con su Agent y llamar a 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
}

Ejecute su Agent:

# Interactive console (default)
cargo run

# Or explicitly specify console mode
cargo run -- chat

Modo Servidor

Para ejecutar su Agent como un servidor HTTP con una UI web:

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

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

El servidor se iniciará y mostrará:

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

Opciones de Configuración

Nombre de Aplicación Personalizado

Por defecto, el Launcher usa el nombre del Agent como nombre de la aplicación. Puede personalizarlo:

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

Servicio de Artifact Personalizado

Proporcione su propia implementación de servicio de artifact:

use adk_artifact::InMemoryArtifactService;

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

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

Detalles del Modo Consola

En el modo consola, el Launcher:

Crea un servicio de Session en memoria
Crea una Session para el usuario
Inicia un bucle REPL interactivo
Transmite las respuestas del Agent en tiempo real
Maneja las transferencias de Agent en sistemas multi-agent

Interacción en Consola

🤖 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!

Consola Multi-Agent

Cuando se usan sistemas multi-agent, la consola muestra qué Agent está respondiendo:

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.

Detalles del Modo Servidor

En modo servidor, el Launcher:

Inicializa la telemetría para la observabilidad
Crea un servicio de sesión en memoria
Inicia un servidor HTTP con puntos de conexión de la API REST
Sirve una interfaz de usuario web para interactuar con su Agent

Puntos de Conexión Disponibles

El servidor expone los siguientes puntos de conexión de la API REST:

GET /health - Punto de conexión de verificación de estado
POST /run_sse - Ejecuta el Agent con transmisión de Server-Sent Events
GET /sessions - Lista las sesiones
POST /sessions - Crea una nueva sesión
GET /sessions/:app_name/:user_id/:session_id - Obtiene los detalles de la sesión
DELETE /sessions/:app_name/:user_id/:session_id - Elimina una sesión

Consulte la documentación de la API del Servidor para especificaciones detalladas de los puntos de conexión.

Interfaz de Usuario Web

El servidor incluye una interfaz de usuario web integrada accesible en http://localhost:8080/ui/. La interfaz de usuario proporciona:

Interfaz de chat interactiva
Gestión de sesiones
Respuestas en tiempo real
Visualización multi-Agent

Argumentos de CLI

El Launcher admite los siguientes comandos de CLI:

Comando	Descripción	Ejemplo
(ninguno)	Consola interactiva (predeterminado)	`cargo run`
`chat`	Consola interactiva (explícita)	`cargo run -- chat`
`serve`	Modo servidor HTTP	`cargo run -- serve`
`serve --port PORT`	Servidor HTTP en puerto personalizado	`cargo run -- serve --port 3000`

Ejemplo Completo

Aquí hay un ejemplo completo que muestra ambos modos:

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
}

Ejecutar en modo consola:

cargo run

Ejecutar en modo servidor:

cargo run -- serve --port 8080

Buenas Prácticas

Variables de Entorno: Siempre cargue la configuración sensible (claves de API) desde variables de entorno
Manejo de Errores: Utilice un manejo de errores adecuado con tipos Result
Apagado Elegante: El Launcher maneja Ctrl+C elegantemente en ambos modos
Selección de Puerto: Elija puertos que no entren en conflicto con otros servicios (predeterminado 8080)
Gestión de Sesiones: En producción, considere usar DatabaseSessionService en lugar de sesiones en memoria

Relacionado

API del Servidor - Documentación detallada de la API REST
Sesiones - Gestión de sesiones
Artefactos - Almacenamiento de artefactos
Observabilidad - Telemetría y registro

Anterior: ← Telemetría | Siguiente: Servidor →