Eingebaute Werkzeuge

ADK-Rust stellt mehrere eingebaute Werkzeuge bereit, die die Fähigkeiten von Agenten erweitern, ohne eine benutzerdefinierte Implementierung zu erfordern. Diese Werkzeuge sind sofort einsatzbereit und lassen sich nahtlos in das Agent-Framework integrieren.

Anbieter-native Werkzeuge werden jetzt über das normale Tool API deklariert, anstatt über anbieterspezifische GenerateContentConfig.extensions-Blobs. Das bedeutet, dass Sie native Werkzeuge wie die Gemini Google Search, die Anthropic Web Search oder die Websuche in OpenAI Responses mit gewöhnlichen FunctionTool-Instanzen im selben Agenten kombinieren können.

Übersicht

GoogleSearchTool

GoogleSearchTool ermöglicht es Agents, das Web mithilfe der Google-Suche zu durchsuchen. Dieses Tool wird intern von Gemini-Modellen über die Grounding-Funktion verarbeitet, d. h. die Suche wird serverseitig vom Modell selbst durchgeführt.

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

    // Create the GoogleSearchTool
    let search_tool = GoogleSearchTool;

    // Add to agent
    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 created with Google Search capability!");
    Ok(())
}

Funktionsweise

Im Gegensatz zu regulären Funktionstools funktioniert GoogleSearchTool anders:

1. Serverseitige Ausführung: Die Suche wird von Geminis Grounding-Funktion durchgeführt, nicht lokal
2. Automatischer Aufruf: Das Modell entscheidet anhand der Abfrage, wann gesucht werden soll
3. Integrierte Ergebnisse: Die 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 des Gemini API stattfindet:

// This is handled internally - you don't call it directly
async fn execute(&self, _ctx: Arc<dyn ToolContext>, _args: Value) -> Result<Value> {
    Err(AdkError::tool("GoogleSearch is handled internally by Gemini"))
}

Tool-Details

Anwendungsfälle

• Aktuelle Ereignisse: „Was ist heute in den Nachrichten passiert?“
• Faktische Fragen: „Wie hoch ist die Bevölkerungszahl von Tokio?“
• Aktuelle Informationen: „Was sind die neuesten Entwicklungen im Bereich KI?“
• Rechercheaufgaben: „Finde Informationen über Trends bei erneuerbaren Energien.“

Beispielanfragen

// The agent will automatically use Google Search for queries like:
// - "What's the weather forecast for New York this week?"
// - "Who won the latest championship game?"
// - "What are the current stock prices for tech companies?"

AgentTool

AgentTool verpackt jeden Agenten als aufrufbares Werkzeug und ermöglicht eine Delegieren-und-Zurückkehren-Komposition: Der Aufrufer ruft ein untergeordnetes Element auf, empfängt dessen Ergebnis und setzt anschließend seine Ausführung fort. Vom untergeordneten Element ausgegebene Zustands- und Artefaktänderungen werden mit dem Ereignis des übergeordneten Werkzeugs zusammengeführt. Die Sitzung des untergeordneten Elements wendet außerdem jedes Ereignis sofort an, sodass spätere Schritte in einem delegierten Workflow frühere Änderungen an Zustand und Verlauf sehen.

Legacy-Standardeinstellungen bleiben isoliert und abwärtskompatibel. Portable Teams aktivieren optional übergeordnete Verlaufs- und Zustands-Snapshots, die Weiterleitung des Speichers, weitergeleitete Fehler, eine begrenzte Delegationstiefe, exakte Projektionen von Zustand und Verlauf sowie die interne Ausführung registrierter Übergaben untergeordneter Elemente. Eine verbrauchte Übergabe eines untergeordneten Elements bleibt als Ereignis sichtbar, ihre Transferaktion wird jedoch vor der Weiterleitung entfernt, sodass der übergeordnete Runner sie nicht zweimal ausführen kann. Anforderungsmetadaten, Abbruch, Bereiche, Geheimnisse, Artefakte und gemeinsam genutzter paralleler Zustand folgen der konfigurierten Weiterleitungsrichtlinie. AgentTool selbst führt die globale Übergabeschleife des Runner nicht aus; ein kompiliertes TeamSpec stellt die exakte verschachtelte Übergaberegistrierung für gemischte Topologien bereit. Kompilierte Teams aktivieren außerdem die Weiterleitung verschachtelter Ereignisse, sodass delegierte Aktivitäten im Ereignisstrom des übergeordneten Elements sichtbar bleiben; eigenständiges AgentTool behält die Legacy-Ereignisausgabe bei, sofern nicht forward_events(true) ausgewählt wird.

