ReAct Agent

Build a ReAct agent utilizing custom tools and conditional routing

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

Objectives

1. Implement the ReAct agent design loop.
2. Bind custom tools to a ChatOpenAI model.
3. 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

1. Define the state schema using add_messages to append messages to history.
2. Create tools and bind them to the LLM.
3. Define the LLM call node, the should_continue conditional router, and the ToolNode tool runner.
4. 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

1. Create two tools @tool for divide(a: float, b: float) and power(base: float, exponent: float).
2. Bind the new tools list to the model.
3. Set up the ReAct StateGraph with the agent node, the conditional router should_continue, and the tool node.
4. 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