Schnellstart

Dieser Leitfaden zeigt Ihnen, wie Sie mit ADK-Rust schnell einsatzbereit sind. Sie erstellen Ihren ersten KI-Agenten in weniger als 10 Minuten.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Rust 1.85.0 oder neuer (rustup update stable)
• Einen Google API key für Gemini

Schritt 1: Neues Projekt erstellen

Erstellen Sie ein neues Rust-Projekt:

cargo new my_agent
cd my_agent

Ihre Projektstruktur wird wie folgt aussehen:

my_agent/
├── Cargo.toml
├── src/
│   └── main.rs
└── .env          # Dies erstellen Sie für Ihren API key

Schritt 2: Abhängigkeiten hinzufügen

Aktualisieren Sie Ihre Cargo.toml mit den erforderlichen Abhängigkeiten:

[package]
name = "my_agent"
version = "0.1.0"
edition = "2024"

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

Installieren Sie die Abhängigkeiten:

cargo build

Schritt 3: Richten Sie Ihren API Key ein

Dieses Projekt verwendet die Gemini API, die einen API key erfordert. Falls Sie keinen haben, erstellen Sie einen Schlüssel in Google AI Studio.

Erstellen Sie eine .env-Datei in Ihrem Projekt-Stammverzeichnis:

Linux / macOS:

echo 'GOOGLE_API_KEY=your-api-key-here' > .env

Windows (PowerShell):

echo GOOGLE_API_KEY=your-api-key-here > .env

Sicherheitstipp: Fügen Sie .env zu Ihrer .gitignore hinzu, um zu vermeiden, dass Ihr API key committet wird.

Schritt 4: Schreiben Sie Ihren Agenten

Ersetzen Sie den Inhalt von src/main.rs durch:

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    // Umgebungsvariablen aus der .env-Datei laden
    dotenvy::dotenv().ok();
    
    // API key aus der Umgebung abrufen
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    // Erstellen Sie das GeminiModel
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    // Bauen Sie Ihren Agenten
    let agent = LlmAgentBuilder::new("my_assistant")
        .description("A helpful AI assistant")
        .instruction("You are a friendly and helpful assistant. Answer questions clearly and concisely.")
        .model(Arc::new(model))
        .build()?;

    // Führen Sie den Agenten mit dem CLI-Launcher aus
    Launcher::new(Arc::new(agent)).run().await?;

    Ok(())
}

Schritt 5: Führen Sie Ihren Agenten aus

Starten Sie Ihren Agenten im interaktiven Konsolenmodus:

cargo run

Sie sehen eine Eingabeaufforderung, in der Sie mit Ihrem Agenten chatten können:

🤖 Agent ready! Type your questions (or 'exit' to quit).

You: Hallo! Wobei können Sie mir helfen?
Assistant: Hallo! Ich bin ein hilfsbereiter KI-Assistent. Ich kann Ihnen bei Folgendem helfen:
- Beantwortung von Fragen zu verschiedenen Themen
- Erklärung von Konzepten
- Bereitstellung von Informationen und Vorschlägen
- Führung einer freundlichen Unterhaltung

Was möchten Sie wissen?

You: exit
👋 Auf Wiedersehen!

Schritt 6: Ein Tool hinzufügen

Erweitern wir Ihren Agenten mit dem Google Search Tool, um ihm Zugriff auf Echtzeitinformationen zu ermöglichen:

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    // Build agent with Google Search tool
    let agent = LlmAgentBuilder::new("search_assistant")
        .description("An assistant that can search the web")
        .instruction("You are a helpful assistant. Use the search tool to find current information when needed.")
        .model(Arc::new(model))
        .tool(Arc::new(GoogleSearchTool::new()))  // Add search capability
        .build()?;

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

    Ok(())
}

Starten Sie Ihren Agenten erneut im interaktiven Konsolenmodus:

cargo run

Jetzt können Sie Ihren Agenten auffordern, das Web zu durchsuchen:

You: Wie ist das Wetter heute in Tokio?
Assistant: Lassen Sie mich diese Informationen suchen...
[Using GoogleSearchTool]
Basierend auf aktuellen Informationen erlebt Tokio...

Als Webserver ausführen

Für eine webbasierte Oberfläche starten Sie den Agenten mit dem serve-Befehl:

