Browser-Tools

Die adk-browser Crate bietet 46 umfassende Browser-Automatisierungstools, die KI-Agenten die Interaktion mit Webseiten ermöglichen. Basierend auf dem WebDriver-Protokoll (Selenium) funktioniert sie mit jedem WebDriver-kompatiblen Browser.

Überblick

Browser-Tools ermöglichen Agenten:

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

Schnellstart

Fügen Sie Ihrer Cargo.toml hinzu:

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

Voraussetzungen

Starten Sie 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 Nutzung

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

Gefilterte Tools

Wählen Sie nur die Tools aus, die Ihr 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();

Multi-Tenant-Nutzung mit Pool-gestützten Toolsets

Für Multi-Tenant-Produktionsbereitstellungen verwenden Sie BrowserToolset::with_pool() zusammen mit LlmAgentBuilder::toolset(). Jeder Benutzer erhält eine isolierte Browser-Sitzung, 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()?;

Browser-Sitzungen starten automatisch und erholen sich automatisch von veralteten WebDriver-Verbindungen. Sie müssen browser.start() nicht mehr aufrufen, bevor Sie Tools verwenden – die Sitzung startet transparent bei der ersten Nutzung.

Verfügbare Tools (Insgesamt 46)

Navigation (4 Tools)

Extraktion (5 Tools)

Interaktion (5 Tools)

Warten (4 Werkzeuge)

Screenshots (1 Tool)

JavaScript (4 Werkzeuge)

Cookies (5 Werkzeuge)

Fenster/Registerkarten (8 Werkzeuge)

Rahmen (3 tools)

Aktionen (7 Werkzeuge)

Element-Selektoren

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 Verfahren

1. Wartezeiten verwenden: Verwenden Sie immer browser_wait_* Tools, bevor Sie mit dynamischen Inhalten interagieren
2. Screenshots minimieren: Screenshots sind teuer; setzen Sie sie strategisch ein
3. Sitzungen schließen: Schließen Sie Browser-Sitzungen immer, wenn Sie fertig sind
4. Fehler behandeln: Browser-Automatisierung kann fehlschlagen; behandeln Sie Timeouts elegant
5. Tools filtern: Geben Sie Agents nur die Tools, die sie benötigen, um die Komplexität zu reduzieren

---

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