Launcher

Der Launcher bietet eine einfache, einzeilige Möglichkeit, ADK-Agents auszuführen. In der standardmäßigen minimalen Stufe ist es ein schlanker Konsolen-Launcher von adk-runner. Aktivieren Sie eine optionale CLI-Funktion wie cli-openai, wenn Sie den vollständigen CLI-Argument-Parser und den HTTP-Server-Modus benötigen.

Übersicht

Der Launcher wurde entwickelt, um die Bereitstellung von Agents so einfach wie möglich zu gestalten. Mit einer einzigen Codezeile können Sie:

Ihren Agent in einer interaktiven Konsole zum Testen und Entwickeln ausführen
Ihren Agent als HTTP-Server mit einer Web-Benutzeroberfläche bereitstellen, wenn eine cli-*-Funktion oder die cargo-adk api-Vorlage verwendet wird
Den Anwendungsnamen und die Artefaktspeicherung anpassen

Grundlegende Verwendung

Konsolenmodus (Standard)

Die einfachste Möglichkeit, den Launcher zu verwenden, besteht darin, 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 the lightweight console launcher
    Launcher::new(Arc::new(agent)).run().await
}

Führen Sie Ihren Agent aus:

# Interactive console (default)
cargo run

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

Servermodus

Um Ihren Agenten als HTTP-Server mit einer Web-Benutzeroberfläche auszuführen, verwenden Sie das api Template oder aktivieren Sie ein cli-* Feature:

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

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 Anwendungsname

Standardmäßig verwendet der Launcher den Namen des Agenten als Anwendungsnamen. Sie können dies anpassen:

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

Benutzerdefinierter Artefakt-Dienst

Stellen Sie Ihre eigene Implementierung des Artefakt-Dienstes 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 Konsolenmodus

Im Konsolenmodus führt der Launcher folgende Aktionen aus:

Erstellt einen In-Memory-Sitzungsdienst
Erstellt eine Sitzung für den Benutzer
Startet eine interaktive REPL-Schleife
Streamt Agentenantworten in Echtzeit
Verarbeitet Agentenübertragungen in Multi-Agenten-Systemen

Konsoleninteraktion

🤖 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-Agenten-Konsole

Bei der Verwendung von Multi-Agenten-Systemen zeigt die Konsole 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 Servermodus

Im Servermodus führt der Launcher folgende Aktionen aus:

Initialisiert Telemetrie für Observability
Erstellt einen In-Memory Session Service
Startet einen HTTP-Server mit REST-API-Endpunkten
Stellt eine Web-UI zur Interaktion mit Ihrem Agent bereit

Produktions-Notausgang

Für Produktionsanwendungen, die benutzerdefinierte Routen, Middleware, Metriken oder die Kontrolle über den Serve-Loop benötigen, verwenden Sie 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?;

Verwenden Sie build_app_with_a2a(...), wenn Sie die A2A-Routen explizit aktivieren möchten.

Verfügbare Endpunkte

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

GET /health - Health-Check-Endpunkt
POST /run_sse - Führt den Agent mit Server-Sent Events Streaming aus
GET /sessions - Listet Sessions auf
POST /sessions - Erstellt eine neue Session
GET /sessions/:app_name/:user_id/:session_id - Ruft Session-Details ab
DELETE /sessions/:app_name/:user_id/:session_id - Löscht eine Session

Siehe die Server API-Dokumentation für detaillierte Endpunkt-Spezifikationen.

Web-UI

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 vollständige CLI-Launcher unterstützt die folgenden Befehle, wenn eine cli-*-Funktion aktiviert ist:

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

Im Konsolenmodus ausführen:

cargo run

Im Servermodus von einem generierten API-Projekt ausführen:

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

Verifizierung vor der Bereitstellung

Bevor Sie Ihren Agent bereitstellen, verwenden Sie cargo adk build, um zu überprüfen, ob das Projekt korrekt kompiliert wird, ohne es tatsächlich bereitzustellen:

# Verify compilation (no deployment)
cargo adk build

# Build with release optimizations
cargo adk build --release

Dies fängt Kompilierungsfehler, fehlende Abhängigkeiten und Konfigurationsprobleme ab, bevor Sie sich zu einer Bereitstellung verpflichten. Es ist besonders nützlich in CI-Pipelines als Gate vor cargo adk deploy.

Siehe cargo adk build für die vollständige Befehlsdokumentation.

Bewährte Verfahren

Umgebungsvariablen: Laden Sie sensible Konfigurationen (API-Schlüssel) immer aus Umgebungsvariablen
Fehlerbehandlung: Verwenden Sie eine ordnungsgemäße Fehlerbehandlung mit Result-Typen
Geordnetes Herunterfahren: Der Launcher verarbeitet Strg+C in beiden Modi ordnungsgemäß
Portauswahl: Wählen Sie Ports, die nicht mit anderen Diensten in Konflikt stehen (Standard 8080)
Sitzungsverwaltung: Ziehen Sie in der Produktion die Verwendung von PostgresSessionService oder SqliteSessionService anstelle von In-Memory-Sitzungen in Betracht
Überprüfung vor der Bereitstellung: Führen Sie cargo adk build vor der Bereitstellung aus, um Probleme frühzeitig zu erkennen

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

Zurück: ← Telemetrie | Weiter: Server →