Outils de navigation

Le adk-browser crate fournit 46 outils complets d'automatisation de navigateur qui permettent aux agents IA d'interagir avec les pages web. Basé sur le protocole WebDriver (Selenium), il fonctionne avec n'importe quel navigateur compatible WebDriver.

Aperçu

Les outils de navigation permettent aux agents de :

• Naviguer sur les pages web et gérer l'historique du navigateur
• Extraire du texte, des liens, des images et des données structurées
• Remplir des formulaires et interagir avec les éléments de la page
• Prendre des captures d'écran et générer des PDFs
• Exécuter du JavaScript pour une automatisation avancée
• Gérer les cookies, les cadres (frames) et les multiples fenêtres

Démarrage rapide

Ajoutez à votre Cargo.toml :

[dependencies]
adk-browser = "2.0.0"
adk-agent = "2.0.0"
adk-model = "2.0.0"

Prérequis

Démarrez un serveur WebDriver :

# Using Docker (recommended)
docker run -d -p 4444:4444 -p 7900:7900 --shm-size=2g selenium/standalone-chrome:latest

# Or use ChromeDriver directly
chromedriver --port=4444

Utilisation de base

use adk_browser::{BrowserSession, BrowserToolset, BrowserConfig};
use adk_agent::LlmAgentBuilder;
use adk_model::GeminiModel;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Configure browser session
    let config = BrowserConfig::new()
        .webdriver_url("http://localhost:4444")
        .headless(true)
        .viewport(1920, 1080);

    // Create and start browser session
    let browser = Arc::new(BrowserSession::new(config));
    browser.start().await?;

    // Create toolset with all 46 tools
    let toolset = BrowserToolset::new(browser.clone());
    let tools = toolset.all_tools();

    // Create AI agent with browser tools
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

    let mut builder = LlmAgentBuilder::new("web_agent")
        .model(model)
        .instruction("You are a web automation assistant. Use browser tools to help users.");

    for tool in tools {
        builder = builder.tool(tool);
    }

    let agent = builder.build()?;

    // Clean up when done
    browser.stop().await?;

    Ok(())
}

Outils filtrés

Sélectionnez uniquement les outils dont votre agent a besoin :

let toolset = BrowserToolset::new(browser)
    .with_navigation(true)   // navigate, back, forward, refresh
    .with_extraction(true)   // extract_text, extract_attribute, extract_links, page_info, page_source
    .with_interaction(true)  // click, double_click, type, clear, select
    .with_wait(true)         // wait_for_element, wait, wait_for_page_load, wait_for_text
    .with_screenshot(true)   // screenshot
    .with_js(true)           // evaluate_js, scroll, hover, handle_alert
    .with_cookies(false)     // Disable cookie tools
    .with_frames(false)      // Disable frame tools
    .with_windows(false)     // Disable window tools
    .with_actions(false);    // Disable advanced actions

let tools = toolset.all_tools();

Utilisation multi-locataire avec des ensembles d'outils basés sur un pool

Pour les déploiements multi-locataires en production, utilisez BrowserToolset::with_pool() avec LlmAgentBuilder::toolset(). Chaque utilisateur obtient une session de navigateur isolée résolue à partir du pool au moment de l'exécution :

use adk_browser::{BrowserSessionPool, BrowserToolset, BrowserConfig, BrowserProfile};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

let pool = Arc::new(BrowserSessionPool::new(BrowserConfig::new(), 10));

// Pool-backed toolset — sessions resolved per-user via ctx.user_id()
let toolset = Arc::new(BrowserToolset::with_pool_and_profile(
    pool,
    BrowserProfile::Scraping,
));

let agent = LlmAgentBuilder::new("web_agent")
    .model(model)
    .instruction("You are a web research assistant.")
    .toolset(toolset)
    .build()?;

Les sessions de navigateur démarrent automatiquement et se récupèrent automatiquement des connexions WebDriver obsolètes. Vous n'avez plus besoin d'appeler browser.start() avant d'utiliser les outils — la session démarre de manière transparente lors de la première utilisation.

Outils disponibles (46 au total)

Navigation (4 outils)

Extraction (5 outils)

Interaction (5 outils)

Attente (4 outils)

Captures d'écran (1 outil)

JavaScript (4 outils)

Cookies (5 outils)

Fenêtres/Onglets (8 outils)

Cadres (3 tools)

Actions (7 outils)

Sélecteurs d'éléments

Les outils qui ciblent des éléments acceptent CSS des sélecteurs :

// By ID
"#login-button"

// By class
".submit-btn"

// By tag and attribute
"input[type='email']"

// By data attribute
"[data-testid='search']"

// Complex selectors
"form.login input[name='password']"

// Nth child
"ul.menu li:nth-child(3)"

Exemple : Agent de recherche web

use adk_browser::{BrowserSession, BrowserToolset, BrowserConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

let config = BrowserConfig::new().webdriver_url("http://localhost:4444");
let browser = Arc::new(BrowserSession::new(config));
browser.start().await?;

let toolset = BrowserToolset::new(browser.clone())
    .with_navigation(true)
    .with_extraction(true)
    .with_screenshot(true);

let mut builder = LlmAgentBuilder::new("researcher")
    .model(model)
    .instruction(r#"
        You are a web research assistant. When asked about a topic:
        1. Navigate to relevant websites using browser_navigate
        2. Extract key information using browser_extract_text
        3. Take screenshots of important content using browser_screenshot
        4. Summarize your findings
    "#);

for tool in toolset.all_tools() {
    builder = builder.tool(tool);
}

let agent = builder.build()?;

Exemple : Automatisation de formulaires

let agent = LlmAgentBuilder::new("form_filler")
    .model(model)
    .instruction(r#"
        You are a form automation assistant. To fill forms:
        1. Use browser_navigate to go to the form page
        2. Use browser_extract_text to see form labels
        3. Use browser_type to fill text fields
        4. Use browser_select for dropdowns
        5. Use browser_click to submit
    "#)
    .build()?;

Préparer le navigateur

let config = BrowserConfig::new()
    .webdriver_url("http://localhost:4444")
    .headless(true)
    .viewport(1920, 1080)
    .page_load_timeout(30)
    .user_agent("Custom User Agent");

let browser = Arc::new(BrowserSession::new(config));
browser.start().await?;

WebDriver Options

Fonctionne avec n'importe quel WebDriver serveur compatible :

Gestion des erreurs

Les outils de navigateur renvoient des erreurs structurées :

match result {
    Ok(value) => println!("Success: {:?}", value),
    Err(e) => {
        match e {
            BrowserError::ElementNotFound(selector) => {
                println!("Could not find element: {}", selector);
            }
            BrowserError::Timeout(duration) => {
                println!("Operation timed out after {:?}", duration);
            }
            BrowserError::SessionClosed => {
                println!("Browser session was closed");
            }
            _ => println!("Browser error: {}", e),
        }
    }
}

Exemples

cargo check -p adk-browser
cargo check -p adk-rust --no-default-features --features browser

Bonnes pratiques

1. Utiliser les attentes : Toujours utiliser les outils browser_wait_* avant d'interagir avec du contenu dynamique
2. Minimiser les captures d'écran : Les captures d'écran sont coûteuses ; utilisez-les stratégiquement
3. Fermer les sessions : Toujours fermer les sessions de navigateur une fois terminé
4. Gérer les erreurs : L'automatisation du navigateur peut échouer ; gérez les délais d'attente avec élégance
5. Filtrer les outils : Ne donnez aux agents que les outils dont ils ont besoin pour réduire la complexité

---

Précédent : ← Outils intégrés | Suivant : Outils d'interface utilisateur →