How to Chain Tool Outputs as Inputs in LangChain Tool-Calling Agent

[MayankBitcot]

I'm working with LangChain's tool-calling agent, and I need to chain the outputs of two tools together. Specifically, I want to call Tool A with input "X", which will return output "Y". Then, I want to pass that "Y" output as the input for Tool B and get its output "Z".

However, I'm not sure how to properly pass the output from Tool A as the input to Tool B within the LangChain framework.

Has anyone successfully implemented this or can provide guidance on how to achieve this chaining of tool outputs as inputs in LangChain's tool-calling agent? Any help would be greatly appreciated!

[dosubot[bot]]

To chain the outputs of two tools in LangChain's tool-calling agent, you can use the AgentExecutor to manage the sequence of tool usage. Here's a step-by-step guide on how to pass the output from Tool A as the input to Tool B:

1. Define Your Tools: Use the @tool decorator to define your tools. This decorator helps in creating tools by associating a Python function with a schema that defines the function's name, description, and expected arguments.

2. Create a Tool-Calling Agent: Use the create_tool_calling_agent function to create an agent that can call these tools.

3. Use the AgentExecutor: This will execute the agent with the desired input, allowing the agent to decide the order and number of times to use the tools based on the input.

Here's an example setup:

from langchain_core.tools import tool
from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_openai.chat_models import ChatOpenAI

# Define your tools
@tool
def tool_a(input_data: str) -> str:
    """Process input data and return a result."""
    return f"Processed {input_data}"

@tool
def tool_b(processed_data: str) -> str:
    """Take processed data and perform another operation."""
    return f"Further processed {processed_data}"

# Initialize the language model
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Create a tool-calling agent
tools = [tool_a, tool_b]
prompt = hub.pull("hwchase17/openai-tools-agent")
agent = create_tool_calling_agent(llm, tools, prompt)

# Create an agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Execute the agent with input that requires chaining
result = agent_executor.invoke(
    {
        "input": "Start with some data, process it with Tool A, and then pass the result to Tool B"
    }
)

print(result)

This setup allows the agent to effectively chain the output of Tool A as the input to Tool B ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[decode-mayank]

@dosu

I am trying the code below, but the problem is that the output of Tool_A is not being passed to Tool_B. Instead, Tool_B is taking the input of Tool_A. I need Tool_B to take the output of Tool_A

@tool
def tool_A(conversation_history: str):
    """
    Process conversation_history and return a result
    """
    UPDATED_PROMPT = GENERATE_JSON_SCHEMA.format(conversation_history=conversation_history)

    # Use LLM to generate the JSON schema based on the conversation history
    response = intent_llm.invoke(UPDATED_PROMPT)

    # Check and parse the 'content' attribute of the response
    if hasattr(response, 'content'):
        raw_content = response.content  # Extract the raw content
    else:
        print("Response object does not have a 'content' attribute.")
        return {"error": "Unexpected response format"}

    # Clean and parse the output (assuming it is in a JSON markdown/code block)
    try:
        cleaned_output = raw_content.strip('```json\n').strip('```')  # Remove code block formatting
        json_data = json.loads(cleaned_output)  # Parse the cleaned JSON

        return f"Processed {json_data}"
    except json.JSONDecodeError as e:
        print("Error parsing JSON:", e)
        return {"error": "Invalid JSON format generated"}
    