Für kontrolliertes Zurückschreiben verwenden Sie output_state_keys unabhängig von der Eingabeprojektion state_keys. state_merge_policy(RejectConflicts) vergleicht den aktuellen Wert des übergeordneten Elements mit dem Snapshot, der beim Beginn der Delegation erstellt wurde, und weist widersprüchliche Schreibvorgänge atomar zurück. artifact_prefixes wendet dasselbe Allowlist-Prinzip auf Artefaktnamen an. Eigenständige Standardeinstellungen bleiben aus Gründen der Abwärtskompatibilität beim Prinzip „Letzter gewinnt“ mit uneingeschränkter Ausgabe; kompilierte Teams übernehmen ihre exakte Kantenrichtlinie.

Grundlegende Verwendung

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

let sub_agent = LlmAgentBuilder::new("summarizer")
    .description("Summarizes text content")
    .instruction("Summarize the provided text concisely.")
    .model(model.clone())
    .build()?;

let agent_tool = AgentTool::new(Arc::new(sub_agent));

let coordinator = LlmAgentBuilder::new("coordinator")
    .instruction("Use the summarizer tool when asked to summarize content.")
    .model(model.clone())
    .tool(Arc::new(agent_tool))
    .build()?;

Funktionsweise

1. Der übergeordnete Agent entscheidet, den umschlossenen Agenten als Tool aufzurufen
2. AgentTool erstellt einen Aufrufkontext mit StreamingMode::None
3. Der Sub-Agent wird bis zum Abschluss ausgeführt und sammelt seine vollständige Antwort
4. Der Antworttext wird an den übergeordneten Agenten zurückgegeben
5. Zustandsdeltas und Artefaktdeltas werden an den übergeordneten Kontext weitergeleitet

Tool-Details

Wichtiges Verhalten

• Unteragenten laufen intern im Nicht-Streaming-Modus, um eine zuverlässige Erfassung der Antwort zu gewährleisten
• Zustandsänderungen (output_key) des Unteragenten werden an die übergeordnete Sitzung weitergegeben
• Vom Unteragenten gespeicherte Artefakte werden an den übergeordneten Kontext weitergeleitet
• Weitere Informationen zu Mustern der Agentenkomposition finden Sie unter Multi-Agenten-Systeme

ExitLoopTool

ExitLoopTool ist ein Steuerungswerkzeug, das zusammen mit LoopAgent verwendet wird, um zu signalisieren, wann ein iterativer Prozess beendet werden soll. Bei seinem Aufruf wird das Flag escalate gesetzt, 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-3.7-flash")?;

    // Create an agent with ExitLoopTool for iterative refinement
    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()?;

    // Use in a 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 er fortfahren oder den Prozess beenden soll
2. Sobald der Agent zum Beenden bereit ist, ruft er exit_loop auf
3. Das Werkzeug setzt actions.escalate = true und actions.skip_summarization = true
4. LoopAgent erkennt das Eskalations-Flag und beendet die Iteration

Werkzeugdetails

Bewährte Vorgehensweisen

1. Klare Beendigungskriterien: Definieren Sie spezifische Bedingungen in der Anweisung des Agents.
2. max_iterations immer festlegen: Verhindern Sie als Sicherheitsmaßnahme Endlosschleifen.
3. Aussagekräftige Anweisungen: Helfen Sie dem Agent, zu verstehen, wann er beendet werden soll.

// Good: Clear exit criteria
.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."
)

// Avoid: Vague criteria
.instruction("Improve the text. Exit when done.")

LoadArtifactsTool

LoadArtifactsTool ermöglicht es Agents, gespeicherte Artefakte nach Namen abzurufen. Dies ist nützlich, wenn Agents auf Dateien, Bilder oder andere Binärdaten zugreifen müssen, die zuvor gespeichert wurden.

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-3.7-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. Ein im Runner konfiguriertes ArtifactService
2. Zuvor im Dienst gespeicherte Artefakte
3. Das zum Agenten hinzugefügte Tool

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

Integrierte Tools kombinieren

Sie können mehrere integrierte Tools gemeinsam 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-3.7-flash")?;

    // Create agent with multiple built-in tools
    let agent = LlmAgentBuilder::new("research_agent")
        .description("Research agent with search and artifact capabilities")
        .instruction(
            "You are a research agent. You can:\n\
             - Search the web using google_search for current information\n\
             - Load stored documents using load_artifacts\n\
             Use these tools to help answer questions comprehensively."
        )
        .model(Arc::new(model))
        .tool(Arc::new(GoogleSearchTool))
        .tool(Arc::new(LoadArtifactsTool::new()))
        .build()?;

    println!("Multi-tool agent created!");
    Ok(())
}

Benutzerdefinierte integrierte Tools erstellen

Sie können eigene Tools nach demselben 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" }))
    }
}

Referenz zu API

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;
}

Verwandte Themen

• Funktionstools – Benutzerdefinierte Funktionstools erstellen
• MCP-Tools – MCP-Server als Tool-Anbieter verwenden
• Workflow-Agenten – ExitLoopTool mit LoopAgent verwenden
• Artefakte – Binärdaten mit Artefakten verwalten

---

Zurück: ← Funktionstools | Weiter: Browser-Tools →