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