Integrierte Tools

adk-rust bietet mehrere integrierte Tools, die die Fähigkeiten von Agenten erweitern, ohne eine benutzerdefinierte Implementierung zu erfordern. Diese Tools sind sofort einsatzbereit und lassen sich nahtlos in das Agent-Framework integrieren.

Übersicht

GoogleSearchTool

GoogleSearchTool ermöglicht Agenten die Websuche mit Google Search. Dieses Tool wird intern von Gemini Modellen durch die Grounding-Funktion gehandhabt, was bedeutet, dass die Suche serverseitig vom Modell selbst durchgeführt wird.

Grundlegende Verwendung

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")?;

    // Erstelle das GoogleSearchTool
    let search_tool = GoogleSearchTool;

    // Zum Agenten hinzufügen
    let agent = LlmAgentBuilder::new("research_assistant")
        .description("An assistant that can search the web for information")
        .instruction(
            "You are a research assistant. When asked about current events, \
             recent news, or factual information, use the google_search tool \
             to find accurate, up-to-date information."
        )
        .model(Arc::new(model))
        .tool(Arc::new(search_tool))
        .build()?;

    println!("Agent mit Google Search-Fähigkeit erstellt!");
    Ok(())
}

Funktionsweise

Im Gegensatz zu regulären FunctionTools funktioniert GoogleSearchTool anders:

1. Serverseitige Ausführung: Die Suche wird von Geminis Grounding-Funktion durchgeführt, nicht lokal
2. Automatische Aufrufung: Das Modell entscheidet, wann es basierend auf der Abfrage suchen soll
3. Integrierte Ergebnisse: Suchergebnisse werden direkt in die Antwort des Modells integriert

Die Tool-Implementierung gibt einen Fehler zurück, wenn sie direkt aufgerufen wird, da die eigentliche Suche innerhalb der Gemini API stattfindet:

// Dies wird intern gehandhabt – Sie rufen es nicht direkt auf
async fn execute(&self, _ctx: Arc<dyn ToolContext>, _args: Value) -> Result<Value> {
    Err(AdkError::Tool("GoogleSearch is handled internally by Gemini".to_string()))
}

Tool-Details

Anwendungsfälle

• Aktuelle Ereignisse: "Was ist heute in den Nachrichten passiert?"
• Faktische Abfragen: "Wie hoch ist die Einwohnerzahl von Tokio?"
• Aktuelle Informationen: "Was sind die neuesten Entwicklungen in der KI?"
• Rechercheaufgaben: "Finde Informationen zu Trends bei erneuerbaren Energien"

Beispielabfragen

// Der Agent wird Google Search automatisch für Abfragen wie diese verwenden:
// - "Wie ist die Wettervorhersage für New York diese Woche?"
// - "Wer hat das letzte Meisterschaftsspiel gewonnen?"
// - "Wie sind die aktuellen Aktienkurse von Technologieunternehmen?"

ExitLoopTool

ExitLoopTool ist ein Steuerungstool, das mit LoopAgent verwendet wird, um zu signalisieren, wann ein iterativer Prozess beendet werden soll. Wenn es aufgerufen wird, setzt es das escalate-Flag, wodurch die Schleife beendet wird.

Grundlegende Verwendung

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")?;

    // Erstellt einen Agenten mit ExitLoopTool zur iterativen Verfeinerung
    let refiner = LlmAgentBuilder::new("content_refiner")
        .description("Iteratively improves content quality")
        .instruction(
            "Review the content and improve it. Check for:\n\
             1. Clarity and readability\n\
             2. Grammar and spelling\n\
             3. Logical flow\n\n\
             If the content meets all quality standards, call the exit_loop tool.\n\
             Otherwise, provide an improved version."
        )
        .model(Arc::new(model))
        .tool(Arc::new(ExitLoopTool::new()))
        .build()?;

    // Verwendung in einem LoopAgent
    let loop_agent = LoopAgent::new(
        "iterative_refiner",
        vec![Arc::new(refiner)],
    ).with_max_iterations(5);

    println!("Loop agent created with exit capability!");
    Ok(())
}

Funktionsweise

1. Der Agent bewertet, ob fortgefahren oder beendet werden soll
2. Wenn bereit zum Beenden, ruft der Agent exit_loop auf
3. Das Tool setzt actions.escalate = true und actions.skip_summarization = true
4. Der LoopAgent erkennt das escalate-Flag und stoppt die Iteration

Tool-Details

Best Practices

1. Klare Abbruchkriterien: Definieren Sie spezifische Bedingungen in der Anweisung des Agenten
2. Immer max_iterations setzen: Verhindern Sie Endlosschleifen als Sicherheitsmaßnahme
3. Sinnvolle Anweisungen: Helfen Sie dem Agenten zu verstehen, wann er beenden soll

