Schnellstart

Erstelle deinen ersten KI-Agenten in weniger als 5 Minuten.

Voraussetzungen

• Rust 1.95.0 oder höher (rustup update stable)
• Einen OpenAI-API-Schlüssel für diese Anleitung

Schritt 1: Einen OpenAI-Server erstellen

cargo install cargo-adk
cargo adk new quickstart_agent --template api --provider openai
cd quickstart_agent

Dies erstellt ein vollständiges Rust-Projekt mit einem OpenAI-Agenten, Sitzungen im Arbeitsspeicher, der ADK-HTTP-Laufzeit, Streaming-Endpunkten und der eingebetteten Entwicklungsoberfläche.

Andere Vorlagen

# Agent with custom tools using #[tool] macro
cargo adk new my_agent --template tools

# RAG agent with Gemini embeddings and in-memory vector search
cargo adk new my_agent --template rag

# REST API server with the embedded runtime UI
cargo adk new my_agent --template api

# OpenAI GPT-5-mini agent
cargo adk new my_agent --template openai

# A2A protocol agent with builder API
cargo adk new my_agent --template a2a

# Use any provider with any template
cargo adk new my_agent --template tools --provider anthropic

# Add optional addons to any template
cargo adk new my_agent --template tools --addon docker --addon ci

Tipp: Verwende das Flag --addon, um Vorlagen mit optionalen Add-ons wie docker, ci, telemetry und weiteren zusammenzustellen. Die Seite Zusammenstellbare Vorlagen enthält die vollständige Liste mit 9 Add-ons und 5 Unternehmensmustern.

Schritt 2: Deinen Schlüssel API hinzufügen

cp .env.example .env
# Open .env and replace the OPENAI_API_KEY placeholder.

Das generierte .gitignore enthält .env nicht. Bewahre den Schlüssel lokal auf und übertrage ihn niemals in das Repository.

Schritt 3: Den Agenten ausführen

cargo run

Öffne http://127.0.0.1:8080/ui/. Der Agent wird automatisch angezeigt; du musst weder zuerst eine Sitzung erstellen noch einen Endpunkt aufrufen.

Schritt 4: In der Laufzeitoberfläche testen

Gib eine Eingabe ein, zum Beispiel:

Explain what this agent can do in three concise Markdown bullets.

Die Antwort wird in die Unterhaltung gestreamt. Verwende den Inspektor auf der rechten Seite, um die Ausführungstopologie, die chronologisch geordnete Ereigniszeitleiste, Zustandsänderungen, Artefakte, Sitzungen, Protokollfunktionen und Telemetrie zu überprüfen, ohne die Seite zu verlassen.

Diese Aufzeichnung verwendet die Showcase-Version des portablen Teams, damit die animierte Übergabe leicht zu sehen ist. Dein erzeugter Agent verwendet dieselbe Laufzeitoberfläche mit einer Topologie aus einem Knoten.

Überprüfe die HTTP-Laufzeit separat, wenn du einen Smoke-Test durchführen möchtest:

curl -fsS http://127.0.0.1:8080/api/health

Du verfügst jetzt über eine ausführbare Datei, die den Agenten ausführt, Sitzungen verwaltet, Ereignisse streamt und eine eigene Testoberfläche bereitstellt. Eine separate Frontend-Installation ist nicht erforderlich.

Einen Agenten ausschließlich im Terminal bevorzugen?

Verwende stattdessen die OpenAI-Konsolenvorlage:

cargo adk new quickstart_console --template openai
cd quickstart_console
cp .env.example .env   # replace the OPENAI_API_KEY placeholder
cargo run

---

Alternative ohne Konfiguration — adk::run()

Wenn du einfach schnell einen Agenten ohne Erstellung ausführen möchtest, verwende die Einzeile:

use adk_rust::run;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    // Minimal default: set GOOGLE_API_KEY. Add provider features for OpenAI/Anthropic.
    let response = run("You are a helpful assistant.", "Explain Rust in one sentence.").await?;
    println!("{response}");
    Ok(())
}

Dies übernimmt die Provider-Erkennung für kompilierte Provider, die Sitzungserstellung, den Aufbau des Agenten und die Ausführung in einem einzigen Aufruf. Ideal für Skripte, Prototypen und schnelle Experimente.

---

Den generierten Code verstehen

