Restoring Creative Responses in LangGraph: How to Process Tool Returns Like AgentExecutor

[mrctito]

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

@tool
    async def tool_responder_tom_conversa():
        """
        Útil para responder qual o tom atual de conversa
        """
        nome_base = chat_agent.app_keys.BASE_CONHECIMENTO.nome_base
        tons = chat_agent.app_keys.obtem_tons_possiveis()
        tom_conversa_atual = chat_agent.app_keys.BASE_CONHECIMENTO.conversation_mood
        msg = f"O tom da conversa atual da base de conhecimento {nome_base} é {tom_conversa_atual}, e os tons possíveis são {tons}."
        return msg


async def run_agent_graph(self) -> str:
        self.graph = self.get_graph()
        
        result = await self.graph.ainvoke(self.contexto, debug=True)

        message_content = ""
        if 'messages' in result:
            for message in result['messages']:
                if isinstance(message, AIMessage):
                    message_content = message.content
            result = message_content
        else:
            for message in result:
                if isinstance(message, ToolMessage):
                    message_content = message.content

            if message_content:
                # Extrai os valores de 'status' e 'resposta' do conteúdo do ToolMessage
                try:
                    if "return_values=" in message_content:
                        # Converte a string de return_values para um dicionário
                        content_dict = eval(message_content.split("return_values=")[1].split(" log=")[0])
                        status = content_dict.get('status')
                        resposta = content_dict.get('resposta')
                        print(f"Status: {status}, Resposta: {resposta}")
                        result = resposta
                    else:
                        result = message_content
                except (IndexError, SyntaxError, ValueError) as e:
                    result = ""
            else:
                print("Nenhum ToolMessage encontrado.")
                result = ""

        return result



    def get_graph(self):
        websocket = self.websocket
        app_keys = self.app_keys
        app_params = self.app_params

        chat = LLMService(app_keys, app_params, websocket)
        self.streaming = False
        chat.update_streaming(self.streaming)

        prompt_obj = ChatPromptTemplate.from_messages(
            [
                ( "system", self.prompt_str),
                ( "human", "{input}"),
            ]
        )
        
        self.llm_with_tools = self.llm.bind_tools(self.tools)
        agent = prompt_obj | self.llm_with_tools

        graph_builder = MessageGraph()
        graph_builder.add_node("chatbot", self.agent_runnable)
        graph_builder.add_node("tools", self.tool_node)
        graph_builder.add_edge("tools", "chatbot")
    
        graph_builder.add_conditional_edges(
            "chatbot", tools_condition
        )
        graph_builder.set_entry_point("chatbot")
        graph = graph_builder.compile()

Description

Hello @dosu,

I have a question: I migrated my multi-agent project, which uses various tools, from AgentExecutor to LangGraph for a basic initial version, and it is working. However, in the AgentExecutor version, when a tool returned its response, the LLM would process this return and create a creative response. For example, I could return a JSON with multiple fields, and the LLM would use this information to craft a response.

Now, in LangGraph, I am not achieving the same effect. The text returned by the tool is passed along exactly as it is.

For example, I have a tool that fetches the prices of three products. It returns a dict with the product name and price, and in the AgentExecutor version, the LLM would format a nice response. Now, in the LangGraph version, this is no longer happening.

What do I need to adjust in my migrated code to restore this behavior?

Thank you.

System Info

langchain==0.2.6
langchain-community==0.2.6
langchain-core==0.2.10
langchain-experimental==0.0.62
langchain-openai==0.1.13
langchain-qdrant==0.1.0
langchain-text-splitters==0.2.1

[dosubot[bot]]

To restore the behavior where the LLM processes the tool's response and creates a creative response in LangGraph, similar to how it worked in AgentExecutor, you need to ensure that the LangGraph agent is set up to handle the conversation history and process the tool's responses correctly. Here is how you can adjust your migrated code:

1. Define the model and tools:

   from langchain_core.tools import tool
   from langchain_openai import ChatOpenAI
   
   model = ChatOpenAI(model="gpt-4o")
   
   @tool
   def magic_function(input: int) -> int:
       """Applies a magic function to an input."""
       return input + 2
   
   tools = [magic_function]

2. Create the LangGraph agent using create_react_agent:

   from langgraph.prebuilt import create_react_agent
   
   app = create_react_agent(model, tools)

3. Invoke the agent with the initial query and process the response:

   query = "what is the value of magic_function(3)?"
   messages = app.invoke({"messages": [("human", query)]})
   response = {
       "input": query,
       "output": messages["messages"][-1].content,
   }
   print(response)

4. Handle subsequent queries by maintaining the conversation history:

   message_history = messages["messages"]
   
   new_query = "Pardon?"
   messages = app.invoke({"messages": message_history + [("human", new_query)]})
   response = {
       "input": new_query,
       "output": messages["messages"][-1].content,
   }
   print(response)

Additionally, you can leverage the LangChain's standard interface methods such as invoke, batch, and their async counterparts (ainvoke, abatch) to handle the inputs and outputs more effectively. This ensures that the LangGraph agent processes the tool's response and maintains the conversation history, allowing it to create a creative response similar to the behavior in AgentExecutor. For more advanced use cases, consider using the astream_log or astream_events methods to stream intermediate steps and events as they happen ^[1][2].

To continue talking to Dosu, mention @dosu.