UPDATE APP.PY WITH SESSION ID

app.py

@@ -1,63 +1,35 @@
-import os
+# app.py
 import gradio as gr
+from my_memory_logic import run_with_session_memory
 
-# Suppose 'run_with_chain' is your pipeline function from pipeline.py
-from pipeline import run_with_chain
-
-# Suppose 'memory' and 'restatement_chain' come from my_memory_logic.py
-from my_memory_logic import memory, restatement_chain
-
-def chat_history_fn(user_input, history):
+def chat_interface_fn(message, history, session_id):
     """
-    Rely on LangChain memory to store the entire conversation across calls.
-    DO NOT re-add old messages from 'history' each time.
-    Also, handle potential None or invalid strings for user_input/answer 
-    to avoid Pydantic validation errors.
+    A single-turn chat function for Gradio's ChatInterface.
+    We rely on session_id to store the conversation in our my_memory_logic store.
     """
-    # -- 0) Sanitize user_input to ensure it's a valid string
-    if not user_input or not isinstance(user_input, str):
-        user_input = "" if user_input is None else str(user_input)
-
-    # -- 1) Restate the new user question using existing LangChain memory
-    reformulated_q = restatement_chain.run({
-        "chat_history": memory.chat_memory.messages,
-        "input": user_input
-    })
-
-    # -- 2) Pass the reformulated question into your pipeline
-    answer = run_with_chain(reformulated_q)
-    # also sanitize if needed
-    if answer is None or not isinstance(answer, str):
-        answer = "" if answer is None else str(answer)
-
-    # -- 3) Add this new user->assistant turn to memory
-    memory.chat_memory.add_user_message(user_input)
-    memory.chat_memory.add_ai_message(answer)
-
-    # -- 4) Update Gradio’s 'history' so the UI shows the new turn
-    history.append((user_input, answer))
-
-    # -- 5) Convert the entire 'history' to message dictionaries:
-    #       [{"role":"user","content":...},{"role":"assistant","content":...},...]
+    # 1) We call run_with_session_memory with user message and session_id
+    answer = run_with_session_memory(message, session_id)
+
+    # 2) Append the turn to the 'history' so Gradio UI displays it
+    history.append((message, answer))
+    
+    # 3) Convert into message dicts if ChatInterface is using openai-style messages
+    #    or we can just return a single string. Let's do openai-style message dicts:
     message_dicts = []
-    for usr_msg, ai_msg in history:
-        if not isinstance(usr_msg, str):
-            usr_msg = str(usr_msg) if usr_msg else ""
-        if not isinstance(ai_msg, str):
-            ai_msg = str(ai_msg) if ai_msg else ""
-
-        message_dicts.append({"role": "user", "content": usr_msg})
+    for user_msg, ai_msg in history:
+        message_dicts.append({"role": "user", "content": user_msg})
         message_dicts.append({"role": "assistant", "content": ai_msg})
-
-    # -- 6) Return the message dictionary list
-    return message_dicts
-
-# Build your ChatInterface with the function
-demo = gr.ChatInterface(
-    fn=chat_history_fn,
-    title="DailyWellnessAI with Memory",
-    description="A chat bot that remembers context using memory + question restatement."
-)
-
-if __name__ == "__main__":
-    demo.launch()
+    return message_dicts, history
+
+# We'll define a small Gradio Blocks or ChatInterface
+with gr.Blocks() as demo:
+    session_id_box = gr.Textbox(label="Session ID", value="abc123", interactive=True)
+    chat_interface = gr.ChatInterface(
+        fn=lambda message, history: chat_interface_fn(
+            message, history, session_id_box.value
+        ),
+        title="DailyWellnessAI (Session-based Memory)",
+        description="Ask your questions. The session_id determines your stored memory."
+    )
+
+demo.launch()