Outils intégrés

adk-rust fournit plusieurs outils intégrés qui étendent les capacités des agents sans nécessiter d'implémentation personnalisée. Ces outils sont prêts à l'emploi et s'intègrent parfaitement au framework des Agent.

Aperçu

GoogleSearchTool

GoogleSearchTool permet aux Agent de rechercher sur le web en utilisant Google Search. Cet outil est géré en interne par les modèles Gemini via la fonctionnalité de "grounding", ce qui signifie que la recherche est effectuée côté serveur par le model lui-même.

Utilisation de base

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

Comment ça marche

Contrairement aux function tools ordinaires, GoogleSearchTool fonctionne différemment :

1. Exécution côté serveur : La recherche est effectuée par la fonctionnalité de "grounding" de Gemini, et non localement
2. Invocation automatique : Le model décide quand rechercher en fonction de la requête
3. Résultats intégrés : Les résultats de recherche sont directement incorporés dans la réponse du model

L'implémentation de l'outil renvoie une erreur si elle est appelée directement car la recherche réelle se produit au sein de l'API Gemini :

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

Détails de l'outil

Cas d'utilisation

• Événements actuels : "Que s'est-il passé dans l'actualité aujourd'hui ?"
• Requêtes factuelles : "Quelle est la population de Tokyo ?"
• Informations récentes : "Quels sont les derniers développements en matière d'IA ?"
• Tâches de recherche : "Trouver des informations sur les tendances en matière d'énergie renouvelable"

Exemples de requêtes

// 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?"

ExitLoopTool

ExitLoopTool est un outil de contrôle utilisé avec LoopAgent pour signaler qu'un processus itératif doit se terminer. Lorsqu'il est appelé, il définit l'indicateur escalate, provoquant la sortie de la boucle.

Utilisation de base

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

Comment ça marche

1. L'agent évalue s'il doit continuer ou sortir
2. Quand il est prêt à sortir, l'agent appelle exit_loop
3. L'outil définit actions.escalate = true et actions.skip_summarization = true
4. Le LoopAgent détecte l'indicateur escalate et arrête d'itérer

Détails de l'outil

Bonnes pratiques

1. Critères de sortie clairs: Définissez des conditions spécifiques dans l'instruction de l'agent
2. Toujours définir max_iterations: Empêchez les boucles infinies comme mesure de sécurité
3. Instructions significatives: Aidez l'agent à comprendre quand sortir

// Bon: Critères de sortie clairs
.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."
)

// À éviter: Critères vagues
.instruction("Improve the text. Exit when done.")

LoadArtifactsTool

LoadArtifactsTool permet aux agents de récupérer les artefacts stockés par leur nom. Ceci est utile lorsque les agents ont besoin d'accéder à des fichiers, des images ou d'autres données binaires qui ont été précédemment sauvegardées.

Utilisation de base

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

Détails de l'outil

Paramètres

L'outil attend un objet JSON avec un tableau artifact_names :

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

Format de la réponse

L'outil retourne un objet contenant les artefacts chargés :

{
  "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"
    }
  ]
}

Exigences

Pour que LoadArtifactsTool fonctionne, vous avez besoin :

1. Un ArtifactService configuré dans le runner
2. Des artefacts précédemment sauvegardés dans le service
3. L'outil ajouté à l'agent

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

Combiner les outils intégrés

Vous pouvez utiliser plusieurs outils intégrés ensemble :

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

Créer des outils intégrés personnalisés

Vous pouvez créer vos propres outils en suivant le même modèle que les outils intégrés en implémentant le trait Tool :

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 de ce que cet outil fait"
    }

    async fn execute(&self, ctx: Arc<dyn ToolContext>, args: Value) -> Result<Value> {
        // Votre logique d'outil ici
        Ok(json!({ "result": "success" }))
    }
}

Référence 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;
}

Liens connexes

• Function Tools - Créer des Function Tools personnalisés
• MCP Tools - Utiliser des serveurs MCP comme fournisseurs d'outils
• Workflow Agents - Utiliser ExitLoopTool avec LoopAgent
• Artifacts - Gérer les données binaires avec des artifacts

---

Précédent: ← Function Tools | Suivant: Browser Tools →