AI Agents with LangChain & Autonomous Workflows · レッスン

エージェントの非同期実行

エージェントがタスクを並列実行し、応答性を高めるための非同期パターンを実装します。

「エージェントの非同期実行」はCoddyKit上の無料AI Agents with LangChain & Autonomous Workflowsレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはAI Agents with LangChain & Autonomous Workflows学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 AI Agents with LangChain & Autonomous Workflowsコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

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!

よくある質問

「エージェントの非同期実行」レッスンは無料ですか？

はい。「エージェントの非同期実行」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、AI Agents with LangChain & Autonomous Workflowsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 AI Agents with LangChain & Autonomous Workflowsコースには全4レッスンが含まれています。

「エージェントの非同期実行」で何を学びますか？

エージェントがタスクを並列実行し、応答性を高めるための非同期パターンを実装します。ブラウザで直接実行するハンズオンコードでAI Agents with LangChain & Autonomous Workflowsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

AI Agents with LangChain & Autonomous Workflowsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのAI Agents with LangChain & Autonomous Workflowsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/4です。

「エージェントの非同期実行」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このAI Agents with LangChain & Autonomous Workflowsレッスンでコードを書いて実行できますか？

はい。すべてのAI Agents with LangChain & Autonomous Workflowsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← AI Agents with LangChain & Autonomous Workflowsに戻る