Das Gerüst von API erstellt mit src/main.rs einen gewöhnlichen LlmAgent und bindet ihn anschließend in den Standardserver ein. Die wichtige Verdrahtung ist:

use adk_rust::prelude::*;
use adk_rust::server::{ServerConfig, create_app};
use adk_rust::session::InMemorySessionService;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY")?;

    let model = adk_rust::model::openai::OpenAIClient::new(
        adk_rust::model::openai::OpenAIConfig::new(&api_key, "gpt-5.6-terra"),
    )?;

    let agent: Arc<dyn Agent> = Arc::new(
        LlmAgentBuilder::new("quickstart_agent")
            .description("REST API agent")
            .instruction("You are a helpful assistant accessible via REST API.")
            .model(Arc::new(model))
            .build()?,
    );

    let config = ServerConfig::new(
        Arc::new(adk_rust::SingleAgentLoader::new(agent)),
        Arc::new(InMemorySessionService::new()),
    );
    let app = create_app(config);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await?;
    axum::serve(listener, app).await?;
    Ok(())
}

---

Benutzerdefinierte Tools hinzufügen

Der schnellste Weg, Tools hinzuzufügen, ist das Makro #[tool]. Füge adk-tool zu deinen Abhängigkeiten hinzu:

[dependencies]
adk-tool = "2.1.0"
schemars = "1"
serde = { version = "1", features = ["derive"] }

Definiere anschließend ein Tool – der Dokumentationskommentar wird zur Beschreibung, und die Args-Struktur wird zum JSON-Schema:

use adk_tool::{tool, AdkError};
use schemars::JsonSchema;
use serde::Deserialize;
use serde_json::{json, Value};

#[derive(Deserialize, JsonSchema)]
struct WeatherArgs {
    /// The city to look up
    city: String,
}

/// Get the current weather for a city.
#[tool]
async fn get_weather(args: WeatherArgs) -> std::result::Result<Value, AdkError> {
    Ok(json!({ "temp": 22, "city": args.city, "condition": "sunny" }))
}

Das Makro generiert eine GetWeather-Struktur, die Tool implementiert. Füge sie deinem Agenten hinzu:

let agent = LlmAgentBuilder::new("weather_agent")
    .instruction("Use the get_weather tool for weather questions.")
    .model(Arc::new(model))
    .tool(Arc::new(GetWeather))  // Generated by #[tool]
    .build()?;

Tipp: Oder erstelle ein Projektgerüst mit bereits eingerichteten Tools: cargo adk new my-agent --template tools

Integrierte Tools

ADK enthält ebenfalls sofort einsatzbereite Tools:

// Google Search (handled server-side by Gemini)
.tool(Arc::new(GoogleSearchTool::new()))

// Exit a LoopAgent
.tool(Arc::new(ExitLoopTool::new()))

---

Als Webserver ausführen

Erstelle ein Serverprojektgerüst, wenn du HTTP bereitstellen möchtest:

cargo adk new my-api --template api --provider openai
cd my-api
cp .env.example .env
cargo run

Öffne http://127.0.0.1:8080/ui/. Die standardmäßige einfache Vorlage verwendet stattdessen den leichtgewichtigen Konsolen-Launcher.

---

Andere Modelle verwenden

Aktiviere Anbieter über Feature-Flags. Der Standard-Build bleibt für schnelle Installationen auf Gemini beschränkt. Füge daher nur den benötigten Anbieter hinzu:

[dependencies]
adk-rust = { version = "2.1.0", features = ["openai"] }

Oder erstelle ein Projektgerüst mit einem Anbieter: cargo adk new my-agent --provider openai

OpenAI

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

Anthropic

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

DeepSeek

let api_key = std::env::var("DEEPSEEK_API_KEY")?;
let model = DeepSeekClient::chat(api_key)?;         // standard
// let model = DeepSeekClient::reasoner(api_key)?;   // chain-of-thought

Groq

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

Ollama (lokal)

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

Unterstützte Modelle

---

Nächste Schritte

• LlmAgent Konfiguration — alle Konfigurationsoptionen
• Funktionstools — benutzerdefinierte Tools mit #[tool] erstellen
• Workflow-Agenten — sequenzielle, parallele und Schleifen-Pipelines
• Sitzungen — Konversationsstatus verwalten
• Rückruffunktionen — das Verhalten des Agenten anpassen

---

Zurück: Einführung | Weiter: LlmAgent