0Pricing
AI Agents with LangChain & Autonomous Workflows · Ders

Asenkron Aracı Yürütme

Aracıların paralel görevleri gerçekleştirmesi ve yanıt verebilirliği artırması için asenkron örüntüleri uygulamayı öğrenin.

Asenkron Aracı Yürütme, CoddyKit'te ücretsiz bir AI Agents with LangChain & Autonomous Workflows dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, AI Agents with LangChain & Autonomous Workflows öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Agents with LangChain & Autonomous Workflows kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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!

Sıkça Sorulan Sorular

“Asenkron Aracı Yürütme” dersi ücretsiz mi?

Evet — “Asenkron Aracı Yürütme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve AI Agents with LangChain & Autonomous Workflows kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Agents with LangChain & Autonomous Workflows kursu toplamda 4 dersten oluşur.

“Asenkron Aracı Yürütme” dersinde ne öğreneceğim?

Aracıların paralel görevleri gerçekleştirmesi ve yanıt verebilirliği artırması için asenkron örüntüleri uygulamayı öğrenin. AI Agents with LangChain & Autonomous Workflows ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

AI Agents with LangChain & Autonomous Workflows öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Agents with LangChain & Autonomous Workflows, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Asenkron Aracı Yürütme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu AI Agents with LangChain & Autonomous Workflows dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Agents with LangChain & Autonomous Workflows dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Karmaşık İş Akışları Tasarlama
  2. Asenkron Aracı Yürütme
  3. Hata Yönetimi ve Dayanıklılık
  4. İnsan Onaylı İş Akışları
← AI Agents with LangChain & Autonomous Workflows Sayfasına Dön