0Pricing
AI Agents with LangChain & Autonomous Workflows · Pelajaran

Eksekusi Agen Asinkron

Pelajari cara menerapkan pola asinkron agar agen dapat menjalankan tugas secara paralel dan meningkatkan daya tanggap.

Eksekusi Agen Asinkron adalah pelajaran AI Agents with LangChain & Autonomous Workflows gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Agents with LangChain & Autonomous Workflows, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Agents with LangChain & Autonomous Workflows mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Eksekusi Agen Asinkron” gratis?

Ya — teks lengkap “Eksekusi Agen Asinkron” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Agents with LangChain & Autonomous Workflows, upgrade ke CoddyKit PRO. Kursus AI Agents with LangChain & Autonomous Workflows mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Eksekusi Agen Asinkron”?

Pelajari cara menerapkan pola asinkron agar agen dapat menjalankan tugas secara paralel dan meningkatkan daya tanggap. Kamu berlatih AI Agents with LangChain & Autonomous Workflows dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Agents with LangChain & Autonomous Workflows?

Tidak diperlukan pengalaman sebelumnya. AI Agents with LangChain & Autonomous Workflows di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Eksekusi Agen Asinkron” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Agents with LangChain & Autonomous Workflows ini?

Ya. Setiap pelajaran AI Agents with LangChain & Autonomous Workflows menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Merancang Alur Kerja Kompleks
  2. Eksekusi Agen Asinkron
  3. Penanganan Kesalahan dan Ketahanan
  4. Persetujuan Manusia dalam Alur
← Kembali ke AI Agents with LangChain & Autonomous Workflows