ReAct agent implementation in LangChain - Step-by-Step Execution

Concept Flow - ReAct agent implementation

Start: Receive user query

↓

Agent decides: Think or Act?

↓

Think: Reason

↓

Update agent memory with observation

↓

Check if answer ready

↓

Return answer

↓

End

The ReAct agent loops between thinking (reasoning) and acting (calling tools), updating memory until it produces a final answer.

Execution Sample

LangChain

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

# Define tools and initialize agent
agent = initialize_agent(tools, llm, agent='zero-shot-react-description')

This code sets up a ReAct agent with tools and a language model to handle user queries by reasoning and acting.

Execution Table

Step	Agent Input	Agent Action	Tool Called	Observation	Agent Memory Update	Answer Ready?
1	User query: 'What is the capital of France?'	Think: Plans to find capital	None	None	Stores plan to use knowledge tool	No
2	Plan: Use knowledge tool	Act: Calls knowledge tool	Knowledge Tool	Paris	Stores observation 'Paris'	No
3	Observation: 'Paris'	Think: Confirms answer	None	None	Updates memory with confirmation	Yes
4	Final answer ready	Return answer: 'The capital of France is Paris.'	None	None	Ends process	Yes

💡 Agent returns final answer after confirming observation matches query.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
agent_memory	{}	{plan: 'use knowledge tool'}	{plan: 'use knowledge tool', observation: 'Paris'}	{plan: 'use knowledge tool', observation: 'Paris', confirmation: true}	{final_answer: 'The capital of France is Paris.'}

Key Moments - 2 Insights

Why does the agent alternate between thinking and acting?

The agent first thinks to decide what to do, then acts by calling a tool. This cycle repeats until it has enough info to answer, as shown in steps 1-3 in the execution table.

What happens if the tool returns no useful observation?

The agent updates memory with the observation (even if empty) and thinks again to decide next steps, continuing the loop until answer is ready.

Visual Quiz - 3 Questions

Look at the execution table, what does the agent do at step 2?

A Calls a tool to get information

B Returns the final answer

C Thinks about the next step without calling a tool

D Ends the process without answer

💡 Hint

Check the 'Agent Action' and 'Tool Called' columns at step 2.

At which step does the agent confirm it has enough information to answer?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Answer Ready?' column to see when it changes to Yes.

If the tool returned no observation at step 2, how would the agent proceed?

A Return an empty answer immediately

B Update memory with empty observation and think again

C Stop and report an error

D Call a different tool without thinking

💡 Hint

Refer to the key moment about handling empty observations.

Concept Snapshot

ReAct agent loops: Think (reason) -> Act (call tool) -> Observe -> Update memory.
Repeat until answer is ready.
Use tools to get info, then reason to decide next step.
Final output returned when confident.
This cycle enables dynamic problem solving.

Full Transcript

The ReAct agent starts by receiving a user query. It thinks about how to answer, then acts by calling a tool if needed. The tool returns an observation, which the agent stores in memory. The agent thinks again to decide if it has enough info. This loop continues until the agent is confident to return a final answer. For example, when asked 'What is the capital of France?', the agent plans to use a knowledge tool, calls it, gets 'Paris', confirms the answer, and returns it. This process shows how the agent dynamically reasons and acts to solve problems.

Practice

1. What is the main purpose of a ReAct agent in LangChain?

easy

A. To store data without processing or reasoning

B. To only perform simple, single-step actions without reasoning

C. To replace language models with rule-based systems

D. To combine reasoning and actions step-by-step to solve complex tasks

Solution

1. Step 1: Understand the ReAct agent concept

   The ReAct agent is designed to think (reason) and act (perform tasks) in steps.

2. Step 2: Identify its main use

   It helps solve problems that need multiple steps, like searching and calculating.

3. Final Answer:

   To combine reasoning and actions step-by-step to solve complex tasks -> Option D

4. Quick Check:

   ReAct agent = reasoning + actions [OK]

Hint: ReAct means think and act together step-by-step [OK]

Common Mistakes:

• Thinking it only acts without reasoning
• Confusing it with simple action-only agents
• Assuming it replaces language models

2. Which of the following is the correct way to create a ReAct agent in LangChain?

easy

A. agent = ReActAgent(llm=llm, tools=tools)

B. agent = ReActAgent(tools=llm, llm=tools)

C. agent = ReActAgent()

