ADK Studio

Visuelle Entwicklungsumgebung zum Erstellen von KI-Agenten per Drag-and-Drop.

Übersicht

ADK Studio bietet eine Low-Code-Schnittstelle zum Entwerfen, Testen und Bereitstellen von KI-Agenten, die mit ADK-Rust erstellt wurden. Erstellen Sie komplexe Multi-Agenten-Workflows visuell und kompilieren Sie sie dann zu produktionsfertigem Rust-Code.

Installation

# Install from crates.io (self-contained binary)
cargo install adk-studio

# Or build from source
cargo build --release -p adk-studio

Schnellstart

# Start the studio server
adk-studio

# Open in browser
open http://localhost:3000

CLI-Optionen

# Bind to all interfaces for remote access
adk-studio --host 0.0.0.0 --port 8080

# Custom projects directory
adk-studio --dir ./my-projects

---

Schritt-für-Schritt-Anleitung

Folgen Sie dieser Anleitung, um Ihren ersten KI-Agenten in ADK Studio zu erstellen.

Schritt 1: Neues Projekt erstellen

Klicken Sie auf die Schaltfläche + Neues Projekt in der oberen rechten Ecke.

Geben Sie einen Namen für Ihr Projekt ein (z.B. "Demo Projekt") und klicken Sie auf Erstellen.

Schritt 2: Agenten zur Arbeitsfläche hinzufügen

Die linke Seitenleiste enthält die Agenten-Palette mit verfügbaren Agententypen:

• LLM Agent - Einzelner KI-Agent, der von einem Sprachmodell angetrieben wird
• Sequential - Unter-Agenten der Reihe nach ausführen
• Parallel - Unter-Agenten gleichzeitig ausführen
• Loop - Iteriert, bis eine Exit-Bedingung erfüllt ist
• Router - Leitet basierend auf der Eingabe an Unter-Agenten weiter

Klicken Sie auf LLM Agent, um ihn zur Arbeitsfläche hinzuzufügen.

Schritt 3: Agenten konfigurieren

Wenn Sie einen Agenten auswählen, erscheint das Eigenschaften-Panel auf der rechten Seite. Hier können Sie Folgendes konfigurieren:

• Name - Bezeichner für den Agenten
• Modell - LLM-Anbieter und -Modell (Gemini, OpenAI, etc.)
• Anweisungen - System-Prompt für den Agenten

Schritt 4: Tools zum Agenten hinzufügen

Scrollen Sie in der linken Seitenleiste nach unten, um die Tool-Palette zu finden:

• Function - Benutzerdefinierte Rust-Funktion mit Code-Editor
• MCP - Model Context Protocol Server
• Browser - 46 WebDriver-Automatisierungsaktionen
• Google Search - Fundierte Websuche
• Load Artifact - Dateien in den Kontext laden

Klicken Sie auf ein Tool, um es Ihrem Agenten hinzuzufügen.

Schritt 5: Erstellen und Testen

Klicken Sie auf Projekt erstellen, um Ihren Agenten zu kompilieren. Nach der Erstellung verwenden Sie das Chat-Panel unten, um Ihren Agenten mit realen Konversationen zu testen.

Der Chat unterstützt:

• Live-SSE-Streaming-Antworten
• Agenten-Ausführungsanimationen
• Ereignisverfolgungs-Panel zum Debuggen

Schritt 6: Generierten Code anzeigen

Klicken Sie auf Code anzeigen, um den produktionsfertigen Rust-Code zu sehen, der aus Ihrem visuellen Design generiert wurde.

Sie können diesen Code kopieren oder Kompilieren verwenden, um ein vollständiges Rust-Projekt zu generieren.

---

Funktionen

Agententypen

Werkzeugtypen

Echtzeit-Chat

Testen Sie Agents direkt im Studio:

• Live SSE Streaming-Antworten
• Agenten-Ausführungsanimationen
• Ereignis-Trace-Panel zum Debuggen
• Persistenz des Session-Speichers

Codegenerierung

Konvertieren Sie visuelle Designs in Produktionscode:

1. Code anzeigen - Vorschau des generierten Rust mit Syntaxhervorhebung
2. Kompilieren - Generiert ein vollständiges Rust-Projekt
3. Erstellen - Kompiliert zu einer ausführbaren Datei mit Echtzeit-Ausgabe
4. Ausführen - Führt den erstellten Agent aus

Architektur

┌─────────────────────────────────────────────────────────────┐
│                     ADK Studio UI                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Palette   │  │   Canvas    │  │   Properties        │ │
│  │  - Agents   │  │  ReactFlow  │  │  - Name             │ │
│  │  - Tools    │  │  Workflow   │  │  - Model            │ │
│  │             │  │  Designer   │  │  - Instructions     │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ HTTP/SSE
┌─────────────────────────────────────────────────────────────┐
│                    ADK Studio Server                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Routes    │  │   Codegen   │  │   Storage           │ │
│  │  /api/*     │  │  Rust code  │  │  Projects           │ │
│  │  /chat      │  │  generation │  │  File-based         │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ Build
┌─────────────────────────────────────────────────────────────┐
│                   Generated Rust Project                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Cargo.toml + src/main.rs                           │   │
│  │  Uses: adk-rust, adk-agent, adk-model, etc.        │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

API-Endpunkte

Projekte

Code-Generierung

Chat

Umgebungsvariablen

Struktur des generierten Codes

my-project/
├── Cargo.toml
└── src/
    └── main.rs

Beispiel für generierte main.rs:

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.0-flash")?;

    let agent = LlmAgentBuilder::new("assistant")
        .description("Helpful AI assistant")
        .instruction("You are a helpful assistant.")
        .model(Arc::new(model))
        .build()?;

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

Vorlagen

Studio enthält vorgefertigte Vorlagen:

• Basic Assistant - Einfacher LLM-Agent
• Research Agent - Agent mit Google-Suche
• Support Router - Multi-Agenten-Routing
• Code Assistant - Agent mit Code-Tools

Bewährte Praktiken

---

Zurück: ← Speicher | Weiter: Entwicklungsrichtlinien →