ब्राउज़र उपकरण

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

अवलोकन

ब्राउज़र उपकरण एजेंटों को इसकी अनुमति देते हैं:

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

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

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

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

पूर्व-आवश्यकताएँ

एक WebDriver सर्वर शुरू करें:

# Docker का उपयोग करना (अनुशंसित)
docker run -d -p 4444:4444 -p 7900:7900 --shm-size=2g selenium/standalone-chrome:latest

# या सीधे ChromeDriver का उपयोग करें
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>> {
    // ब्राउज़र सत्र कॉन्फ़िगर करें
    let config = BrowserConfig::new()
        .webdriver_url("http://localhost:4444")
        .headless(true)
        .viewport(1920, 1080);

    // ब्राउज़र सत्र बनाएं और शुरू करें
    let browser = Arc::new(BrowserSession::new(config));
    browser.start().await?;

    // सभी 46 टूल के साथ टूलसेट बनाएं
    let toolset = BrowserToolset::new(browser.clone());
    let tools = toolset.all_tools();

    // ब्राउज़र टूल के साथ AI एजेंट बनाएं
    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()?;

    // काम पूरा होने पर क्लीनअप करें
    browser.stop().await?;

    Ok(())
}

फ़िल्टर्ड उपकरण

केवल वे उपकरण चुनें जिनकी आपके एजेंट को आवश्यकता है:

let toolset = BrowserToolset::new(browser)
    .with_navigation(true)   // नेविगेट, पीछे, आगे, रीफ़्रेश करें
    .with_extraction(true)   // टेक्स्ट निकालें, एट्रिब्यूट निकालें, लिंक निकालें, पेज जानकारी, पेज स्रोत
    .with_interaction(true)  // क्लिक करें, डबल-क्लिक करें, टाइप करें, साफ़ करें, चयन करें
    .with_wait(true)         // तत्व के लिए प्रतीक्षा करें, प्रतीक्षा करें, पेज लोड होने की प्रतीक्षा करें, टेक्स्ट के लिए प्रतीक्षा करें
    .with_screenshot(true)   // स्क्रीनशॉट
    .with_js(true)           // JavaScript का मूल्यांकन करें, स्क्रॉल करें, होवर करें, अलर्ट को हैंडल करें
    .with_cookies(false)     // कुकी उपकरणों को अक्षम करें
    .with_frames(false)      // फ़्रेम उपकरणों को अक्षम करें
    .with_windows(false)     // विंडो उपकरणों को अक्षम करें
    .with_actions(false);    // उन्नत कार्रवाइयों को अक्षम करें

let tools = toolset.all_tools();

उपलब्ध उपकरण (कुल 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#"
        आप एक वेब रिसर्च असिस्टेंट हैं। जब किसी विषय के बारे में पूछा जाए तो:
        1. browser_navigate का उपयोग करके प्रासंगिक वेबसाइटों पर नेविगेट करें
        2. browser_extract_text का उपयोग करके मुख्य जानकारी निकालें
        3. browser_screenshot का उपयोग करके महत्वपूर्ण सामग्री के स्क्रीनशॉट लें
        4. अपने निष्कर्षों का सारांश दें
    "#);

for tool in toolset.all_tools() {
    builder = builder.tool(tool);
}

let agent = builder.build()?;

उदाहरण: फ़ॉर्म ऑटोमेशन

let agent = LlmAgentBuilder::new("form_filler")
    .model(model)
    .instruction(r#"
        आप एक फ़ॉर्म ऑटोमेशन असिस्टेंट हैं। फ़ॉर्म भरने के लिए:
        1. फ़ॉर्म पेज पर जाने के लिए browser_navigate का उपयोग करें
        2. फ़ॉर्म लेबल देखने के लिए browser_extract_text का उपयोग करें
        3. टेक्स्ट फ़ील्ड भरने के लिए browser_type का उपयोग करें
        4. ड्रॉपडाउन के लिए browser_select का उपयोग करें
        5. सबमिट करने के लिए browser_click का उपयोग करें
    "#)
    .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-संगत सर्वर के साथ काम करता है:

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

Browser tools संरचित त्रुटियाँ लौटाते हैं:

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 run --example browser_basic

# browser tools के साथ AI agent
cargo run --example browser_agent

# पूर्ण 46-टूल्स का इंटरैक्टिव उदाहरण
cargo run --example browser_interactive

# OpenAI-संचालित browser agent
cargo run --example browser_openai --features openai

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

1. Wait का उपयोग करें: गतिशील सामग्री के साथ इंटरैक्ट करने से पहले हमेशा browser_wait_* tools का उपयोग करें
2. स्क्रीनशॉट कम करें: स्क्रीनशॉट महंगे होते हैं; उनका रणनीतिक रूप से उपयोग करें
3. सेशन बंद करें: काम हो जाने पर हमेशा browser session बंद करें
4. त्रुटियों को संभालें: Browser automation विफल हो सकता है; timeouts को सहजता से संभालें
5. Tools को फ़िल्टर करें: जटिलता कम करने के लिए Agent को केवल वही tools दें जिनकी उसे आवश्यकता है

---

पिछला: ← Built-in Tools | अगला: UI Tools →