🦀ADK-Rust

Einführung in ADK-Rust

Das Agent Development Kit (ADK) ist ein flexibles und modulares Framework für die Entwicklung und Bereitstellung von KI-Agenten. Obwohl für Gemini und das Google-Ökosystem optimiert, ist ADK modellunabhängig, bereitstellungsunabhängig und für die Kompatibilität mit anderen Frameworks konzipiert. ADK wurde entwickelt, um die Agentenentwicklung softwareähnlicher zu gestalten und es Entwicklern zu erleichtern, Agentenarchitekturen zu erstellen, bereitzustellen und zu orchestrieren, die von einfachen Aufgaben bis hin zu komplexen Workflows reichen.

Hinweis: ADK-Rust v0.2.0 erfordert Rust 1.85.0 oder höher

Installation

Fügen Sie ADK-Rust Ihrem Projekt hinzu:

cargo add adk-rust

Oder fügen Sie es Ihrer Cargo.toml hinzu:

[dependencies]
adk-rust = "0.2.0"
tokio = { version = "1.40", features = ["full"] }

Kurzbeispiel

use adk_rust::prelude::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;
    
    let agent = LlmAgentBuilder::new("assistant")
        .description("A helpful AI assistant")
        .model(Arc::new(model))
        .build()?;
    
    println!("Agent '{}' ready!", agent.name());
    Ok(())
}

Architekturübersicht

ADK-Rust verwendet eine geschichtete Architektur, die auf Modularität und Erweiterbarkeit ausgelegt ist:

┌─────────────────────────────────────────────────────────────┐
│                    Anwendungsschicht                         │
│              CLI • REST-Server • Web-UI                      │
├─────────────────────────────────────────────────────────────┤
│                      Runner-Schicht                          │
│           Agenten-Ausführung • Kontextverwaltung             │
├─────────────────────────────────────────────────────────────┤
│                      Agenten-Schicht                         │
│    LlmAgent • CustomAgent • Workflow-Agenten                 │
├─────────────────────────────────────────────────────────────┤
│                     Dienstschicht                            │
│      Modelle • Tools • Sessions • Artefakte • Speicher       │
└─────────────────────────────────────────────────────────────┘

Kernkonzepte

ADK-Rust basiert auf mehreren Schlüsselprimitiven, die zusammenwirken, um leistungsstarke KI-Agenten zu erstellen:

Agenten

Die grundlegende Arbeitseinheit, die für spezifische Aufgaben konzipiert ist. ADK-Rust bietet verschiedene Agenten-Typen:

  • LlmAgent: Verwendet ein großes Sprachmodell für die Argumentation und Entscheidungsfindung. Dies ist der primäre Agenten-Typ für die meisten Anwendungsfälle.
  • RealtimeAgent: Sprachfähige Agenten, die die OpenAI Realtime API oder Gemini Live API für bidirektionales Audio-Streaming nutzen.
  • GraphAgent: Workflow-Orchestrierung im LangGraph-Stil mit Zustandsverwaltung, Checkpointing und Human-in-the-Loop-Unterstützung.
  • CustomAgent: Ermöglicht die Implementierung benutzerdefinierter Logik mit voller Kontrolle über das Agentenverhalten.
  • Workflow Agents: Deterministische Agenten, die vordefinierten Ausführungspfaden folgen:
    • SequentialAgent: Führt Sub-Agenten der Reihe nach aus
    • ParallelAgent: Führt Sub-Agenten gleichzeitig aus
    • LoopAgent: Führt Sub-Agenten iterativ aus, bis eine Bedingung erfüllt ist

Werkzeuge

Tools verleihen Agenten Fähigkeiten jenseits der Konversation, indem sie ihnen ermöglichen, mit externen APIs zu interagieren, Informationen zu suchen oder benutzerdefinierte Operationen durchzuführen:

  • FunctionTool: Wickeln Sie jede async Rust-Funktion als Tool ein
  • GoogleSearchTool: Eingebaute Web-Suchfunktion
  • BrowserToolset: 46 WebDriver-Tools für die Webautomatisierung (Navigation, Formulare, Screenshots usw.)
  • ExitLoopTool: Steuert die Schleifenbeendigung in LoopAgent
  • McpToolset: Integration mit Model Context Protocol-Servern

Sitzungen