@tool
def tool_B(processed_data):
    """
    Take processed data and perform another operation.
    """
    try:
        endpoint_url = os.getenv("N8N_ENDPOINT")
        response = requests.post(endpoint_url, json=processed_data)
        if response.status_code == 200:
            print("Data successfully sent to the endpoint.")
            return "Email sent successfully"
        else:
            print(f"Failed to send data. Status code: {response.status_code}, Response: {response.text}")
            return "Email not sent"
    except Exception as e:
        print(f"Error sending JSON to endpoint: {e}")
        return "Email not sent"
        
        
 GENERAL_SUPPORT_PROMPT = ChatPromptTemplate.from_messages(
        [
            ("system", UPDATED_SUPPORT_TEMPLATE),
            ("user", "{input}"),
            MessagesPlaceholder(variable_name="agent_scratchpad"),
        ]
    )
   
    general_support_tools = [tool_A,tool_B]
    general_support_agent = create_tool_calling_agent(llm,general_support_tools,GENERAL_SUPPORT_PROMPT)

    general_support_agent_executor = AgentExecutor(agent=general_support_agent, tools=general_support_tools, verbose=True)

    
    response = general_support_agent_executor.invoke({"input": input_text})

[feijoes]

@MayankBitcot try checking https://python.langchain.com/docs/how_to/tool_runtime/. This might help or maybe using SequentialChain might work

[dosubot[bot]]

To ensure that the output of Tool_A is correctly passed as the input to Tool_B, you need to manage the flow of data between these tools explicitly. The AgentExecutor should be set up to handle this chaining logic. Here's a refined approach to achieve this:

1. Modify the Execution Logic: Ensure that the output of Tool_A is captured and then explicitly passed to Tool_B.

2. Use Intermediate Variables: Store the output of Tool_A and use it as the input for Tool_B.

Here's an example of how you can modify your code to achieve this:

# Define your tools
@tool
def tool_A(conversation_history: str):
    """
    Process conversation_history and return a result
    """
    UPDATED_PROMPT = GENERATE_JSON_SCHEMA.format(conversation_history=conversation_history)
    response = intent_llm.invoke(UPDATED_PROMPT)

    if hasattr(response, 'content'):
        raw_content = response.content
    else:
        print("Response object does not have a 'content' attribute.")
        return {"error": "Unexpected response format"}

    try:
        cleaned_output = raw_content.strip('```json\n').strip('```')
        json_data = json.loads(cleaned_output)
        return json_data  # Return the JSON data directly
    except json.JSONDecodeError as e:
        print("Error parsing JSON:", e)
        return {"error": "Invalid JSON format generated"}

@tool
def tool_B(processed_data):
    """
    Take processed data and perform another operation.
    """
    try:
        endpoint_url = os.getenv("N8N_ENDPOINT")
        response = requests.post(endpoint_url, json=processed_data)
        if response.status_code == 200:
            print("Data successfully sent to the endpoint.")
            return "Email sent successfully"
        else:
            print(f"Failed to send data. Status code: {response.status_code}, Response: {response.text}")
            return "Email not sent"
    except Exception as e:
        print(f"Error sending JSON to endpoint: {e}")
        return "Email not sent"

# Initialize the language model and tools
general_support_tools = [tool_A, tool_B]
general_support_agent = create_tool_calling_agent(llm, general_support_tools, GENERAL_SUPPORT_PROMPT)
general_support_agent_executor = AgentExecutor(agent=general_support_agent, tools=general_support_tools, verbose=True)

# Execute the agent with input that requires chaining
tool_a_output = tool_A(input_text)  # Call Tool A and get its output
response = tool_B(tool_a_output)  # Pass the output of Tool A to Tool B

print(response)

In this setup, tool_A processes the input and returns JSON data, which is then directly passed to tool_B. This ensures that the output of Tool_A is used as the input for Tool_B. Adjust the logic as needed to fit your specific use case.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[deok0726]

Hi, is there any update about this work?
I have same problem with passing one tool's output to another's input

[MayankBitcot]

Not from their side, but we found a workaround for that.
For giving tool A's output to tool B's input, you have to put a delay between these tools, the problem here is when agent ran the tools, tool A's output is not processed and tool B initialized, for this we have add another tool and logic is to use time.sleep(3), so the 3 sec delay between tool A and tool B works for us. And put the clear instructions in prompt for sequential tool calling like- tool A ---> wait tool--> tool B..
You can also try the same, hope will work for you also.