Lanzador

El Launcher proporciona una forma sencilla y de una sola línea de ejecutar agentes ADK. En el nivel mínimo predeterminado, es un lanzador de consola ligero de adk-runner. Habilite una característica CLI opcional, como cli-openai, cuando necesite el analizador de argumentos CLI completo y el modo de servidor HTTP.

Resumen

El Lanzador está diseñado para simplificar al máximo el despliegue de agentes. Con una sola línea de código, puede:

• Ejecutar su agente en una consola interactiva para pruebas y desarrollo
• Desplegar su agente como un servidor HTTP con una interfaz de usuario web cuando se utiliza una característica de cli-* o la plantilla api de cargo-adk
• Personalizar el nombre de la aplicación y el almacenamiento de artefactos

Uso Básico

Modo Consola (Predeterminado)

La forma más sencilla de usar el Lanzador es crearlo con su agente 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 the lightweight console launcher
    Launcher::new(Arc::new(agent)).run().await
}

Ejecute su agente:

# Interactive console (default)
cargo run

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

Modo Servidor

Para ejecutar su agente como un servidor HTTP con una interfaz de usuario web, use la plantilla api o habilite una característica cli-*:

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

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 Lanzador utiliza el nombre del agente como nombre de la aplicación. Puede personalizarlo:

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

Servicio de Artefactos Personalizado

Proporcione su propia implementación del servicio de artefactos:

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 modo consola, el Lanzador:

1. Crea un servicio de sesión en memoria
2. Crea una sesión para el usuario
3. Inicia un bucle REPL interactivo
4. Transmite las respuestas del agente en tiempo real
5. Maneja las transferencias de agentes en sistemas multiagente

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 Multiagente

Al usar sistemas multiagente, la consola muestra qué agente 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 Lanzador:

1. Inicializa la telemetría para la observabilidad
2. Crea un servicio de sesión en memoria
3. Inicia un servidor HTTP con puntos finales de API REST
4. Sirve una interfaz de usuario web para interactuar con su agente

Salida de Emergencia para Producción

Para aplicaciones de producción que necesiten rutas personalizadas, middleware, métricas o control del bucle de servicio, use 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?;

Use build_app_with_a2a(...) si desea que las rutas A2A se habiliten explícitamente.

Puntos Finales Disponibles

El servidor expone los siguientes puntos finales de la API REST:

• GET /health - Punto final de verificación de estado
• POST /run_sse - Ejecutar agente con transmisión de eventos enviados por el servidor (Server-Sent Events)
• GET /sessions - Listar sesiones
• POST /sessions - Crear una nueva sesión
• GET /sessions/:app_name/:user_id/:session_id - Obtener detalles de la sesión
• DELETE /sessions/:app_name/:user_id/:session_id - Eliminar una sesión

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

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 (streaming)
• Visualización multiagente

Argumentos de CLI

El lanzador CLI completo soporta los siguientes comandos cuando una característica cli-* está habilitada:

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. Enable a `cli-*` feature for full CLI/server mode.
    Launcher::new(Arc::new(agent))
        .app_name("weather_app")
        .run()
        .await
}

Ejecutar en modo consola:

cargo run

Ejecutar en modo servidor desde un proyecto API generado:

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

Verificación Pre-Despliegue

Antes de desplegar su Agent, use cargo adk build para verificar que el proyecto compile correctamente sin realmente desplegarlo:

# Verify compilation (no deployment)
cargo adk build

# Build with release optimizations
cargo adk build --release

Esto detecta errores de compilación, dependencias faltantes y problemas de configuración antes de que se comprometa a un despliegue. Es especialmente útil en pipelines de CI como una puerta de acceso antes de cargo adk deploy.

Vea cargo adk build para la documentación completa del comando.

Mejores Prácticas

1. Variables de Entorno: Siempre cargue la configuración sensible (claves API) desde las variables de entorno
2. Manejo de Errores: Use un manejo de errores adecuado con tipos Result
3. Apagado Elegante: El Launcher maneja Ctrl+C elegantemente en ambos modos
4. Selección de Puerto: Elija puertos que no entren en conflicto con otros servicios (predeterminado 8080)
5. Gestión de Session: En producción, considere usar PostgresSessionService o SqliteSessionService en lugar de sesiones en memoria
6. Verificación Pre-Despliegue: Ejecute cargo adk build antes de desplegar para detectar problemas a tiempo

Relacionado

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

---

Anterior: ← Telemetría | Siguiente: Servidor →