cargo run -- serve

Dies startet den Server auf dem Standard-Port 8080. Greifen Sie unter http://localhost:8080 darauf zu.

Um einen benutzerdefinierten Port anzugeben:

cargo run -- serve --port 3000

Dies startet den Server auf Port 3000. Greifen Sie unter http://localhost:3000 darauf zu.

Den Code verstehen

Lassen Sie uns aufschlüsseln, was jeder Teil tut:

Importe

use adk_rust::prelude::*;  // GeminiModel, LlmAgentBuilder, Arc, etc.
use adk_rust::Launcher;    // CLI launcher for console/server modes
use std::sync::Arc;        // Thread-safe reference counting pointer

• prelude::* importiert alle häufig verwendeten Typen: GeminiModel, LlmAgentBuilder, Arc, Fehlertypen und mehr
• Launcher bietet die CLI-Schnittstelle zum Ausführen von Agenten
• Arc (Atomic Reference Counted) ermöglicht das sichere Teilen des Modells und des Agenten über async-Aufgaben hinweg

Modellerstellung

let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

Erstellt eine Gemini model-Instanz, die das Llm-trait implementiert. Das Modell:

• Handhabt die Authentifizierung mit Ihrem API-Schlüssel
• Verwaltet Streaming-Antworten vom LLM
• Unterstützt das Aufrufen von Funktionen für Tools

Agenten-Erstellung

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

Das Builder-Pattern konfiguriert Ihren Agenten:

Launcher

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

Der Launcher handhabt die Laufzeit:

• Konsolenmodus (Standard): Interaktiver Chat in Ihrem Terminal
• Servermodus (-- serve): REST API mit Weboberfläche
• Verwaltet den Sitzungszustand, Streaming-Antworten und das ordnungsgemäße Herunterfahren

Andere Modelle verwenden

adk-rust unterstützt mehrere LLM Anbieter sofort. Aktiviere sie über Feature-Flags in deiner Cargo.toml:

[dependencies]
adk-rust = { version = "0.2.0", features = ["openai", "anthropic", "deepseek", "groq", "ollama"] }

Lege den entsprechenden API-Schlüssel für deinen Anbieter fest:

# OpenAI
export OPENAI_API_KEY="your-api-key"

# Anthropic
export ANTHROPIC_API_KEY="your-api-key"

# DeepSeek
export DEEPSEEK_API_KEY="your-api-key"

# Groq
export GROQ_API_KEY="your-api-key"

# Ollama (no key needed, just run: ollama serve)

OpenAI

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("OPENAI_API_KEY")?;
    let model = OpenAIClient::new(OpenAIConfig::new(api_key, "gpt-4o"))?;

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

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

    Ok(())
}

Anthropic

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("ANTHROPIC_API_KEY")?;
    let model = AnthropicClient::new(AnthropicConfig::new(api_key, "claude-sonnet-4-20250514"))?;

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

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

    Ok(())
}

DeepSeek

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("DEEPSEEK_API_KEY")?;

    // Standard chat model
    let model = DeepSeekClient::chat(api_key)?;

    // Or use reasoner for chain-of-thought reasoning
    // let model = DeepSeekClient::reasoner(api_key)?;

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

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

    Ok(())
}

Groq (Ultra-schnelle Inferenz)

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    let api_key = std::env::var("GROQ_API_KEY")?;
    let model = GroqClient::new(GroqConfig::llama70b(api_key))?;

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

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

    Ok(())
}

Ollama (Lokale Modelle)

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

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    // Requires: ollama serve && ollama pull llama3.2
    let model = OllamaModel::new(OllamaConfig::new("llama3.2"))?;

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

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

    Ok(())
}

Unterstützte Modelle

Nächste Schritte

Nachdem Sie Ihren ersten Agenten erfolgreich ausgeführt haben, erkunden Sie diese Themen:

• LlmAgent-Konfiguration - Alle Konfigurationsoptionen
• Function Tools - Erstellen Sie benutzerdefinierte Tools
• Workflow Agents - Erstellen Sie mehrstufige Pipelines
• Sessions - Verwalten Sie den Konversationsstatus
• Callbacks - Passen Sie das Agenten-Verhalten an

---

Zurück: Einführung | Weiter: LlmAgent