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 d'agent.

Les outils natifs du fournisseur sont désormais déclarés via l'API normale Tool au lieu des blobs GenerateContentConfig.extensions spécifiques au fournisseur. Cela signifie que vous pouvez mélanger des outils natifs tels que Gemini Google Search, Anthropic Web Search ou OpenAI Responses web search avec des instances ordinaires FunctionTool dans le même agent.

Vue d'ensemble

GoogleSearchTool

GoogleSearchTool permet aux agents 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 modèle 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(())
}

Fonctionnement

Contrairement aux outils de fonction classiques, 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 modèle décide quand effectuer une recherche en fonction de la requête
3. Résultats intégrés : Les résultats de recherche sont incorporés directement dans la réponse du modèle

L'implémentation de l'outil renvoie une erreur si elle est appelée directement car la recherche réelle s'effectue 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"))
}

Détails de l'outil

Cas d'utilisation

• Actualités : "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 : "Rechercher des informations sur les tendances en matière d'énergies renouvelables"

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

AgentTool

AgentTool encapsule n'importe quel agent en tant qu'outil appelable, permettant la composition d'agents où un agent parent peut invoquer un agent enfant dans le cadre de son flux de travail d'appel d'outils. Les changements d'état et les artefacts du sous-agent sont automatiquement transmis au contexte parent.

Utilisation de base

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

Fonctionnement

1. L'agent parent décide d'appeler l'agent enveloppé comme un outil
2. AgentTool crée un contexte d'invocation avec StreamingMode::None
3. Le sous-agent s'exécute jusqu'à son achèvement et accumule sa réponse complète
4. Le texte de la réponse est renvoyé à l'agent parent
5. Les deltas d'état et les deltas d'artefacts sont transmis au contexte parent

Détails de l'outil

Comportement clé

• Les sous-agents s'exécutent en mode non-streaming en interne pour une capture fiable des réponses
• Les changements d'état (output_key) du sous-agent se propagent à la session parente
• Les artefacts sauvegardés par le sous-agent sont transmis au contexte parent
• Voir Systèmes multi-agents pour en savoir plus sur les modèles de composition d'agents

ExitLoopTool

ExitLoopTool est un outil de contrôle utilisé avec LoopAgent pour signaler quand un processus itératif doit se terminer. Lorsqu'il est appelé, il définit le drapeau 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 le drapeau d'escalade et arrête l'itération

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 : Prévenez les boucles infinies comme mesure de sécurité
3. Instructions significatives : Aidez l'agent à comprendre quand sortir

// 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 permet aux agents de récupérer des 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és.

Utilisation Basique

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 Réponse

L'outil renvoie 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. D'artefacts précédemment sauvegardés dans le service
3. De 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);

Combinaison d'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éation d'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 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" }))
    }
}

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

Sujets associés

• Function Tools - Création d'outils de fonction personnalisés
• MCP Tools - Utilisation de serveurs MCP comme fournisseurs d'outils
• Workflow Agents - Utilisation de l'ExitLoopTool avec le LoopAgent
• Artifacts - Gestion des données binaires avec les artifacts

---

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