ReAct Agent

In this section, we will build a ReAct (Reasoning and Acting) agent that utilizes mathematical tools to solve multi-step calculations.

Objectives

Implement the ReAct agent design loop.
Bind custom tools to a ChatOpenAI model.
Route queries dynamically using a ToolNode and conditional routing.

Agent III: ReAct Agent

Goal

Build a ReAct agent that binds arithmetic tools (add, subtract, multiply) and dynamically decides whether to execute a tool or finish.

Sample Input

{"messages": [("user", "Add 40 + 12 and then multiply the result by 6.")]}

Sample Output

Outputs performing addition first, then multiplication: 312.

Plan

Define the state schema using add_messages to append messages to history.
Create tools and bind them to the LLM.
Define the LLM call node, the should_continue conditional router, and the ToolNode tool runner.
Build the graph connecting START -> agent, agent -> conditional edge (tools or END), and tools -> agent.

Code Implementation

1. Define the State Schema

We define a state schema using add_messages annotation:

from typing import Annotated, Sequence, TypedDict
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]

2. Define Custom Tools

We define three custom functions decorated with @tool and bind them to the model:

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def add(a: int, b: int):
    """This is an addition function that adds 2 numbers together"""
    return a + b 

@tool
def subtract(a: int, b: int):
    """Subtraction function"""
    return a - b

@tool
def multiply(a: int, b: int):
    """Multiplication function"""
    return a * b

tools = [add, subtract, multiply]
model = ChatOpenAI(model="gpt-4o").bind_tools(tools)

3. Define Nodes and Routing Logic

We write the model call node and the routing function:

from langchain_core.messages import SystemMessage

def model_call(state: AgentState) -> dict:
    system_prompt = SystemMessage(content="You are my AI assistant. Use tools when needed.")
    response = model.invoke([system_prompt] + list(state["messages"]))
    return {"messages": [response]}

def should_continue(state: AgentState) -> str: 
    messages = state["messages"]
    last_message = messages[-1]
    if not last_message.tool_calls: 
        return "end"
    else:
        return "continue"

4. Build and Compile the Graph

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode

graph = StateGraph(AgentState)
graph.add_node("our_agent", model_call)

tool_node = ToolNode(tools=tools)
graph.add_node("tools", tool_node)

graph.set_entry_point("our_agent")

graph.add_conditional_edges(
    "our_agent",
    should_continue,
    {
        "continue": "tools",
        "end": END,
    },
)

graph.add_edge("tools", "our_agent")
app = graph.compile()

5. Invoke the Agent

We invoke the compiled app:

inputs = {"messages": [("user", "Add 40 + 12 and then multiply the result by 6.")]}
for step in app.stream(inputs, stream_mode="values"):
    step["messages"][-1].pretty_print()

Exercise: Division and Power ReAct Agent ➗

Goal

Build a ReAct Agent that adds division (divide) and exponentiation (power) tools, and successfully handles mathematical queries requiring these functions.

Sample Input

{"messages": [("user", "Divide 100 by 4, and then raise the result to the power of 3.")]}

Sample Output

Outputs performing division, then exponentiation, returning the final answer: 15625.0.

Plan

Create two tools @tool for divide(a: float, b: float) and power(base: float, exponent: float).
Bind the new tools list to the model.
Set up the ReAct StateGraph with the agent node, the conditional router should_continue, and the tool node.
Verify step-by-step tool execution.

Solution

from typing import Annotated, Sequence, TypedDict
from langchain_core.messages import BaseMessage, SystemMessage
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.graph.message import add_messages
from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode

# 1. State
class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]

# 2. Define tools
@tool
def divide(a: float, b: float) -> float:
    """Divide function that divides a by b."""
    return a / b

@tool
def power(base: float, exponent: float) -> float:
    """Power function that raises base to the power of exponent."""
    return base ** exponent

tools = [divide, power]
model = ChatOpenAI(model="gpt-4o").bind_tools(tools)

# 3. Nodes and Router
def model_call(state: AgentState) -> dict:
    sys = SystemMessage(content="You are an AI assistant. Use tools when needed.")
    response = model.invoke([sys] + list(state["messages"]))
    return {"messages": [response]}

def should_continue(state: AgentState) -> str:
    last_message = state["messages"][-1]
    if not last_message.tool_calls:
        return "end"
    return "continue"

# 4. Build Graph
graph = StateGraph(AgentState)
graph.add_node("our_agent", model_call)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("our_agent")
graph.add_conditional_edges(
    "our_agent",
    should_continue,
    {
        "continue": "tools",
        "end": END
    }
)
graph.add_edge("tools", "our_agent")
app = graph.compile()

# 5. Test
for step in app.stream({"messages": [("user", "Divide 100 by 4, and raise the result to the power of 3.")]}, stream_mode="values"):
    step["messages"][-1].pretty_print()

Practice & Exercises

To reinforce what you’ve learned in this section, practice with the interactive notebook:

Practice & Exercises

Practice binding custom tools, routing conditional edges based on tool_calls, and handling multi-step reasoning.💻 VS Code | 🚀 Colab | 📥 Download

LangGraph Basics

LangGraph Agents

Objectives

Agent III: ReAct Agent

Goal

Sample Input

Sample Output

Plan

Code Implementation

1. Define the State Schema

2. Define Custom Tools

3. Define Nodes and Routing Logic

4. Build and Compile the Graph

5. Invoke the Agent

Exercise: Division and Power ReAct Agent ➗

Goal

Sample Input

Sample Output

Plan

Practice & Exercises

Practice & Exercises

​Objectives

​Agent III: ReAct Agent

​Goal

​Sample Input

​Sample Output

​Plan

​Code Implementation

​1. Define the State Schema

​2. Define Custom Tools

​3. Define Nodes and Routing Logic

​4. Build and Compile the Graph

​5. Invoke the Agent

​Exercise: Division and Power ReAct Agent ➗

​Goal

​Sample Input

​Sample Output

​Plan

​Practice & Exercises

Practice & Exercises

Objectives

Agent III: ReAct Agent

Goal

Sample Input

Sample Output

Plan

Code Implementation

1. Define the State Schema

2. Define Custom Tools

3. Define Nodes and Routing Logic

4. Build and Compile the Graph

5. Invoke the Agent

Exercise: Division and Power ReAct Agent ➗

Goal

Sample Input

Sample Output

Plan

Practice & Exercises