Launcher

Der Launcher bietet eine einfache, einzeilige Möglichkeit, Ihre ADK agents mit integrierter Unterstützung für den interaktiven console mode und den HTTP server mode auszuführen. Er handhabt das CLI Argument-Parsing, das session management und bietet eine konsistente Schnittstelle für das Deploying von agents.

Überblick

Der Launcher wurde entwickelt, um das agent deployment so einfach wie möglich zu gestalten. Mit einer einzigen Codezeile können Sie:

Ihren agent in einer interaktiven console zum Testen und zur Entwicklung ausführen
Ihren agent als HTTP server mit einer Web-UI deployen
Den application name und den artifact storage anpassen

Grundlegende Nutzung

Console Mode (Standard)

Die einfachste Möglichkeit, den Launcher zu verwenden, ist, ihn mit Ihrem agent zu erstellen und run() aufzurufen:

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
}

Führen Sie Ihren agent aus:

# Interactive console (default)
cargo run

# Or explicitly specify console mode
cargo run -- chat

Server Mode

Um Ihren agent als HTTP server mit einer Web-UI auszuführen:

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

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

Der server startet und zeigt an:

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

Konfigurationsoptionen

Benutzerdefinierter Application Name

Standardmäßig verwendet der Launcher den Namen des agents als application name. Sie können dies anpassen:

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

Benutzerdefinierter Artifact Service

Stellen Sie Ihre eigene artifact service implementation bereit:

use adk_artifact::InMemoryArtifactService;

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

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

Details zum Console Mode

Im console mode führt der Launcher folgende Schritte aus:

Erstellt einen in-memory session service
Erstellt eine session für den Benutzer
Startet eine interaktive REPL loop
Streamt agent responses in real-time
Handhabt agent transfers in multi-agent systems

Console Interaction

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

Multi-Agent Console

Bei der Verwendung von multi-agent systems zeigt die console an, welcher agent antwortet:

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.

Details zum Server-Modus

Im Server-Modus erledigt der Launcher:

Initialisiert Telemetrie für die Beobachtbarkeit
Erstellt einen In-Memory-Session-Dienst
Startet einen HTTP-Server mit REST-API-Endpunkten
Stellt eine Web-Benutzeroberfläche zur Interaktion mit Ihrem Agenten bereit

Verfügbare Endpunkte

Der Server stellt die folgenden REST-API-Endpunkte bereit:

GET /health - Endpunkt für Gesundheitsprüfung
POST /run_sse - Agenten mit Server-Sent Events-Streaming ausführen
GET /sessions - Sitzungen auflisten
POST /sessions - Eine neue Sitzung erstellen
GET /sessions/:app_name/:user_id/:session_id - Sitzungsdetails abrufen
DELETE /sessions/:app_name/:user_id/:session_id - Eine Sitzung löschen

Die Server-API-Dokumentation enthält detaillierte Spezifikationen der Endpunkte.

Web-Benutzeroberfläche

Der Server enthält eine integrierte Web-Benutzeroberfläche, die unter http://localhost:8080/ui/ zugänglich ist. Die Benutzeroberfläche bietet:

Interaktive Chat-Oberfläche
Sitzungsverwaltung
Echtzeit-Streaming-Antworten
Multi-Agenten-Visualisierung

CLI-Argumente

Der Launcher unterstützt die folgenden CLI-Befehle:

Befehl	Beschreibung	Beispiel
(keine)	Interaktive Konsole (Standard)	`cargo run`
`chat`	Interaktive Konsole (explizit)	`cargo run -- chat`
`serve`	HTTP-Server-Modus	`cargo run -- serve`
`serve --port PORT`	HTTP-Server auf benutzerdefiniertem Port	`cargo run -- serve --port 3000`

Vollständiges Beispiel

Hier ist ein vollständiges Beispiel, das beide Modi zeigt:

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
}

Im Konsolenmodus ausführen:

cargo run

Im Server-Modus ausführen:

cargo run -- serve --port 8080

Bewährte Praktiken

Environment Variables: Laden Sie sensible Konfigurationen (API-Schlüssel) immer aus Umgebungsvariablen
Error Handling: Verwenden Sie eine angemessene Fehlerbehandlung mit Result-Typen
Graceful Shutdown: Der Launcher verarbeitet Ctrl+C in beiden Modi sauber
Port Selection: Wählen Sie Ports, die nicht mit anderen Diensten kollidieren (Standard 8080)
Session Management: Ziehen Sie in der Produktion die Verwendung von DatabaseSessionService anstelle von In-Memory-Sitzungen in Betracht

Verwandt

Server-API - Detaillierte REST-API-Dokumentation
Sitzungen - Sitzungsverwaltung
Artefakte - Artefakt-Speicher
Beobachtbarkeit - Telemetrie und Protokollierung

Zurück: ← Telemetrie | Weiter: Server →