Starter

Launcher bietet eine einfache Möglichkeit, ADK-Agenten in einer einzigen Zeile auszuführen. In der standardmäßigen Minimalstufe ist es ein schlanker Konsolen-Starter aus adk-runner. Aktivieren Sie eine optionale CLI-Funktion wie cli-openai, wenn Sie den vollständigen CLI-Argumentparser und den HTTP-Servermodus benötigen.

Übersicht

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

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

Grundlegende Verwendung

Konsolenmodus (Standard)

Die einfachste Möglichkeit, den Starter zu verwenden, besteht darin, ihn mit Ihrem Agenten 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-3.7-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 Agenten 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 Weboberfläche auszuführen, verwenden Sie die api-Vorlage oder aktivieren Sie eine cli-*-Funktion:

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

Der Server wird gestartet und zeigt Folgendes 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 Starter den Namen des Agenten als Anwendungsnamen. Sie können ihn anpassen:

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

Benutzerdefinierter Artefaktdienst

Stellen Sie Ihre eigene Implementierung des Artefaktdienstes 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 Starter Folgendes aus:

Erstellt einen sitzungsinternen Dienst
Erstellt eine Sitzung für den Benutzer
Startet eine interaktive REPL-Schleife
Überträgt Agentenantworten in Echtzeit
Verarbeitet Agentenübergaben 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 Starter Folgendes aus:

Initialisiert Telemetrie für die Beobachtbarkeit
Erstellt einen sitzungsinternen Speicherdienst
Startet einen HTTP-Server mit REST- und API-Endpunkten
Stellt eine Web-UI zur Interaktion mit Ihrem Agenten bereit

Ausweg für den Produktiveinsatz

Für Produktionsanwendungen, die benutzerdefinierte Routen, Middleware, Metriken oder die Kontrolle über die Bereitstellungsschleife 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 die A2A-Routen explizit aktiviert werden sollen.

Verfügbare Endpunkte

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

GET /health – Endpunkt für die Zustandsprüfung
POST /run_sse – Agent mit Streaming über Server-Sent Events 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

Ausführliche Spezifikationen der Endpunkte finden Sie in der Dokumentation Server API.

Web-UI

Der Server enthält eine integrierte Web-UI, die unter http://localhost:8080/ui/ erreichbar ist. Die UI bietet:

Interaktive Chat-Oberfläche
Inspektion von Sitzung, Zustand, Artefakten und Ereigniszeitleiste
Antworten und Tool-Aktivitäten im Echtzeit-Streaming
Exakte Delegations- und Übergabetopologie des Teams
Erkennung der Fähigkeiten von Agent und UI-Protokoll

CLI-Argumente

Der vollständige CLI-Launcher unterstützt die folgenden Befehle, wenn ein cli-*-Feature aktiviert ist:

Befehl	Beschreibung	Beispiel
(keiner)	Interaktive Konsole (Standard)	`cargo run`
`chat`	Interaktive Konsole (explizit)	`cargo run -- chat`
`serve`	HTTP Servermodus	`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-3.7-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 aus einem generierten API-Projekt ausführen:

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

Überprüfung vor der Bereitstellung

Verwenden Sie vor der Bereitstellung Ihres Agents cargo adk build, um zu überprüfen, dass 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

Dadurch werden Kompilierungsfehler, fehlende Abhängigkeiten und Konfigurationsprobleme erkannt, bevor Sie sich für eine Bereitstellung entscheiden. Dies ist besonders nützlich in CI-Pipelines als Prüfung vor cargo adk deploy.

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

Bewährte Vorgehensweisen

Umgebungsvariablen: Laden Sie vertrauliche Konfigurationen (API-Schlüssel) immer aus Umgebungsvariablen
Fehlerbehandlung: Verwenden Sie eine geeignete Fehlerbehandlung mit Result-Typen
Geordnetes Herunterfahren: Der Launcher behandelt 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 Sitzungen im Arbeitsspeicher in Betracht
Prüfung vor der Bereitstellung: Führen Sie cargo adk build vor der Bereitstellung aus, um Probleme frühzeitig zu erkennen

Server API – Ausführliche Dokumentation zu REST API
Sitzungen – Sitzungsverwaltung
Artefakte – Artefaktspeicherung
Beobachtbarkeit – Telemetrie und Protokollierung

Zurück: ← Telemetrie | Weiter: Server →