Browser Automation

pip install browser-use langchain-anthropic langchain-openai

from browser_agent import BrowserTool
import asyncio

# Initialize the tool
browser_tool = BrowserTool()

# Run a simple task
async def browse():
    result = await browser_tool._arun(
        task="Go to Wikipedia and summarize the article about Python programming"
    )
    print(result)

asyncio.run(browse())

# Use the synchronous wrapper
result = browser_tool._run(
    task="Search Google for 'machine learning tutorials' and return the top 3 results"
)
print(result)

from browser_use import Browser, BrowserConfig

# Windows
browser = Browser(
    config=BrowserConfig(
        chrome_instance_path='C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
    )
)

# Linux
browser = Browser(
    config=BrowserConfig(
        chrome_instance_path='/usr/bin/google-chrome'
    )
)

# macOS (default)
browser = Browser(
    config=BrowserConfig(
        chrome_instance_path='/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
    )
)

from langchain_anthropic import ChatAnthropic
from browser_agent import BrowserTool

# Use a different Claude model
custom_llm = ChatAnthropic(
    model="claude-3-opus-20240229",
    temperature=0.7,
    max_tokens=4096
)

browser_tool = BrowserTool(llm=custom_llm)

from browser_use import BrowserConfig

config = BrowserConfig(
    chrome_instance_path='/path/to/chrome',
    headless=False,  # Set to True for headless mode
    disable_security=False,
    window_width=1920,
    window_height=1080,
    save_screenshots=True,
    screenshot_dir='./screenshots'
)

browser = Browser(config=config)

# Order food delivery
result = browser_tool._run(
    task="Order a large pepperoni pizza from Domino's for delivery to my address"
)

# Shopping cart management
result = browser_tool._run(
    task="Browse Amazon and add a Nintendo Switch, two controllers, and Zelda game to cart"
)

# Price comparison
result = browser_tool._run(
    task="Compare prices for iPhone 15 Pro on Amazon, Best Buy, and Apple.com"
)

# Academic research
result = browser_tool._run(
    task="Research the key events of World War II and create a timeline with dates"
)

# Technical documentation
result = browser_tool._run(
    task="Find the official Python documentation for asyncio and summarize the main concepts"
)

# Market research
result = browser_tool._run(
    task="Research the top 5 CRM software solutions and compare their pricing and features"
)

# Newsletter signup
result = browser_tool._run(
    task="Sign up for the TechCrunch newsletter using my email"
)

# Gym membership
result = browser_tool._run(
    task="Navigate to Planet Fitness website and start the membership signup process"
)

# Service scheduling
result = browser_tool._run(
    task="Schedule a grocery delivery from Whole Foods for tomorrow between 3-5 PM"
)

# Flight search
result = browser_tool._run(
    task="Search for round-trip flights from NYC to London departing next month, return cheapest options"
)

# Hotel booking research
result = browser_tool._run(
    task="Find hotels in San Francisco near Moscone Center under $200/night with good reviews"
)

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from browser_agent import BrowserToolkit

# Initialize LLM
llm = ChatAnthropic(model="claude-3-5-sonnet-latest")

# Create toolkit and get tools
toolkit = BrowserToolkit.from_llm(llm)
tools = toolkit.get_tools()

# Create agent prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with web browsing capabilities."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# Create agent
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run tasks
result = agent_executor.invoke({
    "input": "Research the latest AI news and summarize the top 3 stories"
})

print(result['output'])

async def complex_workflow():
    browser_tool = BrowserTool()
    
    # Step 1: Research
    research = await browser_tool._arun(
        task="Find the top-rated Italian restaurants in San Francisco on Yelp"
    )
    
    # Step 2: Price comparison
    prices = await browser_tool._arun(
        task="Compare menu prices for the top 3 restaurants from the previous search"
    )
    
    # Step 3: Reservation (example - won't actually book)
    info = await browser_tool._arun(
        task="Get reservation availability for tonight at the highest-rated restaurant"
    )
    
    return {
        "research": research,
        "prices": prices,
        "availability": info
    }

result = asyncio.run(complex_workflow())

import asyncio
from browser_agent import BrowserTool

async def safe_browse(task: str, max_retries: int = 3):
    browser_tool = BrowserTool()
    
    for attempt in range(max_retries):
        try:
            result = await browser_tool._arun(task)
            return result
        except Exception as e:
            print(f"Attempt {attempt + 1} failed: {str(e)}")
            if attempt == max_retries - 1:
                raise
            await asyncio.sleep(2 ** attempt)  # Exponential backoff
    
    return None

# Use with retry logic
result = asyncio.run(safe_browse(
    "Navigate to GitHub and find the top trending Python repositories"
))

from browser_use import Browser, BrowserConfig
from browser_agent import BrowserTool

# Configure browser to save screenshots
config = BrowserConfig(
    chrome_instance_path='/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
    save_screenshots=True,
    screenshot_dir='./browser_screenshots'
)

browser = Browser(config=config)
browser_tool = BrowserTool(browser=browser)

# Screenshots will be automatically saved during execution
result = browser_tool._run(
    task="Navigate to the OpenAI website and capture the homepage"
)

from browser_agent import BrowserTool
from writing_agent import WritingTool
import asyncio

async def research_and_write(topic: str):
    # Step 1: Use browser to gather information
    browser = BrowserTool()
    research = await browser._arun(
        f"Research {topic} and gather key facts and statistics"
    )
    
    # Step 2: Use writing agent to create article
    writer = WritingTool()
    article = await writer._arun(
        query=f"Write a comprehensive article about {topic}. Use this research: {research}",
        target_length=1500
    )
    
    return article

# Create research-backed content
result = asyncio.run(research_and_write("Quantum Computing Applications"))
print(result)

# Never hardcode sensitive information
# BAD
result = browser_tool._run(
    task="Login to example.com with username: admin, password: secret123"
)

# GOOD - Use environment variables or secure credential storage
import os
username = os.getenv('APP_USERNAME')
password = os.getenv('APP_PASSWORD')

result = browser_tool._run(
    task=f"Login to example.com with saved credentials"
)

from browser_use import Browser, BrowserConfig

config = BrowserConfig(
    chrome_instance_path='/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
    headless=False,  # See the browser in action
    save_screenshots=True,
    screenshot_dir='./debug_screenshots'
)

browser = Browser(config=config)
browser_tool = BrowserTool(browser=browser)

# Run task with visible browser
result = browser_tool._run("Navigate to example.com and click the login button")