Outils de navigateur

Le crate adk-browser 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 navigateur 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 PDF
• Exécuter du JavaScript pour une automatisation avancée
• Gérer les cookies, les cadres et les multiples fenêtres

Démarrage rapide

Ajoutez à votre Cargo.toml :

[dependencies]
adk-browser = "0.2.0"
adk-agent = "0.2.0"
adk-model = "0.2.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>> {
    // Configurer la session du navigateur
    let config = BrowserConfig::new()
        .webdriver_url("http://localhost:4444")
        .headless(true)
        .viewport(1920, 1080);

    // Créer et démarrer la session du navigateur
    let browser = Arc::new(BrowserSession::new(config));
    browser.start().await?;

    // Créer un ensemble d'outils avec les 46 outils
    let toolset = BrowserToolset::new(browser.clone());
    let tools = toolset.all_tools();

    // Créer un agent IA avec les outils de navigateur
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.0-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()?;

    // Nettoyage après utilisation
    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)   // naviguer, retour, avance, rafraîchir
    .with_extraction(true)   // extraire_texte, extraire_attribut, extraire_liens, info_page, source_page
    .with_interaction(true)  // cliquer, double_cliquer, taper, effacer, sélectionner
    .with_wait(true)         // attendre_élément, attendre, attendre_chargement_page, attendre_texte
    .with_screenshot(true)   // capture_écran
    .with_js(true)           // évaluer_js, défiler, survoler, gérer_alerte
    .with_cookies(false)     // Désactiver les outils de cookies
    .with_frames(false)      // Désactiver les outils de cadres
    .with_windows(false)     // Désactiver les outils de fenêtres
    .with_actions(false);    // Désactiver les actions avancées

let tools = toolset.all_tools();

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)

Frames (3 outils)

Actions (7 outils)

Sélecteurs d'éléments

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

// Par ID
"#login-button"

// Par classe
".submit-btn"

// Par balise et attribut
"input[type='email']"

// Par attribut de données
"[data-testid='search']"

// Sélecteurs complexes
"form.login input[name='password']"

// N-ième enfant
"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 formulaire

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 de WebDriver

Fonctionne avec n'importe quel serveur compatible WebDriver :

Gestion des erreurs

Les outils de navigation 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

# Basic browser session
cargo run --example browser_basic

# AI agent with browser tools
cargo run --example browser_agent

# Full 46-tool interactive example
cargo run --example browser_interactive

# OpenAI-powered browser agent
cargo run --example browser_openai --features openai

Bonnes pratiques

1. Utiliser les 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 de manière stratégique.
3. Fermer les sessions : Fermez toujours les sessions de navigation 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 UI →