Please add humanintheloop after checkweather in the following code:import operator from…
- User
Please add human_in_the_loop after check_weather in the following code:import operator from typing import TypedDict from typing_extensions import Annotated from langgraph.graph import StateGraph, END
Define our state class State(TypedDict): messages: Annotated[list, operator.add] location: str weather: str
Create our graph workflow = StateGraph(State)
Define our nodes def greet(state): print("state:",state) return {"messages": [("ai", "Hello! I'm your weather assistant. Where are you located?")]}
def get_location(state): print("state:",state) return {"location": state["messages"][-1][1]}
def check_weather(state): print("state:",state)
In a real app, we'd call a weather API here
weather = "sunny" if "new york" in state["location"].lower() else "rainy" return {"weather": weather}
def report_weather(state): print("state:",state) return {"messages": [ ("ai", f"The weather in {state['location']} is {state['weather']}. Can I help you with anything else?")]}
Add nodes to our graph workflow.add_node("greet", greet) workflow.add_node("get_location", get_location) workflow.add_node("check_weather", check_weather) workflow.add_node("report_weather", report_weather)
Connect our nodes workflow.set_entry_point("greet") workflow.add_edge("greet", "get_location") workflow.add_edge("get_location", "check_weather") workflow.add_edge("check_weather", "report_weather") workflow.add_edge("report_weather", END)
Compile our graph app = workflow.compile()
Run our app inputs = {"messages": [("human", "Hi, I'd like to check the weather.")]} for output in app.stream(inputs): for key, value in output.items(): print(f"{key}: {value}")
Assistant
Of course! Adding a "human-in-the-loop" step is a key feature of LangGraph, allowing you to pause the graph's execution and wait for external input.
The most common way to do this is to add a node that will act as a stopping point and then use the
.compile(interrupt_after=["node_name"])method. The graph will run until it completes that node, then pause. You can then provide the human's input and resume the graph.Here is the modified code with the
human_in_the_loopstep added right aftercheck_weather.Changes Made:
- Added a
human_in_the_loopnode: This new node simply asks the user for confirmation before proceeding. It acts as a clear, named step in our graph where we want to pause. - Rewired the graph edges: The connection now flows from
check_weatherto our newhuman_in_the_loopnode. - Added a Conditional Edge: After the human provides input, we need to decide what to do. A new
decide_to_reportfunction checks the user's last message.- If the user says "yes" (or similar), it routes to
report_weather. - Otherwise, it routes to
END.
- If the user says "yes" (or similar), it routes to
- Compiled with
interrupt_after: We tell the graph to pause execution immediately after thehuman_in_the_loopnode is finished. - Updated Execution Flow: The final section of the code is updated to show how to run the graph, provide the human input when it pauses, and then resume it.
Updated Code
import operator import time from typing import TypedDict from typing_extensions import Annotated from langgraph.graph import StateGraph, END # Define our state class State(TypedDict): messages: Annotated[list, operator.add] location: str weather: str # Create our graph workflow = StateGraph(State) # Define our nodes def greet(state): print("--- GREETING ---") print("state:",state) return {"messages": [("ai", "Hello! I'm your weather assistant. Where are you located?")]} def get_location(state): print("--- GETTING LOCATION ---") print("state:",state) # Get the last human message for the location return {"location": state["messages"][-1][1]} def check_weather(state): print("--- CHECKING WEATHER ---") print("state:",state) # In a real app, we'd call a weather API here weather = "sunny" if "new york" in state["location"].lower() else "rainy" return {"weather": weather} # NEW NODE: This is our human-in-the-loop step. # The graph will pause after this node runs. def human_in_the_loop(state): print("--- HUMAN IN THE LOOP ---") print("state:",state) # The AI asks for confirmation before reporting the weather return {"messages": [ ("ai", f"I have the weather for {state['location']}. Shall I report it?") ]} def report_weather(state): print("--- REPORTING WEATHER ---") print("state:",state) # The final report return {"messages": [ ("ai", f"The weather in {state['location']} is {state['weather']}. Goodbye!")]} # NEW FUNCTION: This is a conditional router. It checks the last human message # to decide the next step. def decide_to_report(state): """ Checks the last human message. If it's "yes", we'll report the weather. Otherwise, we'll end the conversation. """ print("--- DECIDING NEXT STEP ---") last_message = state["messages"][-1][1] if "yes" in last_message.lower(): return "report_weather" else: print("--- ENDING ---") return END # Add nodes to our graph workflow.add_node("greet", greet) workflow.add_node("get_location", get_location) workflow.add_node("check_weather", check_weather) workflow.add_node("human_in_the_loop", human_in_the_loop) # Add the new node workflow.add_node("report_weather", report_weather) # Connect our nodes workflow.set_entry_point("greet") workflow.add_edge("greet", "get_location") workflow.add_edge("get_location", "check_weather") # The graph now goes from checking the weather to the human-in-the-loop step workflow.add_edge("check_weather", "human_in_the_loop") # After the human-in-the-loop step, we use our conditional router workflow.add_conditional_edges( "human_in_the_loop", decide_to_report, # The dictionary maps the router's return value to the next node { "report_weather": "report_weather", END: END } ) workflow.add_edge("report_weather", END) # Compile our graph, telling it to interrupt AFTER the human_in_the_loop node app = workflow.compile(interrupt_after=["human_in_the_loop"]) # Run our app - now a two-step process print("--- STARTING APP ---") # Initial input from the user initial_input = {"messages": [("human", "I want to know the weather in New York.")]} # STEP 1: Run the graph until it interrupts print("\n--- RUN 1: Executing until interruption ---") interrupted_state = app.invoke(initial_input) # The graph has paused. `interrupted_state` contains the current state. # The last message is the AI asking for confirmation. print("\n--- PAUSED ---") print("Current Messages:", interrupted_state['messages']) # STEP 2: Get human input and resume the graph print("\n--- PROVIDING HUMAN INPUT AND RESUMING ---") # In a real app, you would get this from a user interface. # Here, we simulate the user saying "yes". human_response = {"messages": [("human", "Yes, please report it.")]} # To resume, we call `invoke` again with the state from the interruption # AND the new human message. LangGraph automatically merges the new message. final_state = app.invoke(interrupted_state | human_response) print("\n--- RUN 2: Resumed and finished execution ---") print("Final Messages:", final_state['messages']) print("\n--- APP FINISHED ---")- Added a
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.