0Pricing
AI Agents with LangChain & Autonomous Workflows · Lezione

Esecuzione asincrona degli agenti

Impari a implementare pattern asincroni affinché gli agenti possano eseguire attività in parallelo e migliorare la reattività.

Esecuzione asincrona degli agenti è una lezione AI Agents with LangChain & Autonomous Workflows gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents with LangChain & Autonomous Workflows, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents with LangChain & Autonomous Workflows include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Why Asynchronous Agents?

Imagine your AI agent needs to do several things at once: fetch data from two APIs, analyze text with an LLM, and then store a result. If it does these synchronously (one after another), it waits for each step to complete before starting the next.

This waiting can make your agent slow and unresponsive, especially when dealing with network calls or complex computations.

Synchronous vs. Asynchronous

Synchronous execution is like a single-lane road: only one car can pass at a time. If a car breaks down, all traffic stops.

  • Synchronous: Tasks run one by one.
  • Asynchronous: Tasks can start, pause while waiting for something (like an API response), and let other tasks run in the meantime. It's like a multi-lane highway or juggling multiple balls.

Asynchronous programming helps agents utilize idle time more effectively.

Python's Async/Await Keywords

Python uses the async and await keywords to enable asynchronous programming. Think of them as signals:

  • async def: Defines a function (called a coroutine) that can run asynchronously.
  • await: Pauses the current coroutine until the awaited task is complete, allowing other tasks to run.

Let's see a basic example:

import asyncio

async def say_hello():
    print("Hello ")
    await asyncio.sleep(1) # Simulate a delay
    print("World!")

async def main():
    await say_hello()

if __name__ == "__main__":
    asyncio.run(main())

The asyncio Event Loop

Behind the scenes, Python's asyncio library manages how asynchronous tasks run. It uses an event loop.

  • The event loop constantly monitors tasks.
  • When an await statement pauses a task, the event loop switches to another ready task.
  • Once the awaited task is done, the event loop resumes the paused task.

This allows non-blocking operations, improving overall efficiency.

Async LLM Calls in LangChain

Many LangChain components, especially LLMs, offer asynchronous versions of their methods. For example, instead of .invoke(), you can often use .ainvoke() for an asynchronous call.

This is crucial for making your agent responsive when querying large language models, which can take time.

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

async def main():
    # Make sure you have your OpenAI API key set up
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    
    # Using .ainvoke() for an asynchronous call
    response = await llm.ainvoke([HumanMessage(content="What is the capital of Canada?")])
    print(response.content)

if __name__ == "__main__":
    asyncio.run(main())

Running Multiple LLM Calls Concurrently

The real power of async shines when you need to make multiple LLM calls. You don't have to wait for each one to finish before starting the next.

Use asyncio.gather() to run several asynchronous tasks in parallel and collect their results.

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

async def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    
    # Create multiple asynchronous LLM invocation tasks
    task1 = llm.ainvoke([HumanMessage(content="Tell me a fact about the sun.")])
    task2 = llm.ainvoke([HumanMessage(content="Tell me a fact about the moon.")])
    task3 = llm.ainvoke([HumanMessage(content="Tell me a fact about Earth.")])
    
    # Run all tasks concurrently and wait for them to complete
    results = await asyncio.gather(task1, task2, task3)
    
    for i, res in enumerate(results):
        print(f"Result {i+1}: {res.content}\n")

if __name__ == "__main__":
    asyncio.run(main())

Asynchronous Tool Execution

Just like LLMs, your custom tools can also be asynchronous! If your tool performs I/O-bound operations (like fetching data from a database or an external API), making it asynchronous will significantly improve agent performance.

To create an async tool, implement the _arun method in your BaseTool subclass.

import asyncio
from langchain.tools import BaseTool

class AsyncWebSearchTool(BaseTool):
    name: str = "AsyncWebSearch"
    description: str = "Searches the web asynchronously for a query."

    async def _arun(self, query: str) -> str:
        # Simulate an asynchronous web search API call
        await asyncio.sleep(1.5) 
        return f"Results for '{query}': Found 5 articles."

    def _run(self, query: str) -> str:
        # Fallback for synchronous calls (optional but good practice)
        return f"Sync results for '{query}': Found 4 articles."

async def main():
    tool = AsyncWebSearchTool()
    result = await tool.arun("latest AI news")
    print(result)

if __name__ == "__main__":
    asyncio.run(main())

Building Async Chains & Agents

When you combine asynchronous LLMs and tools into chains or agents, LangChain automatically leverages their async capabilities. Most LangChain runnables and chains also provide an .ainvoke() method.

This means you can build entire asynchronous workflows, allowing your agent to process complex tasks involving multiple steps and external calls much faster.

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableSequence

async def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    prompt = ChatPromptTemplate.from_template("What is a unique fact about {animal}?")
    
    # Define a simple chain
    chain = prompt | llm
    
    # Invoke the chain asynchronously
    response = await chain.ainvoke({"animal": "platypus"})
    print(response.content)

if __name__ == "__main__":
    asyncio.run(main())

Quick Check: Async Benefits

Let's check your understanding of asynchronous execution.

Recap: Mastering Async Agents

Great job! You've learned the fundamentals of asynchronous execution in Python and how to apply it to your LangChain agents.

  • Asynchronous programming (async/await) allows agents to perform tasks concurrently instead of waiting for each one.
  • This significantly improves responsiveness and throughput for I/O-bound operations.
  • LangChain's LLMs, tools, and chains often provide asynchronous methods (e.g., .ainvoke(), .arun()) to leverage this power.

By integrating async patterns, you can build more efficient and high-performing autonomous workflows!

Domande Frequenti

La lezione «Esecuzione asincrona degli agenti» è gratuita?

Sì — il testo completo di «Esecuzione asincrona degli agenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents with LangChain & Autonomous Workflows, passa a CoddyKit PRO. Il corso AI Agents with LangChain & Autonomous Workflows include 4 lezioni in totale.

Cosa imparerò in «Esecuzione asincrona degli agenti»?

Impari a implementare pattern asincroni affinché gli agenti possano eseguire attività in parallelo e migliorare la reattività. Eserciti AI Agents with LangChain & Autonomous Workflows con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Agents with LangChain & Autonomous Workflows?

Non è richiesta alcuna esperienza precedente. AI Agents with LangChain & Autonomous Workflows su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Esecuzione asincrona degli agenti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Agents with LangChain & Autonomous Workflows?

Sì. Ogni lezione AI Agents with LangChain & Autonomous Workflows include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Progettare workflow complessi
  2. Esecuzione asincrona degli agenti
  3. Gestione degli errori e resilienza
  4. Approvazioni con intervento umano
← Torna a AI Agents with LangChain & Autonomous Workflows