D. agent = ReActAgent(llm)

Solution

1. Step 1: Recall ReAct agent constructor parameters

   The ReAct agent requires a language model (llm) and a list of tools (tools) as named arguments.

2. Step 2: Check each option for correct syntax

   agent = ReActAgent(llm=llm, tools=tools) correctly passes llm and tools by name. agent = ReActAgent(tools=llm, llm=tools) swaps them incorrectly. agent = ReActAgent() misses required arguments. agent = ReActAgent(llm) passes only llm without tools.

3. Final Answer:

   agent = ReActAgent(llm=llm, tools=tools) -> Option A

4. Quick Check:

   Correct parameters = llm and tools [OK]

Hint: Pass llm and tools as named parameters to ReActAgent [OK]

Common Mistakes:

• Swapping llm and tools arguments
• Omitting required parameters
• Passing parameters positionally without names

3. Given this code snippet, what will be the output behavior of the ReAct agent?

from langchain.agents import ReActAgent
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
tools = [search_tool, calculator_tool]
agent = ReActAgent(llm=llm, tools=tools)

response = agent.run('What is the capital of France and what is 5 plus 3?')

medium

A. The agent will first search for the capital of France, then calculate 5 plus 3, returning both answers.

B. The agent will only perform the search and ignore the calculation.

C. The agent will return an error because multiple tools cannot be used.

D. The agent will calculate 5 plus 3 first, then search for the capital.

Solution

1. Step 1: Understand ReAct agent multi-tool usage

   The ReAct agent can use multiple tools and decides which to use based on the question.

2. Step 2: Analyze the question and agent behavior

   The question asks two things: capital of France (search) and 5 plus 3 (calculator). The agent will perform both actions step-by-step.

3. Final Answer:

   The agent will first search for the capital of France, then calculate 5 plus 3, returning both answers. -> Option A

4. Quick Check:

   Multi-tool agent answers multi-part questions [OK]

Hint: ReAct agents use all needed tools for multi-part questions [OK]

Common Mistakes:

• Thinking agent uses only one tool per run
• Assuming order is reversed without reason
• Believing multiple tools cause errors

4. What is the likely cause of this error when running a ReAct agent?

TypeError: ReActAgent.__init__() missing 1 required positional argument: 'llm'

medium

A. The ReActAgent does not accept an llm argument.

B. The tools list was empty, causing the error.

C. The ReActAgent was created without passing the required language model (llm) argument.

D. The run method was called with an invalid input string.

Solution

1. Step 1: Interpret the error message

   The error says the __init__ method is missing the required 'llm' argument.

2. Step 2: Identify correct constructor usage

   ReActAgent requires an llm parameter when created. Missing it causes this TypeError.

3. Final Answer:

   The ReActAgent was created without passing the required language model (llm) argument. -> Option C

4. Quick Check:

   Missing llm argument = TypeError [OK]

Hint: Always pass llm when creating ReActAgent [OK]

Common Mistakes:

• Forgetting to pass llm argument
• Confusing tools argument with llm
• Misreading error as related to run method

5. You want to build a ReAct agent that can handle a question requiring web search, math calculation, and database lookup. Which setup correctly supports this multi-step reasoning and acting?

hard

A. Create separate agents for each tool and run them independently without combining

B. Create a ReActAgent with llm and a tools list including search_tool, calculator_tool, and db_tool

C. Use only the calculator_tool since it can handle all tasks internally

D. Create a ReActAgent with llm but no tools, relying on the model alone

Solution

1. Step 1: Identify the need for multiple tools

   The question requires web search, math calculation, and database lookup, so multiple tools are needed.

2. Step 2: Choose the correct agent setup

   ReActAgent supports multiple tools passed as a list along with the llm to reason and act step-by-step.

3. Step 3: Evaluate other options

   Separate agents won't combine reasoning easily; calculator_tool alone can't do all tasks; no tools means no external actions.

4. Final Answer:

   Create a ReActAgent with llm and a tools list including search_tool, calculator_tool, and db_tool -> Option B

5. Quick Check:

   Multi-tool ReActAgent = best for multi-step tasks [OK]

Hint: Pass all needed tools in one ReActAgent for multi-step tasks [OK]

Common Mistakes:

• Trying to run separate agents instead of one combined
• Assuming one tool can do all tasks
• Not passing any tools to the agent