Browser-Werkzeuge

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

Übersicht

Browser-Werkzeuge ermöglichen Agenten, Folgendes zu tun:

• 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 erweiterte Automatisierung ausführen
• Cookies, Frames und mehrere Fenster verwalten

Schnellstart

Fügen Sie zu Ihrer Cargo.toml hinzu:

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

    // Browser-Sitzung erstellen und starten
    let browser = Arc::new(BrowserSession::new(config));
    browser.start().await?;

    // Toolset mit allen 46 Werkzeugen erstellen
    let toolset = BrowserToolset::new(browser.clone());
    let tools = toolset.all_tools();

    // KI-Agenten mit Browser-Werkzeugen erstellen
    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("Sie sind ein Web-Automatisierungsassistent. Nutzen Sie Browser-Werkzeuge, um Benutzern zu helfen.");

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

    let agent = builder.build()?;

    // Aufräumen, wenn fertig
    browser.stop().await?;

    Ok(())
}

Gefilterte Werkzeuge

Wählen Sie nur die Werkzeuge 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)     // Cookie-Werkzeuge deaktivieren
    .with_frames(false)      // Frame-Werkzeuge deaktivieren
    .with_windows(false)     // Fenster-Werkzeuge deaktivieren
    .with_actions(false);    // Erweiterte Aktionen deaktivieren

let tools = toolset.all_tools();

Verfügbare Tools (insgesamt 46)

Navigation (4 Tools)

Extraktion (5 Tools)

Interaktion (5 Tools)

Warten (4 Tools)

Screenshots (1 Tool)

JavaScript (4 Tools)

Cookies (5 Tools)

Fenster/Tabs (8 Tools)

Frames (3 Tools)

Aktionen (7 Tools)

Element-Selektoren

Tools, die Elemente ansprechen, akzeptieren CSS-Selektoren:

// Nach ID
"#login-button"

// Nach Klasse
".submit-btn"

// Nach Tag und Attribut
"input[type='email']"

// Nach Datenattribut
"[data-testid='search']"

// Komplexe Selektoren
"form.login input[name='password']"

// N-tes Kind
"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

# 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

Best Practices

1. Wartezeiten nutzen: Verwenden Sie immer browser_wait_* Tools, bevor Sie mit dynamischen Inhalten interagieren.
2. Screenshots minimieren: Screenshots sind aufwändig; setzen Sie sie strategisch ein.
3. Sessions schließen: Schließen Sie Browser-Sessions 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: ← Built-in Tools | Weiter: UI Tools →