Eingebaute Tools

ADK-Rust bietet mehrere eingebaute 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 Agenten-Framework integrieren.

Provider-native Tools werden jetzt über die normale Tool API anstelle von provider-spezifischen GenerateContentConfig.extensions blobs deklariert. Das bedeutet, Sie können native Tools wie Gemini Google Search, Anthropic Web Search oder OpenAI Responses Web-Suche mit gewöhnlichen FunctionTool Instanzen im selben Agenten mischen.

Übersicht

GoogleSearchTool

GoogleSearchTool ermöglicht Agenten, das Web mit Google Search zu durchsuchen. Dieses Tool wird intern von Gemini-Modellen über 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")?;

    // 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(())
}

Wie es funktioniert

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:

// 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 Abfragen: "Wie hoch ist die Einwohnerzahl von Tokio?"
• Aktuelle Informationen: "Was sind die neuesten Entwicklungen in der KI?"
• Rechercheaufgaben: "Finde Informationen über Trends bei erneuerbaren Energien"

Beispielabfragen

// 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 umschließt jeden Agenten als aufrufbares Tool und ermöglicht so die Agentenkomposition, bei der ein übergeordneter Agent einen untergeordneten Agenten als Teil seines Tool-Aufruf-Workflows aufrufen kann. Zustandsänderungen und Artefakte des Unter-Agenten werden automatisch an den übergeordneten Kontext weitergeleitet.

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

Wie es funktioniert

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

Tool-Details

Schlüsselverhalten

• Unter-Agents laufen intern im Nicht-Streaming-Modus für eine zuverlässige Antwortaufnahme
• Zustandsänderungen (output_key) vom Unter-Agent werden an die übergeordnete Session weitergegeben
• Vom Unter-Agent gespeicherte Artefakte werden an den übergeordneten Kontext weitergeleitet
• Siehe Multi-Agent Systems für weitere Informationen zu Agenten-Kompositionsmustern

ExitLoopTool

ExitLoopTool ist ein Kontroll-Tool, 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")?;

    // 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 beenden 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 Eskalations-Flag und stoppt die Iteration

Tool-Details

Bewährte Verfahren

1. Klare Abbruchkriterien: Definieren Sie spezifische Bedingungen in der Anweisung des Agenten
2. max_iterations immer setzen: Verhindern Sie Endlosschleifen als Sicherheitsmaßnahme
3. Sinnvolle Anweisungen: Helfen Sie dem Agenten zu verstehen, wann er beenden 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 Agenten, gespeicherte Artefakte anhand ihres Namens abzurufen. Dies ist nützlich, wenn Agenten auf Dateien, Bilder oder andere binäre Daten 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-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 im Runner konfigurierten ArtifactService
2. Zuvor im Dienst gespeicherte Artefakte
3. Das dem 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);

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(
            "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(())
}

Erstellen benutzerdefinierter integrierter Tools

Sie können Ihre eigenen 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 - MCP-Server als Tool-Anbieter verwenden
• Workflow Agents - ExitLoopTool mit LoopAgent verwenden
• Artefakte - Binärdaten mit Artefakten verwalten

---

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