Browser-Tools

Der Crate adk-browser stellt 46 umfassende Tools zur Browserautomatisierung bereit, mit denen KI-Agenten mit Webseiten interagieren können. Auf dem WebDriver-Protokoll (Selenium) basierend, funktioniert es mit jedem WebDriver-kompatiblen Browser.

Übersicht

Browser-Tools ermöglichen Agenten Folgendes:

• Webseiten zu navigieren und den Browserverlauf zu verwalten
• Text, Links, Bilder und strukturierte Daten zu extrahieren
• Formulare auszufüllen und mit Seitenelementen zu interagieren
• Screenshots aufzunehmen und PDFs zu erzeugen
• JavaScript für fortgeschrittene Automatisierung auszuführen
• Cookies, Frames und mehrere Fenster zu verwalten

Schnellstart

Füge Folgendes zu deinem Cargo.toml hinzu:

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

Voraussetzungen

Starte einen WebDriver-Server:

# 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

Grundlegende Verwendung

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

Gefilterte Tools

Wähle nur die Tools aus, die dein Agent benötigt:

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

Mandantenfähige Verwendung mit poolbasierten Toolsets

Verwende für Mandantenbereitstellungen in Produktionsumgebungen BrowserToolset::with_pool() zusammen mit LlmAgentBuilder::toolset(). Jeder Benutzer erhält eine isolierte Browsersitzung, die zur Laufzeit aus dem Pool aufgelöst wird:

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

Browsersitzungen werden automatisch gestartet und von veralteten WebDriver-Verbindungen wiederhergestellt. Du musst browser.start() nicht mehr aufrufen, bevor du Tools verwendest – die Sitzung wird bei der ersten Verwendung transparent gestartet.

Verfügbare Tools (insgesamt 46)

Navigation (4 Tools)

Extraktion (5 Tools)

Interaktion (5 Tools)

Warten (4 Tools)

Screenshots (1 Tool)

JavaScript (4 Werkzeuge)

Cookies (5 Werkzeuge)

Windows/Tabs (8 Tools)

Frames (3 Tools)

Aktionen (7 Tools)

Elementselektoren

Tools, die auf Elemente abzielen, akzeptieren CSS-Selektoren:

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

Beispiel: Web-Recherche-Agent

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

Beispiel: Formularautomatisierung

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

Konfiguration

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-Optionen

Funktioniert mit jedem WebDriver-kompatiblen Server:

Fehlerbehandlung

Browser-Tools geben strukturierte Fehler zurück:

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

Beispiele

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

Bewährte Vorgehensweisen

1. Wartezeiten verwenden: Verwenden Sie immer browser_wait_*-Tools, bevor Sie mit dynamischen Inhalten interagieren
2. Screenshots minimieren: Screenshots sind kostspielig; verwenden Sie sie gezielt
3. Sitzungen schließen: Schließen Sie Browser-Sitzungen immer, wenn Sie fertig sind
4. Fehler behandeln: Browser-Automatisierung kann fehlschlagen; behandeln Sie Zeitüberschreitungen ordnungsgemäß
5. Tools filtern: Geben Sie Agents nur die benötigten Tools, um die Komplexität zu reduzieren

---

Zurück: ← Integrierte Tools | Weiter: UI-Tools →