Update app.py

app.py

@@ -1,30 +1,39 @@
 import gradio as gr
 from langgraph.graph import StateGraph, END
-from langgraph.checkpoint.sqlite import SqliteSaver # Changed import
+from langgraph.checkpoint.sqlite import SqliteSaver
 from langgraph.checkpoint.memory import MemorySaver
 import operator
 from typing import TypedDict, Annotated, Optional
 import uuid
-import os # Import os for path handling
+import os
 
-# --- 1. Define your Graph State (Same as before) ---
+# --- 1. Define your Graph State ---
 class GraphState(TypedDict):
     greeting_message: str
     human_input: Annotated[Optional[str], operator.add]
     final_response: str
     current_node: str
 
-# --- 2. Define the Nodes (Same as before) ---
+# --- 2. Define the Nodes ---
 def greeting_node(state: GraphState) -> GraphState:
     greeting = "Hello there! I'm an AI assistant. How can I help you today?"
     print("🤖 Greeting Node Executed:")
     print(greeting)
     return {"greeting_message": greeting, "current_node": "greeting"}
 
+# IMPORTANT CHANGE HERE: Remove input() from this node!
 def human_input_node(state: GraphState) -> GraphState:
-    print("\n✋ Human Input Node Executed (Graph was resumed with input):")
-    user_response = input("Please enter your response (e.g., 'I want to know about LangChain'): ")
-    return {"human_input": user_response, "current_node": "human_input_interrupt"}
+    """
+    Node 2: This node now simply acts as the interruption point.
+    The human input will be provided by the Gradio UI *after* this node runs and interrupts.
+    """
+    print("\n✋ Human Input Node Executed (This is where graph will interrupt AFTER running this node):")
+    # This node returns its current_node state. The actual human_input will be added
+    # to the state during the RESUME phase from the Gradio UI.
+    # Since we are using 'interrupt_after' and human_input_node doesn't take input directly,
+    # the 'human_input' will only appear in the state after 'resume_graph' sends it.
+    return {"current_node": "human_input_interrupt"}
+
 
 def human_response_display_node(state: GraphState) -> GraphState:
     human_response = state.get("human_input", "No human input received.")
@@ -33,7 +42,7 @@ def human_response_display_node(state: GraphState) -> GraphState:
     print(final_message)
     return {"final_response": final_message, "current_node": "human_response_display"}
 
-# --- 3. Build the Graph (Same as before) ---
+# --- 3. Build the Graph ---
 builder = StateGraph(GraphState)
 builder.add_node("greeting", greeting_node)
 builder.add_node("human_input_interrupt", human_input_node)
@@ -44,37 +53,35 @@ builder.add_edge("greeting", "human_input_interrupt")
 builder.add_edge("human_response_display", END)
 
 # --- Checkpointer and Graph Compilation ---
-# Define a persistent SQLite database file
-# It's good practice to place it in a dedicated directory or the project root.
-#SQLITE_DB_PATH = "langgraph_checkpoints.sqlite" # This file will be created/used
-
-# Initialize SqliteSaver with the file path
+#SQLITE_DB_PATH = "langgraph_checkpoints.sqlite"
 #global_memory_saver = SqliteSaver.from_conn_string(SQLITE_DB_PATH)
-
 global_memory_saver = MemorySaver()
 
-# Global graph instance compiled once
 global_graph = builder.compile(
     checkpointer=global_memory_saver,
+    # Keep interrupt_after for human_input_interrupt.
+    # This means human_input_node runs, then graph interrupts.
     interrupt_after=["human_input_interrupt"]
 )
 
-
-
-# --- Gradio UI Logic (Mostly the same, but now truly persistent) ---
-
+# --- Gradio UI Logic ---
 current_thread_id = gr.State("")
 
 def start_graph(thread_id_state):
-    # Generate a new unique thread ID for each new conversation
     new_thread_id = str(uuid.uuid4())
     print(f"\n--- Starting New Graph Execution with thread_id: {new_thread_id} ---")
     
     # You might want to explicitly drop previous thread state if it exists for this ID
-    # if global_memory_saver.get_state({"configurable": {"thread_id": new_thread_id}}):
+    # (Uncomment if you want to explicitly clear old data for a potentially re-used UUID,
+    # though with uuid4 it's highly unlikely)
+    # try:
     #     global_memory_saver.drop(config={"configurable": {"thread_id": new_thread_id}})
+    # except Exception as e:
+    #     print(f"Could not drop previous state for {new_thread_id}: {e}")
 
     try:
+        # Pass an empty input for the first run.
+        # The graph will run greeting_node, then human_input_node, then interrupt.
         for s in global_graph.stream({"greeting_message": ""}, {"configurable": {"thread_id": new_thread_id}}):
             if "__end__" in s:
                 break
@@ -87,8 +94,9 @@ def start_graph(thread_id_state):
         current_state_snapshot = global_graph.get_state({"configurable": {"thread_id": new_thread_id}})
         
         output_message = current_state_snapshot.values.get("greeting_message", "No greeting yet.")
-        output_message += "\n" + "Please provide your input to continue."
+        output_message += "\n\n" + "Please type your response in the 'Your Input' box and click 'Resume Graph'."
 
+        # Enable human input textbox and resume button, disable start button
         return (output_message, gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=False), new_thread_id)
 
     except Exception as e:
@@ -97,11 +105,12 @@ def start_graph(thread_id_state):
 
 def resume_graph(human_input_from_ui: str, thread_id_state):
     print(f"\n--- Resuming Graph Execution for thread_id: {thread_id_state} ---")
-    print(f"Received human input from UI (will be ignored if input taken in node): {human_input_from_ui}")
+    print(f"Human input received from UI: {human_input_from_ui}")
 
     try:
-        # Pass None as input as the human_input_node already handled taking input
-        for s in global_graph.stream(None, {"configurable": {"thread_id": thread_id_state}}):
+        # Pass the human_input_from_ui directly to the graph stream.
+        # This input will be merged into the graph's state when it resumes.
+        for s in global_graph.stream({"human_input": human_input_from_ui}, {"configurable": {"thread_id": thread_id_state}}):
             if "__end__" in s:
                 break
             else:
@@ -111,6 +120,7 @@ def resume_graph(human_input_from_ui: str, thread_id_state):
         final_state_values = final_state_snapshot.values
 
         final_message = final_state_values.get("final_response", "Graph finished without final response.")
+        # Disable input, resume button, enable start button for new conversation
         return (final_message, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), thread_id_state)
 
     except Exception as e:
@@ -119,13 +129,12 @@ def resume_graph(human_input_from_ui: str, thread_id_state):
 
 # Gradio Interface setup
 with gr.Blocks() as demo:
-    gr.Markdown("# LangGraph Human Approval Demo (Persistent)")
-    #gr.Markdown(f"Graph state will be saved persistently in `{SQLITE_DB_PATH}`. Click 'Start Conversation' to begin.")
-    gr.Markdown(f"Graph state will be saved persistently IN-MEMORY. Click 'Start Conversation' to begin.")
-
+    gr.Markdown("# LangGraph Human Approval Demo (Persistent on Hugging Face)")
+    gr.Markdown(f"Graph state will be saved persistently in MEMORY.")
 
     output_textbox = gr.Textbox(label="AI Assistant Output", lines=5, interactive=False)
-    human_input_textbox = gr.Textbox(label="Your Input (Please enter in console as well)", placeholder="Type your response here...", interactive=True)
+    # The human input now comes ONLY from this textbox
+    human_input_textbox = gr.Textbox(label="Your Input", placeholder="Type your response here...", interactive=False)
     
     thread_id_state = gr.State("")