Outils de navigateur

La crate adk-browser fournit 46 outils complets d’automatisation de navigateur permettant aux agents d’IA d’interagir avec des pages web. Fondée sur le protocole WebDriver (Selenium), elle fonctionne avec tout navigateur compatible avec WebDriver.

Vue d’ensemble

Les outils de navigateur permettent aux agents de :

• Naviguer sur des 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 des JavaScript pour une automatisation avancée
• Gérer les cookies, les cadres et plusieurs fenêtres

Démarrage rapide

Ajoutez à votre Cargo.toml :

[dependencies]
adk-browser = "2.1.0"
adk-agent = "2.1.0"
adk-model = "2.1.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-3.7-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 adossés à 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 depuis le 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 récupèrent automatiquement les 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)

Attendre (4 outils)

Captures d’écran (1 outil)

JavaScript (4 outils)

Cookies (5 outils)

Fenêtres/Onglets (8 outils)

Frames (3 outils)

Actions (7 outils)

Sélecteurs d’éléments

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

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

Configuration

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

Options WebDriver

Fonctionne avec tout serveur compatible avec WebDriver :

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 des attentes : utilisez toujours 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 judicieusement
3. Fermer les sessions : fermez toujours les sessions du navigateur lorsque vous avez 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 afin de réduire la complexité

---

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