How to structure the output of react_agent？

[jaxonister]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

def test_agent(self):
    llm = OpenAi()
    tools = GenImgTextToolkit(chatgpt_model=llm).get_tools()
    debug(f"current_model: {llm.model_name}")
    agent = create_react_agent(model=self.llm,tools=self.tools,state_modifier=self.state_modifier)
    result = agent.run("xxxx")

Description

How to structure the output of react_agent?

System Info

langchain==0.2.14
langchain-community==0.2.12
langchain-core==0.2.33
langchain-experimental==0.0.64
langchain-ollama==0.1.1
langchain-openai==0.1.22
langchain-text-splitters==0.2.2

[dosubot[bot]]

Hello, @jaxonister! I'm here to help you with any bugs, questions, or contribution guidance you might need. Let's work together to find a solution while you wait for a human maintainer.

To structure the output of react_agent in LangChain, you can use the ReActOutputParser class. This class expects the output to be in a specific format:

1. Action Format:

   Thought: agent thought here
   Action: search[what is the temperature in SF?]
   

2. Final Answer Format:

   Thought: agent thought here
   Action: Finish[The temperature is 100 degrees]
   

The ReActOutputParser class uses regex patterns to parse the output and determine whether it should return an AgentAction or an AgentFinish.

Here is the relevant code snippet from the class:

import re
from typing import Union

from langchain_core.agents import AgentAction, AgentFinish
from langchain_core.exceptions import OutputParserException

from langchain.agents.agent import AgentOutputParser


class ReActOutputParser(AgentOutputParser):
    """Output parser for the ReAct agent."""

    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
        action_prefix = "Action: "
        if not text.strip().split("\n")[-1].startswith(action_prefix):
            raise OutputParserException(f"Could not parse LLM Output: {text}")
        action_block = text.strip().split("\n")[-1]

        action_str = action_block[len(action_prefix) :]
        # Parse out the action and the directive.
        re_matches = re.search(r"(.*?)\[(.*?)\]", action_str)
        if re_matches is None:
            raise OutputParserException(
                f"Could not parse action directive: {action_str}"
            )
        action, action_input = re_matches.group(1), re_matches.group(2)
        if action == "Finish":
            return AgentFinish({"output": action_input}, text)
        else:
            return AgentAction(action, action_input, text)

    @property
    def _type(self) -> str:
        return "react"

This code ensures that the output is correctly parsed and structured based on the expected format ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[jaxonister]

What are the detailed steps?

[dosubot[bot]]

To structure the output of react_agent in LangChain, follow these detailed steps:

1. Define the Prompt Template:
   Create a prompt template that includes the necessary input keys: tools, tool_names, and agent_scratchpad.

   from langchain_core.prompts import PromptTemplate
   
   template = '''Answer the following questions as best you can. You have access to the following tools:
   
   {tools}
   
   Use the following format:
   
   Question: the input question you must answer
   Thought: you should always think about what to do
   Action: the action to take, should be one of [{tool_names}]
   Action Input: the input to the action
   Observation: the result of the action
   ... (this Thought/Action/Action Input/Observation can repeat N times)
   Thought: I now know the final answer
   Final Answer: the final answer to the original input question
   
   Begin!
   
   Question: {input}
   Thought:{agent_scratchpad}'''
   
   prompt = PromptTemplate.from_template(template)

2. Create the ReAct Agent:
   Use the create_react_agent function to create the agent. This function requires a language model (llm), a sequence of tools, the prompt template, and optionally an output parser and tools renderer.

   from langchain import hub
   from langchain_community.llms import OpenAI
   from langchain.agents import create_react_agent, AgentExecutor
   
   # Pull the prompt from the hub
   prompt = hub.pull("hwchase17/react")
   model = OpenAI()
   tools = [...]  # Define your tools here
   
   agent = create_react_agent(model, tools, prompt)
   agent_executor = AgentExecutor(agent=agent, tools=tools)

3. Invoke the Agent:
   Use the agent_executor to invoke the agent with the required input.

   result = agent_executor.invoke({"input": "hi"})

4. Handle Chat History (Optional):
   If you need to use chat history, include it in the input.

   from langchain_core.messages import AIMessage, HumanMessage
   
   result_with_history = agent_executor.invoke(
       {
           "input": "what's my name?",
           "chat_history": "Human: My name is Bob\nAI: Hello Bob!",
       }
   )

5. Parse the Output:
   Use the ReActOutputParser to parse the output of the agent. This parser expects the output to be in a specific format and can handle both actions and final answers.

   from langchain.agents.output_parsers.react_output_parser import ReActOutputParser
   
   output_parser = ReActOutputParser()
   
   parsed_output = output_parser.parse(result)

   The ReActOutputParser expects the output to be in one of two formats:

   • For actions:

     Thought: agent thought here
     Action: search
     Action Input: what is the temperature in SF?
     

   • For final answers:

     Thought: agent thought here
     Final Answer: The temperature is 100 degrees
     

By following these steps, you can structure the output of react_agent in LangChain effectively ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[jaxonister]

The message returned by the agent is {"messages":[HumanMessage,AIMessage |,ToolMessage]}