Sessions verwalten den Kontext einer einzelnen Konversation, einschließlich:

  • Session ID: Eindeutiger Bezeichner für die Konversation
  • Events: Der Konversationsverlauf (Benutzernachrichten, Agentenantworten, Tool-Aufrufe)
  • State: Arbeitsspeicher für die Konversation mit bereichsbezogenen Präfixen (app:, user:, temp:)

Rückrufe

Benutzerdefinierter Code, der zu bestimmten Zeitpunkten in der Ausführung des Agenten ausgeführt wird:

  • before_agent / after_agent: Agenten-Aufrufe abfangen
  • before_model / after_model: LLM-Aufrufe abfangen
  • before_tool / after_tool: Tool-Ausführungen abfangen

Rückrufe ermöglichen Protokollierung, Schutzmaßnahmen, Caching und Verhaltensmodifikation.

Artefakte

Binärdatenspeicher für Dateien, Bilder oder andere Nicht-Text-Inhalte:

  • Artefakte speichern und laden mit Versionierung
  • Namespace-Bereichsdefinition (Sitzungs- oder Benutzerebene)
  • Pluggable Storage-Backends

Ereignisse

Die grundlegende Kommunikationseinheit, die Dinge darstellt, die während einer Sitzung geschehen:

  • Benutzernachrichten
  • Agentenantworten
  • Tool-Aufrufe und Ergebnisse
  • Zustandsänderungen

Ereignisse bilden den Konversationsverlauf und ermöglichen die Wiederholung und Fehlerbehebung.

Modelle

Das zugrunde liegende LLM, das LlmAgents antreibt. ADK-Rust ist für Gemini optimiert, unterstützt aber mehrere Anbieter über das Llm trait:

  • Gemini: Googles Gemini-Modelle (gemini-3-pro-preview, gemini-2.5-flash, gemini-2.5-pro)
  • OpenAI: gpt-5.2, gpt-4o, gpt-4o-mini, Azure OpenAI
  • Anthropic: claude-sonnet-4-5, claude-opus-4-5, claude-sonnet-4
  • DeepSeek: deepseek-chat, deepseek-reasoner mit Denkmodus
  • Groq: Ultraschnelle Inferenz mit llama-3.3-70b-versatile, mixtral-8x7b-32768
  • Ollama: Lokale Inferenz mit llama3.2, qwen2.5, mistral, phi4
  • mistral.rs: Hochleistungs-lokale Inferenz mit Hardwarebeschleunigung

Alle Anbieter implementieren dasselbe trait für den austauschbaren Gebrauch:

pub trait Llm: Send + Sync {
    async fn generate(&self, request: LlmRequest) -> Result<LlmResponse>;
    async fn generate_stream(&self, request: LlmRequest) -> Result<LlmResponseStream>;
}

Runner

Die Engine, die den Ausführungsfluss verwaltet, Agenteninteraktionen orchestriert und sich mit Backend-Diensten koordiniert. Der Runner übernimmt:

  • Agentenaufruf und Antwortverarbeitung
  • Tool-Ausführung
  • Sitzungs- und Zustandsverwaltung
  • Event-Streaming

Feature-Flags

adk-rust nutzt Cargo Features für Modularität:

# Full installation (default)
adk-rust = "0.2.0"

# Minimal: Only agents + Gemini
adk-rust = { version = "0.2.0", default-features = false, features = ["minimal"] }

# Custom: Pick what you need
adk-rust = { version = "0.2.0", default-features = false, features = ["agents", "gemini", "tools"] }

Verfügbare Features:

  • agents: Agent-Implementierungen (LlmAgent, CustomAgent, Workflow-Agents)
  • models: Modell-Integrationen (Gemini)
  • openai: OpenAI-Modelle (GPT-5, GPT-4o)
  • anthropic: Anthropic-Modelle (Claude 4.5, Claude 4)
  • deepseek: DeepSeek-Modelle (chat, reasoner)
  • groq: Groq ultraschnelle Inferenz
  • ollama: Lokale Ollama-Modelle
  • tools: Tool-System und integrierte Tools
  • sessions: Session-Verwaltung
  • artifacts: Artefakt-Speicherung
  • memory: Memory-System mit semantischer Suche
  • runner: Agent-Ausführungs-Runtime
  • server: HTTP-Server (REST + A2A)
  • telemetry: OpenTelemetry-Integration
  • cli: CLI-Starter

Andere Sprachen

adk ist in mehreren Sprachen verfügbar:

Weiter: Schnellstart →