// Gut: Klare Abbruchkriterien
.instruction(
    "Improve the text until it:\n\
     - Has no grammatical errors\n\
     - Is under 100 words\n\
     - Uses active voice\n\
     When all criteria are met, call exit_loop."
)

// Vermeiden: Vage Kriterien
.instruction("Improve the text. Exit when done.")

LoadArtifactsTool

LoadArtifactsTool ermöglicht Agenten, gespeicherte Artefakte anhand ihres Namens abzurufen. Dies ist nützlich, wenn Agenten auf zuvor gespeicherte Dateien, Bilder oder andere Binärdaten zugreifen müssen.

Grundlegende Nutzung

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")?;

    // Create agent with artifact loading capability
    let agent = LlmAgentBuilder::new("document_analyzer")
        .description("Analyzes stored documents")
        .instruction(
            "You can load and analyze stored artifacts. \
             Use the load_artifacts tool to retrieve documents by name. \
             The tool accepts an array of artifact names."
        )
        .model(Arc::new(model))
        .tool(Arc::new(LoadArtifactsTool::new()))
        .build()?;

    println!("Agent created with artifact loading capability!");
    Ok(())
}

Tool-Details

Parameter

Das Tool erwartet ein JSON-Objekt mit einem artifact_names-Array:

{
  "artifact_names": ["document.txt", "image.png", "data.json"]
}

Antwortformat

Das Tool gibt ein Objekt zurück, das die geladenen Artefakte enthält:

{
  "artifacts": [
    {
      "name": "document.txt",
      "content": "The text content of the document..."
    },
    {
      "name": "image.png",
      "content": {
        "mime_type": "image/png",
        "data": "base64-encoded-data..."
      }
    },
    {
      "name": "missing.txt",
      "error": "Artifact not found"
    }
  ]
}

Anforderungen

Damit LoadArtifactsTool funktioniert, benötigen Sie:

1. Einen ArtifactService, der im Runner konfiguriert ist
2. Artefakte, die zuvor im Dienst gespeichert wurden
3. Das Tool, das dem Agenten hinzugefügt wurde

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

// Set up artifact service
let artifact_service = Arc::new(InMemoryArtifactService::new());

// Configure runner with artifact service
let runner = Runner::new(agent)
    .with_artifact_service(artifact_service);

Kombinieren integrierter Tools

Sie können mehrere integrierte Tools zusammen verwenden:

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")?;

    // Create agent with multiple built-in tools
    let agent = LlmAgentBuilder::new("research_agent")
        .description("Research agent with search and artifact capabilities")
        .instruction(
            "Sie sind ein Recherche-Agent. Sie können:\n\
             - Das Web mit google_search nach aktuellen Informationen durchsuchen\n\
             - Gespeicherte Dokumente mit load_artifacts laden\n\
             Nutzen Sie diese Tools, um Fragen umfassend zu beantworten."
        )
        .model(Arc::new(model))
        .tool(Arc::new(GoogleSearchTool))
        .tool(Arc::new(LoadArtifactsTool::new()))
        .build()?;

    println!("Multi-Tool-Agent erstellt!");
    Ok(())
}

Eigene integrierte Tools erstellen

Sie können eigene Tools nach dem gleichen Muster wie integrierte Tools erstellen, indem Sie das Tool trait implementieren:

use adk_rust::prelude::*;
use async_trait::async_trait;
use serde_json::{json, Value};
use std::sync::Arc;

pub struct MyCustomTool;

impl MyCustomTool {
    pub fn new() -> Self {
        Self
    }
}

#[async_trait]
impl Tool for MyCustomTool {
    fn name(&self) -> &str {
        "my_custom_tool"
    }

    fn description(&self) -> &str {
        "Description of what this tool does"
    }

    async fn execute(&self, ctx: Arc<dyn ToolContext>, args: Value) -> Result<Value> {
        // Your tool logic here
        Ok(json!({ "result": "success" }))
    }
}

API-Referenz

GoogleSearchTool

impl GoogleSearchTool {
    /// Create a new GoogleSearchTool instance
    pub fn new() -> Self;
}

ExitLoopTool

impl ExitLoopTool {
    /// Create a new ExitLoopTool instance
    pub fn new() -> Self;
}

LoadArtifactsTool

impl LoadArtifactsTool {
    /// Create a new LoadArtifactsTool instance
    pub fn new() -> Self;
}

impl Default for LoadArtifactsTool {
    fn default() -> Self;
}

Verwandt

• Function Tools - Eigene Function Tools erstellen
• MCP Tools - Verwenden von MCP-Servern als Tool-Anbieter
• Workflow Agents - Verwenden von ExitLoopTool mit LoopAgent
• Artifacts - Verwalten von Binärdaten mit Artifacts

---

Zurück: ← Function Tools | Weiter: Browser Tools →