langgraph/how-tos/react-agent-from-scratch/

[giscus[bot]]

langgraph/how-tos/react-agent-from-scratch/

Build language agents as graphs

https://langchain-ai.github.io/langgraph/how-tos/react-agent-from-scratch/

[austinmw]

Great tutorial, but I'm curious: Where's the explicit reasoning step? Doesn't a true ReAct agent show 'Thought, Action, Observation' cycles? This looks more like a tool-using agent. Shouldn't we see the agent's 'Thought' process before each action? Without explicit thought steps, could this lead to less thorough reasoning and potentially worse performance in complex tasks?

[Linnore]

Same question. Probably the reasoning step is hidden inside the ToolNode.

[hinthornw]

For claude and similar models, the reasoning is done prior to tool calling.
Same for o1.

For OpenAI's gpt-4* models you'd have to explicitly add a field for reasoning to the tool(s).

[davlu93]

Sorry I still did not get it. The react agent imply the use of the react prompt Thought action Observation. Here I do not see any react prompt ...
What does it mean that the reasoning is done prior to tool calling?

[hinthornw]

As in it's prompted to use <> tags to reason before calling a tool.

You all are correct in that this example does not actually use the prompt from the original paper.
Good at naming, we are not. It's meant to credit the react paper as one of the first prototypical language model "agents" operating in a loop but I see how the naming is misleading.

[kentwait]

If there were more than one tool available, then the model in call_model would have to decide which tools to use, if any. You're right that it doesn't explicitly tell us the reason for the action, but the reasoning seems to be there.
The "observation" part always occurs as the output of every tool called is going back to the model, then the model decides whether to call tools again or make a response to end the cycle.

[davlu93]

There is no whatsoever react prompting there. The model does not state it's reasoning, acting and observing steps. SO it's not a react agent for me, it's just an angent

[MarcinRutecki]

Yes - I use this approach as Tool Manager Agent. That is exactly what it does.
They should change the name as it's misleading

[MarcinRutecki]

Why do you import END twice?

from langgraph.graph import StateGraph, END
from langgraph.constants import END

[hinthornw]

We want to be extra certain it's imported, since we use stochastic python

[hinthornw]

(jokes - i think it was a grep gone wrong); fixed here: #2022
Thanks for flagging!

[HasnainKhanNiazi]

This guide is misleading as there is no ReAct prompting and all the reasoning steps are missing. This agent can be called simple "Function calling Agent" or something.

[vbarda]

@HasnainKhanNiazi check out this explanation that we added to the conceptual guides: https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation

[sataycat]

Finally, the paper asked the LLM to explicitly generate a "Thought" step before deciding which tools to call. This is the "Reasoning" part of "ReAct". Our implementation does not do this by default, largely because LLMs have gotten much better and that is not as necessary. Of course, if you wish to prompt it do so, you certainly can.

If we prompt it to do a 'Thought' step, would it affect the tool calling since a message is generated beforehand?

Also wondering if we skip the reasoning step we will skip out on CoT level improvements in the quality of the response

[davlu93]

For sure using the function calling implicit capabilities is better then explicitly prompt the llm to write its thoughts, but I realized that using function calling is tremendously expensive in terms of token consume. It's cheaper to use the react prompting without the function calling (meaning without the bind_tools method) as it's done for the first version of the langchain create react agent where you use a react output parser and the react prompting explicitly

[gtnpromtior]

can u explain more this please ?

[Emekaborisama]

Petition to change this as its misleading

[dglozic]

As in it's prompted to use <> tags to reason before calling a tool.

