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

ReActエージェントとPlan-and-Executeエージェント

推論と行動を組み合わせ、複雑なタスクを完了する高度なエージェントアーキテクチャを理解・実装します。

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

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

Beyond Simple AI Agents

Welcome to Advanced Agent Architectures! So far, you've learned about basic agents and chains in LangChain. These are great for straightforward tasks.

However, real-world problems can be complex. They often require agents to reason, make decisions, and perform multiple steps to achieve a goal. This is where advanced architectures come in.

Introducing ReAct Agents

One powerful advanced architecture is ReAct, which stands for Reasoning and Acting. It's inspired by how humans solve problems.

Reasoning: The agent thinks about the problem, current state, and what to do next.
Acting: The agent then performs an action, often by using a tool.

This cycle allows agents to dynamically adapt and solve complex tasks.

The ReAct Loop: Thought, Action, Observation

ReAct agents operate in an iterative loop:

Thought: The agent generates a thought, explaining its reasoning and what it plans to do.
Action: Based on the thought, the agent chooses a tool and its input (e.g., 'search', 'calculator').
Observation: The agent receives the result from the tool's execution.

This loop continues until the agent believes it has enough information to provide a final answer.

ReAct in Action: A Simple Flow

Let's see a simplified Python example of how a ReAct agent's logic might flow. Notice how it thinks, acts, and observes to reach a conclusion.

def run_react_agent(query):
    print(f"User Query: {query}")
    print("Thought: I need to find the population of London. I will use a search tool.")
    print("Action: Use 'search_tool' with query 'population of London'")
    # Simulate tool output
    observation = "Observation: The population of London is ~9 million (2023 est.)."
    print(observation)
    print("Thought: I have the information. I can now answer the user.")
    print("Action: Respond with the observed information.")
    return observation.replace("Observation: ", "")

if __name__ == "__main__":
    result = run_react_agent("What is the population of London?")
    print(f"\nFinal Answer: {result}")

Understanding Plan-and-Execute

Another powerful architecture is Plan-and-Execute. Unlike ReAct, which is more reactive, Plan-and-Execute agents first create a comprehensive plan.

They are particularly effective for tasks that are complex, multi-step, and where a clear sequence of actions can be determined upfront.

The Planner and Executor Components

Plan-and-Execute agents typically consist of two main parts:

The Planner: This component takes the initial goal and breaks it down into a sequence of smaller, manageable steps. It focuses on strategy.
The Executor: This component then takes each step from the plan and carries it out, often by using specific tools. It focuses on execution.

This separation helps manage complexity and ensures a structured approach.

Plan-and-Execute: A Structured Flow

Here's a simplified Python example illustrating the Plan-and-Execute flow. Notice how the goal is first planned, then each step is executed in order.

def planner(goal):
    print(f"Goal: {goal}")
    print("Planner: Breaking down the goal into steps...")
    plan = [
        "Step 1: Find today's date.",
        "Step 2: Get the weather forecast for New York City for today.",
        "Step 3: Summarize the date and weather information."
    ]
    print(f"Plan created: {plan}")
    return plan

def executor(step):
    print(f"Executing: {step}")
    if "date" in step:
        return "Observation: Today's date is October 26, 2023."
    elif "weather" in step:
        return "Observation: New York weather: Sunny, 60°F."
    elif "summarize" in step:
        return "Observation: Summary: Oct 26, 2023, NYC is Sunny, 60°F."
    return "Observation: Step completed."

if __name__ == "__main__":
    my_goal = "Tell me today's date and weather in New York City."
    plan_steps = planner(my_goal)
    
    print("\n--- Execution Phase ---")
    for step in plan_steps:
        res = executor(step)
        print(res)

ReAct vs. Plan-and-Execute

Both are powerful, but suited for different scenarios:

ReAct: More dynamic and reactive. Best for tasks where the path isn't clear upfront, requiring exploration and iterative decision-making (e.g., complex research questions).
Plan-and-Execute: More structured and systematic. Best for tasks where a clear sequence of steps can be defined (e.g., booking a flight with known steps: search, select, confirm).

Choosing the Right Architecture

When deciding between ReAct and Plan-and-Execute, consider:

Task Complexity: Is it a clear, sequential task (Plan-and-Execute) or an exploratory, problem-solving one (ReAct)?
Predictability: Can you easily predict the steps needed (Plan-and-Execute) or will the agent need to adapt dynamically (ReAct)?
Error Handling: Plan-and-Execute can sometimes be easier to debug due to defined steps, while ReAct's dynamic nature can be harder to trace.

Quick Check: Agent Architectures

An AI agent needs to solve a complex, multi-step problem where the exact sequence of actions is not known beforehand, and it might need to explore different options and react to intermediate results.

Recap: Advanced Agent Architectures

Great job! In this lesson, you explored two advanced agent architectures:

ReAct (Reasoning and Acting): Agents that iteratively think, act, and observe, suitable for dynamic, exploratory tasks.
Plan-and-Execute: Agents that first create a detailed plan and then execute each step, ideal for structured, multi-step workflows.

Understanding these patterns helps you build more robust and intelligent AI agents for complex challenges. Next, we'll look at agents that can self-correct!

よくある質問

「ReActエージェントとPlan-and-Executeエージェント」レッスンは無料ですか？

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

「ReActエージェントとPlan-and-Executeエージェント」で何を学びますか？

推論と行動を組み合わせ、複雑なタスクを完了する高度なエージェントアーキテクチャを理解・実装します。ブラウザで直接実行するハンズオンコードでAI Agents with LangChain & Autonomous Workflowsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

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

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

「ReActエージェントとPlan-and-Executeエージェント」レッスンにはどのくらい時間がかかりますか？

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

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

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

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

← AI Agents with LangChain & Autonomous Workflowsに戻る