Interrupt on a specific tool when using Langgraph ReAct Agent

[nathan-vo810]

I have been looking into Human In the Loop for Langgraph React Agent here: https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-hitl/

In the tutorial, the graph is interrupted at every tool call.

graph = create_react_agent(model, tools=tools, interrupt_before=["tools"], checkpointer=memory)

However, I don't want it to stop at every single tool call but instead stop at a specific tool such as AskHuman like in this tutorial: https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/wait-user-input/

I cannot use the chain with tools as for my usecase it is required to have an agent. So, how can I have my langgraph agent only stop on a specific tool?

Thank you in advance.

[hinthornw]

For that, I'd make my own graph, have two tool nodes - one where I'd have an interrupt and the other I wouldn't.

We demonstrate this in the customer support tutorial

[Michael-YongWang]

If multi tools are called at the same time, how to use multi tool nodes to separately make the function call in parallel? Could you please show an example?

[sharyar]

@hinthornw would you mind sharing the customer support tutorial?

[nimishdm-airindia]

If multi tools are called at the same time, how to use multi tool nodes to separately make the function call in parallel? Could you please show an example?

@Michael-YongWang Did you find the solution?

[AruWipro]

Did you get any information ?

[RajuGangitla]

this one is not using ReAct Agent and here agent is llm with bind tools

check this flow using this you can interrput at specific tool calls
https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/review-tool-calls/

[thanhhuynhk17]

Use case: I wanted to interrupt the LangGraph ReAct agent when a specific tool is about to be called (summary_file), so a human can review and optionally edit the parameters before the call executes.

I used the built-in post_model_hook like this:

def use_post_hook(state, config: RunnableConfig):
    last_msg = state["messages"][-1]
    if isinstance(last_msg, ToolMessage):
        with open("post_messages.md", "w", encoding="utf-8") as f:
            f.write(f"\n{last_msg.model_dump_json()}\n")


    if not isinstance(last_msg, AIMessage):
        return # do nothing
    print("Post hooked: check action.")
    new_msg = process_ai_message(last_msg)
    if not new_msg: # has no new message, do nothing!
        return

    tool_calls = new_msg.additional_kwargs.get("tool_calls", None)
    print("tool_calls", tool_calls)
    if tool_calls and tool_calls[0]["function"]["name"] in ["summary_file"]:
        print("---human_feedback---")
        feedback = interrupt({
            "name": tool_calls[0]["function"]["name"],
            "type": "ask", 
            "content": f"{tool_calls[0]["function"]["arguments"]}"
            })
        print("feedback", feedback)
        # handle feedback
        ...
    return {
        "messages": [RemoveMessage(id=last_msg.id), new_msg],
    }

And then passed it to the agent:

geoda_agent = create_react_agent(
  ...,
  post_model_hook=use_post_hook,
  ...,
)

[ahmad5149]

If you want to introduce Human-in-the-Loop approval before calling certain tools (e.g. risky actions like place_order), you can use a post_model_hook with interrupt.
Here’s a working example 👇

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
from langgraph.types import interrupt
from langchain_core.messages import AIMessage
from langgraph.checkpoint import InMemorySaver
from IPython.display import display, Image

# Define which tools require human approval
RISKY_TOOLS = ["get_user_info", "place_order"]

def halt_on_risky_tools(state):
    lastmsg = state["messages"][-1]
    if isinstance(lastmsg, AIMessage) and getattr(lastmsg, "tool_calls", None):
        for tc in lastmsg.tool_calls:
            if tc.get("name") in RISKY_TOOLS:
                # Pause execution until human approves
                _ = interrupt({"awaiting": tc["name"], "args": tc.get("args", {})})
    return {}

# Example tools
@tool(return_direct=True)
def get_user_info(name: str, age: int) -> None:
    """Testing tool."""
    return f"User {name} is {age} years old."

@tool(return_direct=True)
def place_order(product_id: str, price: int) -> None:
    """Use this tool to place an order."""
    return f"Order placed successfully for {product_id} {price}"

# Add checkpointing
checkpointer = InMemorySaver()

# Create agent with risky tool interruption
agent = create_react_agent(
    model=llm,
    tools=[get_user_info, place_order],
    post_model_hook=halt_on_risky_tools,
    checkpointer=checkpointer,
)

# (Optional) visualize the graph in Jupyter
display(Image(agent.get_graph().draw_mermaid_png()))

##How You can call it

config = {"configurable": {"thread_id": "user_123"}}

llm_output= agent.invoke(
    {"messages": [{"role": "user", "content": "I want to place the order for 1000 USD againstg the id 123"}]}, config=config
)

for message in llm_output['messages']:
    print(message.pretty_print())

##How you can resume it

response = agent.invoke(Command(resume=True), config=config)

for message in response["messages"]:
    
    print(message.pretty_print())
    
    ```