Sorry for being dense, but what does the above mean? Can an agent using the more-less the same setup as Prebult agent (and ToolNode) make modifications to insert the reasoning step (or at least make LLM 'show its work' while it is choosing tools or decides it has everything it needs?

[Bipin-K-Balan]

I don't think, this is a React agent. As per ReAct paper LLM is explicitly asked to process a query in Thought, Action input, Action and Observation in N loop till its get a final answer and providing tools inside the prompt itself. There the problem is its difficult to parse the tool and tool arguments from natural text output and most of builtin parsers are failing. Here, you bind LLM with tools, the agent will only provide tool call as response, not content untill and unless its a final answer and since there is no thoughts and observations are coming as texts in intermediate steps, we cannot append this to the scratch pad of LLM to track its previous thoughts and actions, this approach wont work to trigger LLM reasoning skills. What you are showing here is just a tool calling agent with some basic prompts.. See, this is an official documentation and you are not supposed to give misleading info. Please provide some good React agent parsers that can parse the tools, arguments effectively from React parsers or provide the bind_tool function has the capability to display reasoning steps that can stand apart from content so that we can append those intermediate steps to scratch pad.

[jasontjahjono]

is there a javascript implementation to this?

[Rahulsharma4298]

I dont why langchain is making things complicated. The create_react_agent of langchain 0.2 makes much sense and it works well.
When I am using langgraph create_react_agent, the agent is most of the time saying "I am sorry, I cannot fulfill this request. The available tools lack the functionality to access real-time weather information."
Also not able to understand if they have create_react_agent function already then why do I need to write these code. It does not seem like react but simple function calling agent.

[MarcinRutecki]

Can you copy-paste your code for defining tavilysearch tool?

[Rahulsharma4298]

from dotenv import load_dotenv
from langchain_community.tools import DuckDuckGoSearchResults
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.language_models import BaseLLM
from langchain_core.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

load_dotenv()


class Agent:
    def __init__(self, model: BaseLLM):
        self.memory = MemorySaver()
        tools = Agent.get_tools()
        self.model = model.bind_tools(tools)
        self._agent_executor = create_react_agent(self.model,
                                                  tools,
                                                  checkpointer=self.memory,
                                                  debug=True)

    @staticmethod
    def get_tools():
        search = TavilySearchResults(max_results=4)
        ddg_search = DuckDuckGoSearchResults()
        tools = [search, ddg_search]
        return tools

    def get_executor(self):
        return self._agent_executor

    def chat(self, query):
        executor = self.get_executor()
        return executor.invoke({"messages": [HumanMessage(query)]},
                               self.config,
                               output_keys='messages')[-1]

    @property
    def config(self):
        config = {"configurable": {"thread_id": "abc123"}}
        return config


if __name__ == '__main__':
    model = ChatGoogleGenerativeAI(model="gemini-1.5-flash")
    agent = Agent(model)
    executor = agent.get_executor()
    resp = executor.invoke({"messages": [HumanMessage('latest news india')]},
                           agent.config, output_keys='messages')
    print(resp[-1].pretty_print())

[MarcinRutecki]

from dotenv import load_dotenv
from langchain_community.tools import DuckDuckGoSearchResults
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.language_models import BaseLLM
from langchain_core.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool

load_dotenv()

class Agent:
def init(self, model: BaseLLM):
"""
Initialize the Agent with a language model and preconfigured tools.

    :param model: A language model object that implements the BaseLLM interface.
    """
    self.memory = MemorySaver()
    tools = Agent.get_tools()
    self.model = model.bind_tools(tools)
    self._agent_executor = create_react_agent(
        self.model,
        tools,
        checkpointer=self.memory,
        debug=True
    )

@staticmethod
@tool
def tavily_search(query: str):
    """
    Use this tool to perform an Internet search.

    When asked about the latest news, always provide detailed and accurate information,
    including sources to support the content and use the current date for the search query.

    :param query: The search query.
    """
    tavily_search_tool = TavilySearchResults(
        max_results=5,
        search_depth="advanced",
        include_answer=True,
        include_raw_content=False
    )
    # Perform the search and return the results
    return tavily_search_tool.run(query)

@staticmethod
@tool
def duckduckgo_search(query: str):
    """
    Use this tool to perform a quick web search using DuckDuckGo.

    Ideal for retrieving general information quickly. This tool is lightweight
    and doesn't include detailed contextual answers.

    :param query: The search query.
    """
    ddg_search_tool = DuckDuckGoSearchResults()
    return ddg_search_tool.run(query)

@staticmethod
def get_tools():
    """
    Fetch the list of tools available to the agent.

    :return: A list of tool instances.
    """
    tools = [Agent.tavily_search, Agent.duckduckgo_search]
    return tools

def get_executor(self):
    """
    Retrieve the executor object for the agent.

    :return: The agent executor instance.
    """
    return self._agent_executor

def chat(self, query):
    """
    Engage in a conversational exchange with the agent.

    :param query: The user's input query or message.
    :return: The agent's response message.
    """
    executor = self.get_executor()
    return executor.invoke({"messages": [HumanMessage(query)]},
                           self.config,
                           output_keys='messages')[-1]

@property
def config(self):
    """
    Provide the configuration settings for the agent.

    :return: A dictionary containing configuration settings.
    """
    config = {"configurable": {"thread_id": "abc123"}}
    return config

if name == 'main':
model = ChatGoogleGenerativeAI(model="gemini-1.5-flash")
agent = Agent(model)
executor = agent.get_executor()
response = executor.invoke(
{"messages": [HumanMessage('latest news india')]},
agent.config,
output_keys='messages'
)
print(response[-1].pretty_print())

[Rahulsharma4298]

TavilySearchResults and DuckDuckGoSearchResults class are already a BaseTool, any reason we are defining it again as a tool. I think BaseTool class have description kwargs that we can change?

[Rahulsharma4298]

I tested it, it is still many times not answering many queries. If I have defined a search tool, it should search any query.
Many times it gives answers like I don't have access to this, please search on website or google.
Specially for follow-up questions. Sometimes response like:
I cannot directly browse the internet or access real-time information, including websites or news articles. My knowledge is based on the data I was trained on.