Update app.py

app.py

@@ -1,16 +1,16 @@
 import gradio as gr
 from langgraph.graph import StateGraph, END
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.checkpoint.sqlite import SqliteSaver # Import SqliteSaver
 import operator
 from typing import TypedDict, Annotated, Optional
 import uuid
 import os
+import sqlite3 # Import sqlite3 for direct connection if needed for older versions
 
 # --- 1. Define your Graph State ---
 class GraphState(TypedDict):
     greeting_message: str
-    human_input: Annotated[Optional[str], operator.add]
+    human_input: Annotated[Optional[str], operator.add] # operator.add for merging
     final_response: str
     current_node: str
 
@@ -24,11 +24,11 @@ def greeting_node(state: GraphState) -> GraphState:
 def human_input_node(state: GraphState) -> GraphState:
     """
     Node 2: This node processes the human input that was added to the state
-    before its execution (during the resume phase via put_state).
+    via the `put_state` method during the resume phase. It does NOT contain `input()`.
     """
     human_response = state.get("human_input", "No human input found in state when human_input_node ran.")
     print(f"\n✋ Human Input Node Executed (Processing input: '{human_response}'):")
-    # You could add validation or further processing of state['human_input'] here if needed.
+    # This node could perform validation or further processing using human_response.
     return {"current_node": "human_input_processed"}
 
 def human_response_display_node(state: GraphState) -> GraphState:
@@ -41,27 +41,44 @@ def human_response_display_node(state: GraphState) -> GraphState:
 # --- 3. Build the Graph ---
 builder = StateGraph(GraphState)
 builder.add_node("greeting", greeting_node)
-builder.add_node("human_input_interrupt", human_input_node) # Node name remains for clarity
+builder.add_node("human_input_interrupt", human_input_node)
 builder.add_node("human_response_display", human_response_display_node)
 
 builder.set_entry_point("greeting")
-builder.add_edge("greeting", "human_input_interrupt") # Still connects normally
+builder.add_edge("greeting", "human_input_interrupt")
 builder.add_edge("human_response_display", END)
 
-# --- Checkpointer and Graph Compilation ---
-# Using MemorySaver as requested
-#global_memory_saver = MemorySaver()
-
-SQLITE_DB_PATH = "langgraph_checkpoints.sqlite" # This will be a file in your Space
-global_memory_saver = SqliteSaver.from_conn_string(SQLITE_DB_PATH)
+# Define the path for the SQLite database file
+SQLITE_DB_PATH = "langgraph_checkpoints.sqlite"
 
+# --- Checkpointer and Graph Compilation ---
+# Initialize global_graph and global_memory_saver
+# The recommended way is to establish the connection once and keep the saver instance.
+# For SqliteSaver, if from_conn_string is a context manager, you need to use `with`.
+# A simpler approach that generally works better for global scope in web apps:
+# Establish a direct SQLite connection and pass it to SqliteSaver.
+try:
+    # Use check_same_thread=False for Gradio/web apps that might access the DB from different threads
+    # or if the connection is managed globally.
+    conn = sqlite3.connect(SQLITE_DB_PATH, check_same_thread=False)
+    global_memory_saver = SqliteSaver(conn=conn)
+    # Ensure tables are created if they don't exist.
+    # SqliteSaver usually does this on first use or you can explicitly call a setup if available.
+    # In recent versions, just passing the connection is often enough for setup.
+except Exception as e:
+    print(f"Error initializing SqliteSaver connection: {e}")
+    # Fallback or error handling if DB connection fails
+    global_memory_saver = None # Or exit the application
+
+if global_memory_saver:
+    global_graph = builder.compile(
+        checkpointer=global_memory_saver,
+        interrupt_before=["human_input_interrupt"]
+    )
+else:
+    print("SqliteSaver not initialized, graph compilation skipped.")
+    global_graph = None # Handle the case where checkpointer couldn't be initialized
 
-global_graph = builder.compile(
-    checkpointer=global_memory_saver,
-    # CRITICAL CHANGE: Interrupt BEFORE human_input_interrupt
-    # This means the graph will pause *before* executing the human_input_node
-    interrupt_before=["human_input_interrupt"]
-)
 
 # --- Gradio UI Logic ---
 current_thread_id = gr.State("")
@@ -70,9 +87,10 @@ def start_graph(thread_id_state):
     new_thread_id = str(uuid.uuid4())
     print(f"\n--- Starting New Graph Execution with thread_id: {new_thread_id} ---")
     
+    if not global_graph:
+        return (f"Error: Graph not initialized. Check server logs.", gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), thread_id_state)
+
     try:
-        # CRITICAL FIX: Pass an empty dictionary {} as input for the first stream call.
-        # This tells LangGraph to start from the entry point with an initial empty state.
         for s in global_graph.stream({}, {"configurable": {"thread_id": new_thread_id}}):
             if "__end__" in s:
                 break
@@ -97,15 +115,18 @@ 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"Human input received from UI: {human_input_from_ui}")
 
+    if not global_graph or not global_memory_saver:
+        return (f"Error: Graph or checkpointer not initialized. Check server logs.", gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), thread_id_state)
+
     try:
         current_state_snapshot = global_graph.get_state({"configurable": {"thread_id": thread_id_state}})
         current_state_values = current_state_snapshot.values
         
         current_state_values["human_input"] = human_input_from_ui
 
+        # Use put_state() from the SqliteSaver instance
         global_memory_saver.put_state(current_state_values, {"configurable": {"thread_id": thread_id_state}})
 
-        # Resume the graph with None as input after manually updating the state.
         for s in global_graph.stream(None, {"configurable": {"thread_id": thread_id_state}}):
             if "__end__" in s:
                 break
@@ -124,8 +145,9 @@ def resume_graph(human_input_from_ui: str, thread_id_state):
 
 # Gradio Interface setup
 with gr.Blocks() as demo:
-    gr.Markdown("# LangGraph Human-in-the-Loop Demo (MemorySaver)")
-    gr.Markdown("Graph state will be saved persistently in **memory** for the current session. Click 'Start Conversation' to begin. Input is taken via Gradio UI.")
+    gr.Markdown("# LangGraph Human-in-the-Loop Demo (SqliteSaver)")
+    gr.Markdown(f"Graph state will be saved persistently in `{SQLITE_DB_PATH}`. Click 'Start Conversation' to begin. Input is taken via Gradio UI.")
+    
 
     output_textbox = gr.Textbox(label="AI Assistant Output", lines=5, interactive=False)
     human_input_textbox = gr.Textbox(label="Your Input", placeholder="Type your response here...", interactive=False)