ब्राउज़र टूल्स

adk-browser क्रेट 46 व्यापक ब्राउज़र ऑटोमेशन टूल्स प्रदान करता है, जो AI एजेंट्स को वेब पेजों के साथ इंटरैक्ट करने में सक्षम बनाते हैं। WebDriver प्रोटोकॉल (Selenium) पर निर्मित, यह किसी भी WebDriver-संगत ब्राउज़र के साथ काम करता है।

अवलोकन

ब्राउज़र टूल्स एजेंट्स को निम्नलिखित कार्य करने की अनुमति देते हैं:

• वेब पेजों पर नेविगेट करना और ब्राउज़र इतिहास प्रबंधित करना
• टेक्स्ट, लिंक, इमेज और संरचित डेटा निकालना
• फ़ॉर्म भरना और पेज तत्वों के साथ इंटरैक्ट करना
• स्क्रीनशॉट लेना और PDFs उत्पन्न करना
• उन्नत ऑटोमेशन के लिए JavaScript निष्पादित करना
• कुकीज़, फ़्रेम और एकाधिक विंडोज़ प्रबंधित करना

त्वरित शुरुआत

अपने Cargo.toml में जोड़ें:

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

पूर्वापेक्षाएँ

एक 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

मूल उपयोग

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

फ़िल्टर किए गए टूल्स

अपने एजेंट के लिए केवल आवश्यक टूल्स चुनें:

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

पूल-आधारित टूलसेट्स के साथ मल्टी-टेनेंट उपयोग

प्रोडक्शन मल्टी-टेनेंट डिप्लॉयमेंट्स के लिए, BrowserToolset::with_pool() का उपयोग LlmAgentBuilder::toolset() के साथ करें। प्रत्येक उपयोगकर्ता को रनटाइम पर पूल से प्राप्त एक पृथक ब्राउज़र सत्र मिलता है:

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

ब्राउज़र सत्र पुराने WebDriver कनेक्शनों से स्वचालित रूप से शुरू और पुनर्प्राप्त हो जाते हैं। टूल्स का उपयोग करने से पहले अब आपको browser.start() कॉल करने की आवश्यकता नहीं है — सत्र पहली बार उपयोग किए जाने पर पारदर्शी रूप से शुरू हो जाता है।

उपलब्ध टूल्स (कुल 46)

नेविगेशन (4 टूल्स)

निष्कर्षण (5 टूल)

इंटरैक्शन (5 टूल)

प्रतीक्षा (4 टूल)

स्क्रीनशॉट (1 टूल)

JavaScript (4 उपकरण)

कुकीज़ (5 टूल)

विंडोज़/टैब (8 टूल)

फ़्रेम (3 टूल)

क्रियाएँ (7 उपकरण)

तत्व चयनकर्ता

तत्वों को लक्षित करने वाले टूल 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)"

उदाहरण: वेब अनुसंधान एजेंट

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

उदाहरण: फ़ॉर्म स्वचालन

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

कॉन्फ़िगरेशन

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 विकल्प

किसी भी WebDriver-संगत सर्वर के साथ काम करता है:

त्रुटि प्रबंधन

ब्राउज़र टूल संरचित त्रुटियाँ लौटाते हैं:

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

उदाहरण

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

सर्वोत्तम अभ्यास

1. प्रतीक्षाओं का उपयोग करें: गतिशील सामग्री के साथ इंटरैक्ट करने से पहले हमेशा browser_wait_* टूल का उपयोग करें
2. स्क्रीनशॉट कम से कम लें: स्क्रीनशॉट महँगे होते हैं; उनका रणनीतिक रूप से उपयोग करें
3. सेशन बंद करें: काम पूरा होने पर हमेशा ब्राउज़र सेशन बंद करें
4. त्रुटियों को संभालें: ब्राउज़र ऑटोमेशन विफल हो सकता है; टाइमआउट को सुचारु रूप से संभालें
5. टूल फ़िल्टर करें: जटिलता कम करने के लिए एजेंट को केवल आवश्यक टूल दें

---

पिछला: ← अंतर्निहित टूल | अगला: UI टूल →