Running PlayWright browser tools with LLMCompiler

[dopc]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
from langchain_community.tools.playwright.utils import (
    create_sync_playwright_browser, create_async_playwright_browser
)

# async tools
async_browser = create_async_playwright_browser()
atoolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)
async_tools = atoolkit.get_tools()

# sync tools
sync_browser = create_sync_playwright_browser()
toolkit = PlayWrightBrowserToolkit.from_browser(sync_browser=sync_browser)
sync_tools = toolkit.get_tools()

Description

I am trying to use LangGraph's LLMCompiler implementation with PlayWright browser tools.

However, I could not achieve that because of the below errors:

1. with create_async_playwright_browser, I got the error below:
   ValueError('Synchronous browser not provided to navigate_browser')
   Here is a related issue with this error,
2. with create_sync_playwright_browser, I got the error below:
   error('cannot switch to a different thread')
   Here is a related issue with this error.

Can anyone help?

System Info

langchain==0.2.3
langchain-community==0.2.4
langchain-core==0.2.20
langchain-openai==0.1.8
langchain-text-splitters==0.2.1
langchainhub==0.1.18

[dosubot[bot]]

Hey @dopc! I'm here to help you out with any bugs or questions you have. I'm a bot that can assist with problem-solving and guide you on your coding journey while we wait for a human maintainer.

To resolve the errors encountered when using create_async_playwright_browser and create_sync_playwright_browser with LangGraph's LLMCompiler implementation and PlayWright browser tools, follow these steps:

1. Ensure Proper Event Loop Management: Make sure the event loop is correctly managed for asynchronous operations. Use the run_async function to handle the event loop:

   import asyncio
   from typing import Coroutine, TypeVar, Any
   
   T = TypeVar("T")
   
   def run_async(coro: Coroutine[Any, Any, T]) -> T:
       """Run an async coroutine."""
       event_loop = asyncio.get_event_loop()
       return event_loop.run_until_complete(coro)

2. Create Playwright Browsers: Use the following functions to create synchronous and asynchronous Playwright browsers:

   from playwright.async_api import async_playwright
   from playwright.sync_api import sync_playwright
   
   def create_async_playwright_browser(headless: bool = True, args: Optional[List[str]] = None):
       browser = run_async(async_playwright().start())
       return run_async(browser.chromium.launch(headless=headless, args=args))
   
   def create_sync_playwright_browser(headless: bool = True, args: Optional[List[str]] = None):
       browser = sync_playwright().start()
       return browser.chromium.launch(headless=headless, args=args)

3. Lazy Import and Validate Browsers: Ensure that the Playwright browsers are lazily imported and validated as shown in the BaseBrowserTool class:

   from typing import Optional, Tuple, Type
   from langchain_core.pydantic_v1 import root_validator
   from langchain_core.tools import BaseTool
   from langchain_core.utils import guard_import
   
   def lazy_import_playwright_browsers() -> Tuple[Type[AsyncBrowser], Type[SyncBrowser]]:
       return (
           guard_import(module_name="playwright.async_api").Browser,
           guard_import(module_name="playwright.sync_api").Browser,
       )
   
   class BaseBrowserTool(BaseTool):
       sync_browser: Optional["SyncBrowser"] = None
       async_browser: Optional["AsyncBrowser"] = None
   
       @root_validator
       def validate_browser_provided(cls, values: dict) -> dict:
           lazy_import_playwright_browsers()
           if values.get("async_browser") is None and values.get("sync_browser") is None:
               raise ValueError("Either async_browser or sync_browser must be specified.")
           return values
   
       @classmethod
       def from_browser(cls, sync_browser: Optional[SyncBrowser] = None, async_browser: Optional[AsyncBrowser] = None) -> BaseBrowserTool:
           lazy_import_playwright_browsers()
           return cls(sync_browser=sync_browser, async_browser=async_browser)

4. Instantiate the Toolkit: Use the PlayWrightBrowserToolkit class to instantiate the toolkit with either a synchronous or asynchronous browser:

   from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
   
   # async tools
   async_browser = create_async_playwright_browser()
   atoolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)
   async_tools = atoolkit.get_tools()
   
   # sync tools
   sync_browser = create_sync_playwright_browser()
   toolkit = PlayWrightBrowserToolkit.from_browser(sync_browser=sync_browser)
   sync_tools = toolkit.get_tools()

By following these steps, you should be able to resolve the errors and use the PlayWright browser tools with LangGraph's LLMCompiler implementation ^[1][2].

To continue talking to Dosu, mention @dosu.

[dopc]

@dosu hey dosu! thanks for your help.

Please also check LLMCompiler implementation (https://langchain-ai.github.io/langgraph/tutorials/llm-compiler/LLMCompiler/) while trying to solve my problem. I think that would helpful to solve the issue. Please answer again now.

[dosubot[bot]]

To resolve the errors and successfully use the PlayWright browser tools with the LLMCompiler implementation, follow these steps:

1. Ensure Playwright is Installed:

   pip install playwright
   playwright install

2. Create Playwright Browsers:

   from playwright.async_api import async_playwright
   from playwright.sync_api import sync_playwright
   
   async def create_async_playwright_browser(headless: bool = True):
       async with async_playwright() as p:
           return await p.chromium.launch(headless=headless)
   
   def create_sync_playwright_browser(headless: bool = True):
       with sync_playwright() as p:
           return p.chromium.launch(headless=headless)

3. Instantiate the Toolkit:

   from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
   
   # Asynchronous tools
   async def setup_async_tools():
       async_browser = await create_async_playwright_browser()
       atoolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)
       return atoolkit.get_tools()
   
   # Synchronous tools
   def setup_sync_tools():
       sync_browser = create_sync_playwright_browser()
       toolkit = PlayWrightBrowserToolkit.from_browser(sync_browser=sync_browser)
       return toolkit.get_tools()

4. Use the Tools:

   import asyncio
   
   async def main():
       async_tools = await setup_async_tools()
       sync_tools = setup_sync_tools()
   
       # Example usage of async tools
       tools_by_name = {tool.name: tool for tool in async_tools}
       navigate_tool = tools_by_name["navigate_browser"]
       get_elements_tool = tools_by_name["get_elements"]
   
       await navigate_tool.arun({"url": "https://web.archive.org/web/20230428131116/https://www.cnn.com/world"})
       elements = await get_elements_tool.arun({"selector": ".container__headline", "attributes": ["innerText"]})
       print(elements)
   
   asyncio.run(main())

5. Integrate with LLMCompiler:

   from langchain.agents import AgentType, initialize_agent
   from langchain_anthropic import ChatAnthropic
   
   async def integrate_with_llmcompiler():
       async_tools = await setup_async_tools()
       llm = ChatAnthropic(temperature=0)  # or any other LLM, e.g., ChatOpenAI(), OpenAI()
   
       agent_chain = initialize_agent(
           async_tools,
           llm,
           agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
           verbose=True,
       )
   
       result = await agent_chain.arun("What are the headers on langchain.com?")
       print(result)
   
   asyncio.run(integrate_with_llmcompiler())

By following these steps, you should be able to resolve the errors and use the PlayWright browser tools with the LLMCompiler implementation ^[1][2].

To continue talking to Dosu, mention @dosu.

[tjwebb]

same problem here. did anyone figure this out?