Calling tools asynchronusly using _acall and with @tool decoration using AgentExecutor

[sowsan]

Hello Team -

How can I call the tool created with async ? Like the scenario below , and if I use AgentExecutor, how can I ensure that AgentExecutor will call the _arun behind the scene? I am using

AgentExecutor.Astream() def _arun(
       self,
       url: str,
       run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
   ) -> str:
       """Use the tool asynchronously."""
       async with aiohttp.ClientSession() as session:
           async with session.get(url) as response:
               text = await response.text()
       callbacks = run_manager.get_child() if run_manager else None
       return await self.summary_chain.ainvoke(
           {"text": text},
           {"callbacks": callbacks},
       ) 

Also how can we make the tool with @tool decorator called asynchronously ? @tool. If I decorate the fucnation with async it says @tool doesnt support async. I am using latest version of langchain - 0.0.0.346

def summarize_tool(url: str, callbacks: Callbacks = None):
    """Summarize a website."""
    text = requests.get(url).text
    summary_chain = (
        ChatPromptTemplate.from_template(
            "Summarize the following text:\n<TEXT {uid}>\n" "{text}" "\n</TEXT {uid}>"
        ).partial(uid=lambda: uuid.uuid4())
        | ChatOpenAI(model="gpt-3.5-turbo-16k")
        | StrOutputParser()
    ).with_config(run_name="Summarize Text")
    return summary_chain.invoke(
        {"text": text},
        {"callbacks": callbacks},
    ) 

[dosubot[bot]]

🤖

Hello @sowsan,

I'm Dosu, an AI assistant here to help you with your questions and troubleshoot issues related to LangChain. While we wait for a human maintainer, I'm here to provide as much assistance as I can!

In the LangChain framework, to ensure that your tool function is called asynchronously, you need to define it as a coroutine function using async def. The framework will automatically use the _arun method for coroutine functions. Here's an example:

from langchain_core.tools import tool

@tool()
async def my_tool(a: int, b: int) -> int:
    """Add two numbers asynchronously"""
    return a + b

In this example, my_tool is a coroutine function because it is defined with async def. When you run this tool with the LangChain framework, it will automatically use the _arun method to call this tool asynchronously.

The AgentExecutor will call the _arun method behind the scenes when you use the ainvoke method of the tool:

result = await my_tool.ainvoke({"a": 1, "b": 2})

In this code, ainvoke is an asynchronous method that calls the _arun method of the tool. The AgentExecutor will handle the asynchronous execution of the tool.

Regarding your second question, the @tool decorator currently does not support asynchronous functions. This is a limitation of the current version of LangChain (v0.0.346). If you need to perform asynchronous operations in your tool, you may need to manage the asynchrony within the tool function itself, using Python's asyncio library.

For more details, you can refer to the source code of LangChain in the tools.py and manager.py files.

I hope this helps! If you have any more questions, feel free to ask.

Sources

• libs/core/langchain_core/tools.py
• libs/core/langchain_core/callbacks/manager.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[mfernandezsidn]

I need help with this too!