for session debugging

app.py

@@ -1,55 +1,13 @@
-import subprocess
 import sys
 import os
-
-ROOT_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "./")
-sys.path.append(ROOT_FILE)
-from components.induce_personality import construct_big_five_words
-
-
-# need to import: gradio
-def install(package, upgrade=False):
-    if upgrade:
-        subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                package,
-            ],
-            check=True,
-        )
-    else:
-        subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                package,
-            ],
-            check=True,
-        )
-
-
-# install("ipdb")
-# install("gradio")
-# install("sentence-transformers")
-# install("git+https://github.com/terrierteam/pyterrier_t5.git")
-# install("protobuf")
-# install("transformers", upgrade=True)
-import random
 import json
 import gradio as gr
-import random
-import time
 import markdown
-import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
 from together import Together
 
+ROOT_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../")
+sys.path.append(ROOT_FILE)
+from components.induce_personality import construct_big_five_words
 from components.chat_conversation import (
     # format_message_history,
     format_user_message,
@@ -62,62 +20,72 @@ from components.chat_conversation import (
     conversation_window,
     generate_response_local_api,
     generate_response_together_api,
+    generate_response_debugging,
 )
 from components.constant import (
-    # ACCESS,
-    # QUERY_REWRITING,
-    # RAG,
-    # PERSONALITY,
-    # PERSONALITY_LIST,
-    # REWRITE_PASSAGES,
-    # NUM_PASSAGES,
-    # DEVICE,
-    RESPONSE_GENERATOR,
     CONV_WINDOW,
     API_URL,
-    # TEMPLATE_PAYLOAD,
 )
 from components.induce_personality import (
     build_personality_prompt,
 )
 
-# LOG_FILE = "log_file_bingzhi_information_seeking.txt"
-LOG_DIR = os.path.join(ROOT_FILE, "log/seperate_preference_elicitation/others/")
+LOG_DIR = os.path.join(ROOT_FILE, "log/api/")
 if os.path.exists(LOG_DIR) is False:
     os.makedirs(LOG_DIR)
+
+# Load Static Files
 STATIC_FILE = os.path.join(ROOT_FILE, "_static")
+LOG_DIR = os.path.join(ROOT_FILE, "log/test_session/")
+INSTRUCTION_PAGE_FILE = os.path.join(STATIC_FILE, "html/instruction_page.html")
+USER_NARRATIVE_FILE = os.path.join(STATIC_FILE, "html/user_narrative.html")
+PREFERENCE_ELICITATION_TASK_FILE = os.path.join(STATIC_FILE, "html/system_instruction_preference_elicitation.html")
+EVALUATION_INSTRUCTION_FILE = os.path.join(STATIC_FILE, "html/evaluation_instruction.html")
+GENERAL_INSTRUCTION_FILE = os.path.join(STATIC_FILE, "html/general_instruction.html")
+FINAL_EVALUATION_FILE = os.path.join(STATIC_FILE, "html/final_evaluation.html")
+SYSTEM_INSTRUCTION_FILE = os.path.join(STATIC_FILE, "txt/system_instruction_with_user_persona.txt")
+SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION_FILE = os.path.join(
+    STATIC_FILE, "txt/system_instruction_preference_elicitation.txt"
+)
+SUMMARIZATION_PROMPT_FILE = os.path.join(STATIC_FILE, "txt/system_summarization_user_preference_elicitation.txt")
+
+
+# Load the required static content from files
+def load_static_content(file_path):
+    with open(file_path, "r") as f:
+        return f.read()
+
+
+def ensure_directory_exists(directory_path):
+    """Ensures the given directory exists; creates it if it does not."""
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+
 
-with open(os.path.join(STATIC_FILE, "html/instruction_page.html"), "r") as f:
-    INSTRUCTION_PAGE = f.read()
-with open(os.path.join(STATIC_FILE, "html/evaluation_instruction.html"), "r") as f:
-    EVALUATION_INSTRUCTION = f.read()
-with open(os.path.join(STATIC_FILE, "html/general_instruction.html"), "r") as f:
-    GENERAL_INSTRUCTION = f.read()
-with open(os.path.join(STATIC_FILE, "html/user_narrative.html"), "r") as f:
-    USER_NARRATIVE = f.read()
-with open(os.path.join(STATIC_FILE, "html/system_instruction_preference_elicitation.html"), "r") as f:
-    PREFERENCE_ELICITATION_TASK = f.read()
-with open(os.path.join(STATIC_FILE, "html/final_evaluation.html"), "r") as f:
-    FINAL_EVALUATION = f.read()
-with open(os.path.join(STATIC_FILE, "txt/system_instruction_with_user_persona.txt"), "r") as f:
-    SYSTEM_INSTRUCTION = f.read()
-with open(os.path.join(STATIC_FILE, "txt/system_instruction_preference_elicitation.txt"), "r") as f:
-    SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION = f.read()
-with open(os.path.join(STATIC_FILE, "txt/system_summarization_user_preference_elicitation.txt"), "r") as f:
-    SUMMARIZATION_PROMPT = f.read()
+INSTRUCTION_PAGE = load_static_content(INSTRUCTION_PAGE_FILE)
+EVALUATION_INSTRUCTION = load_static_content(EVALUATION_INSTRUCTION_FILE)
+GENERAL_INSTRUCTION = load_static_content(GENERAL_INSTRUCTION_FILE)
+USER_NARRATIVE = load_static_content(USER_NARRATIVE_FILE)
+PREFERENCE_ELICITATION_TASK = load_static_content(PREFERENCE_ELICITATION_TASK_FILE)
+FINAL_EVALUATION = load_static_content(FINAL_EVALUATION_FILE)
+SYSTEM_INSTRUCTION = load_static_content(SYSTEM_INSTRUCTION_FILE)
+SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION = load_static_content(SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION_FILE)
+SUMMARIZATION_PROMPT = load_static_content(SUMMARIZATION_PROMPT_FILE)
+
+# Other constants
 FIRST_MESSAGE = "Hey"
 INFORMATION_SEEKING = True
 USER_PREFERENCE_SUMMARY = True
 DEBUG = False
-API_TYPE = "together"
-assert API_TYPE in ["together", "local"], "The API should be eiother 'together' or 'local'"
+API_TYPE = "debug"
+assert API_TYPE in ["together", "local", "debug"], "The API should be either 'together' or 'local'"
 if API_TYPE == "together":
-    TOGETHER_CLIENT = Together(api_key=os.environ.get("TOGETHER_API_KEY"))
-# if DEBUG:
-#     CONV_WINDOW = 3
+    TOGETHER_CLIENT = Together(api_key=os.getenv("TOGETHER_API_KEY"))
+
+SESSION_DEBUG = True
 
 
-def get_context(synthetic_data_path):
+def get_context_list(synthetic_data_path):
     # Load data from the synthetic data file
     with open(synthetic_data_path, "r") as f:
         data = [json.loads(line) for line in f]
@@ -165,6 +133,10 @@ def get_user_narrative_html(user_narrative):
     return USER_NARRATIVE.replace("{user_narrative}", user_narrative).replace("\n", "<br>")
 
 
+def get_user_narrative_from_raw(raw_narrative):
+    return get_user_narrative_html(markdown.markdown(raw_narrative.replace("\n", "<br>")))
+
+
 def get_task_instruction_for_user(context):
     ticker_name = context["short_name"]
     user_narrative = context["user_narrative"]
@@ -210,16 +182,22 @@ def display_system_instruction_with_html(
     return html_system_instruction
 
 
-def log_action(tab_name, action, details):
+def log_action(user_id, tab_name, action, details):
     """
     Log actions for each tab (stock).
     """
-    log_file = os.path.join(LOG_DIR, f"{tab_name}.txt")
+    log_file_dir = os.path.join(LOG_DIR, f"{user_id}")
+    if os.path.exists(log_file_dir) is False:
+        os.makedirs(log_file_dir)
+    log_file = os.path.join(log_file_dir, f"{tab_name}.txt")
+    print(log_file)
     with open(log_file, "a") as f:
         f.write(f"Action: {action} | Details: {details}\n")
 
 
-def add_user_profile_to_system_instruction(system_instruction, user_preference_elicitation_data, summary, terminator):
+def add_user_profile_to_system_instruction(
+    user_id, system_instruction, user_preference_elicitation_data, summary, terminator
+):
     if summary:
         if user_preference_elicitation_data["summary_history"] == "":
             # Format prompt
@@ -229,10 +207,12 @@ def add_user_profile_to_system_instruction(system_instruction, user_preference_e
             summarization_instruction = [{"role": "system", "content": summarization_prompt}]
             if API_TYPE == "local":
                 summ, _ = generate_response_local_api(summarization_instruction, terminator, 512, API_URL)
-            else:
+            elif API_TYPE == "together":
                 summ, _ = generate_response_together_api(summarization_instruction, 512, TOGETHER_CLIENT)
+            else:
+                summ, _ = generate_response_debugging(summarization_instruction)
             user_preference_elicitation_data["summary_history"] = summ
-            log_action("Prompt", "Preference Elicitation Summarization", summ)
+            log_action(user_id, "Prompt", "Preference Elicitation Summarization", summ)
             print(f"Preference Summary:{summ}")
         system_instruction += f"\nPrevious Conversations with the Customer about the User Profile: {user_preference_elicitation_data['summary_history']}\n"
     else:
@@ -240,41 +220,17 @@ def add_user_profile_to_system_instruction(system_instruction, user_preference_e
     return system_instruction
 
 
-def create_demo(
-    terminator,
-    system_description_without_context,
-    stock_context_list,
-    raw_context_list,
-):
-    # Store the history here and use this as an input to each tab.
-    tab_data = {}
-    user_preference_elicitation_data = {"history": "", "summary_history": ""}
-
-    if DEBUG:
-        user_preference_elicitation_data[
-            "summary_history"
-        ] = """Previous Conversations with the Customer about the User Profile: Based on our previous conversation, here's a summary of your investment preferences:
-
-        1. **Preferred Industries:** You're interested in investing in the healthcare sector, without a specific preference for sub-industries such as pharmaceuticals, medical devices, biotechnology, or healthcare services.
-        2. **Value vs. Growth Stocks:** You prefer growth stocks, which have the potential for high returns but may be riskier.
-        3. **Dividend vs. Non-Dividend Stocks:** You're open to both dividend and non-dividend growth stocks, focusing on reinvesting profits for future growth.
-        4. **Cyclical vs. Non-Cyclical Stocks:** You're interested in cyclical stocks, which are sensitive to economic fluctuations and tend to perform well during economic expansions."""
-
-    def tab_creation_exploration_stage(order):
-        comp, context, general_instruction, round_instruction = get_context(order)
-        system_instruction = system_description_without_context + "\n" + context
-        tab_data[comp] = {"history": [], "selection": "", "reason": ""}
+def create_demo():
+    global personality_prompts, context_info_list, terminator
+
+    def tab_creation_exploration_stage(order, comp, context):
         english_order = ["1", "2", "3", "4", "5"]
-        # with gr.Tab(f"{english_order[order]}: {comp}") as tab:
         with gr.Tab(f"{english_order[order]}-1:Discuss"):
-            gr.HTML(value=general_instruction, label="General Instruction")
+            general_instruction = gr.HTML(label="General Instruction")
             with gr.Row():
                 with gr.Column():
                     with gr.Row():
-                        gr.HTML(
-                            value=round_instruction,
-                            label="Round Instruction",
-                        )
+                        round_instruction = gr.HTML(label="Round Instruction")
                 with gr.Column():
                     with gr.Row():
                         chatbot = gr.Chatbot(height=600)
@@ -287,12 +243,6 @@ def create_demo(
                         continue_button = gr.Button(value="Show More of the Advisor’s Answer", interactive=False)
             with gr.Row():
                 clear = gr.ClearButton([msg, chatbot])
-            if DEBUG:
-                with gr.Row():
-                    display_prompt = gr.HTML(
-                        value=display_system_instruction_with_html(system_instruction),
-                        label="System Instruction",
-                    )
         with gr.Tab(f"{english_order[order]}-2:Eval"):
             with gr.Row():
                 gr.HTML(value=EVALUATION_INSTRUCTION)
@@ -344,7 +294,7 @@ def create_demo(
             evaluation_send_button = gr.Button(value="Send: Evaluation")
         return {
             "comp": comp,
-            "system_instruction": system_instruction,
+            "system_instruction_context": context,
             "start_conversation": start_conversation,
             "msg_button": msg_button,
             "continue_button": continue_button,
@@ -357,6 +307,8 @@ def create_demo(
             "knowledgeable": knowledgeable,
             "helpful": helpful,
             "evaluation_send_button": evaluation_send_button,
+            "general_instruction": general_instruction,
+            "round_instruction": round_instruction,
         }
 
     def tab_creation_preference_stage():
@@ -364,8 +316,7 @@ def create_demo(
             gr.HTML(value=PREFERENCE_ELICITATION_TASK, label="Preference Elicitation Task")
         with gr.Row():
             with gr.Column():
-                whole_user_narrative = get_user_narrative_html(user_narrative)
-                gr.HTML(value=whole_user_narrative, label="User Narrative")
+                user_narrative = gr.HTML(label="User Narrative")
             with gr.Column():
                 with gr.Row():
                     elicitation_chatbot = gr.Chatbot(height=600)
@@ -382,17 +333,18 @@ def create_demo(
             "continue_button": continue_button,
             "msg": msg,
             "elicitation_chatbot": elicitation_chatbot,
+            "user_narrative": user_narrative,
         }
 
-    def tab_final_evaluation(first_comp, second_comp, third_comp, fourth_comp, fifth_comp):
+    def tab_final_evaluation():
         with gr.Row():
             gr.HTML(value=FINAL_EVALUATION)
         with gr.Row():
-            ranking_first_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{first_comp}")
-            ranking_second_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{second_comp}")
-            ranking_third_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{third_comp}")
-            ranking_fourth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{fourth_comp}")
-            ranking_fifth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=f"{fifth_comp}")
+            ranking_first_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5])
+            ranking_second_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5])
+            ranking_third_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5])
+            ranking_fourth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5])
+            ranking_fifth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5])
         with gr.Row():
             textbox = gr.HTML(
                 """<div style="background-color: #f8d7da; color: #721c24; padding: 15px; border: 1px solid #f5c6cb; border-radius: 5px; margin-bottom: 20px;">
@@ -403,19 +355,21 @@ def create_demo(
             )
             submit_ranking = gr.Button(value="Submit Ranking")
         return {
-            "first": {"comp": first_comp, "ranking_first_comp": ranking_first_comp},
-            "second": {"comp": second_comp, "ranking_second_comp": ranking_second_comp},
-            "third": {"comp": third_comp, "ranking_third_comp": ranking_third_comp},
-            "fourth": {"comp": fourth_comp, "ranking_fourth_comp": ranking_fourth_comp},
-            "fifth": {"comp": fifth_comp, "ranking_fifth_comp": ranking_fifth_comp},
+            "first": ranking_first_comp,
+            "second": ranking_second_comp,
+            "third": ranking_third_comp,
+            "fourth": ranking_fourth_comp,
+            "fifth": ranking_fifth_comp,
             "submit_ranking": submit_ranking,
             "text_box": textbox,
         }
 
-    def click_control_exploration_stage(tabs):
+    def click_control_exploration_stage(
+        tabs, user_id, tab_session, user_preference_elicitation_session, system_description_without_context
+    ):
         (
             comp,
-            system_instruction,
+            system_instruction_context,
             start_conversation,
             msg_button,
             continue_button,
@@ -430,7 +384,7 @@ def create_demo(
             evaluation_send_button,
         ) = (
             tabs["comp"],
-            tabs["system_instruction"],
+            tabs["system_instruction_context"],
             tabs["start_conversation"],
             tabs["msg_button"],
             tabs["continue_button"],
@@ -444,23 +398,79 @@ def create_demo(
             tabs["helpful"],
             tabs["evaluation_send_button"],
         )
+        system_instruction = ""
         start_conversation.click(
-            lambda history: respond_start_conversation(history, system_instruction, comp),
-            [chatbot],
-            [chatbot, start_conversation, msg_button, continue_button],
+            lambda user_id, tab_session, history, comp, user_preference_elicitation_session, system_description_without_context, system_instruction_context: respond_start_conversation(
+                user_id,
+                tab_session,
+                history,
+                system_instruction,
+                comp,
+                user_preference_elicitation_data=user_preference_elicitation_session,
+                system_description_without_context=system_description_without_context,
+                system_instruction_context=system_instruction_context,
+            ),
+            [
+                user_id,
+                tab_session,
+                chatbot,
+                comp,
+                user_preference_elicitation_session,
+                system_description_without_context,
+                system_instruction_context,
+            ],
+            [tab_session, chatbot, start_conversation, msg_button, continue_button],
         )
         msg_button.click(
-            lambda message, history: respond(message, tab_data[comp]["history"], system_instruction, comp),
-            [msg, chatbot],
-            [msg, chatbot],
+            lambda user_id, tab_session, message, history, comp, user_preference_elicitation_session, system_description_without_context, system_instruction_context: respond(
+                user_id,
+                tab_session,
+                message,
+                tab_session["history"],
+                system_instruction,
+                comp,
+                user_preference_elicitation_data=user_preference_elicitation_session,
+                system_description_without_context=system_description_without_context,
+                system_instruction_context=system_instruction_context,
+            ),
+            [
+                user_id,
+                tab_session,
+                msg,
+                chatbot,
+                comp,
+                user_preference_elicitation_session,
+                system_description_without_context,
+                system_instruction_context,
+            ],
+            [tab_session, msg, chatbot],
         )
         continue_button.click(
-            lambda history: respond_continue(tab_data[comp]["history"], system_instruction, comp),
-            [chatbot],
-            [chatbot],
+            lambda user_id, tab_session, history, comp, user_preference_elicitation_session, system_description_without_context, system_instruction_context: respond_continue(
+                user_id,
+                tab_session,
+                tab_session["history"],
+                system_instruction,
+                comp,
+                user_preference_elicitation_data=user_preference_elicitation_session,
+                system_description_without_context=system_description_without_context,
+                system_instruction_context=system_instruction_context,
+            ),
+            [
+                user_id,
+                tab_session,
+                chatbot,
+                comp,
+                user_preference_elicitation_session,
+                system_description_without_context,
+                system_instruction_context,
+            ],
+            [tab_session, chatbot],
         )
         evaluation_send_button.click(
-            lambda dropdown, reason, trust, satisfaction, knowledgeable, helpful: respond_evaluation(
+            lambda user_id, comp, tab_session, dropdown, reason, trust, satisfaction, knowledgeable, helpful: respond_evaluation(
+                user_id,
+                tab_session,
                 {
                     "selection": dropdown,
                     "reason": reason,
@@ -471,11 +481,11 @@ def create_demo(
                 },
                 comp,
             ),
-            [dropdown, reason, trust, satisfaction, knowledgeable, helpful],
-            [dropdown, reason, trust, satisfaction, knowledgeable, helpful],
+            [user_id, comp, tab_session, dropdown, reason, trust, satisfaction, knowledgeable, helpful],
+            [tab_session, dropdown, reason, trust, satisfaction, knowledgeable, helpful],
         )
 
-    def click_control_preference_stage(tabs):
+    def click_control_preference_stage(tabs, user_id, user_preference_elicitation_session):
         (
             start_conversation,
             msg_button,
@@ -489,43 +499,55 @@ def create_demo(
             tabs["elicitation_chatbot"],
             tabs["msg"],
         )
+        # nonlocal user_id
         start_conversation.click(
-            lambda history: respond_start_conversation(
-                history, SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION, user_elicitation=True
+            lambda user_id, user_preference_elicitation_data, history: respond_start_conversation(
+                user_id,
+                user_preference_elicitation_data,
+                history,
+                SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION,
+                user_elicitation=True,
             ),
-            [elicitation_chatbot],
-            [elicitation_chatbot, start_conversation, msg_button, continue_button],
+            [user_id, user_preference_elicitation_session, elicitation_chatbot],
+            [user_preference_elicitation_session, elicitation_chatbot, start_conversation, msg_button, continue_button],
         )
         msg_button.click(
-            lambda message, history: respond(
+            lambda user_id, tab_data, message, history: respond(
+                user_id,
+                tab_data,
                 message,
-                user_preference_elicitation_data["history"],
+                tab_data["history"],
                 SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION,
                 user_elicitation=True,
             ),
-            [msg, elicitation_chatbot],
-            [msg, elicitation_chatbot],
+            [user_id, user_preference_elicitation_session, msg, elicitation_chatbot],
+            [user_preference_elicitation_session, msg, elicitation_chatbot],
         )
         continue_button.click(
-            lambda history: respond_continue(
-                user_preference_elicitation_data["history"],
+            lambda user_id, tab_data, history: respond_continue(
+                user_id,
+                tab_data,
+                tab_data["history"],
                 SYSTEM_INSTRUECTION_PREFERENCE_ELICITATION,
                 user_elicitation=True,
             ),
-            [elicitation_chatbot],
-            [elicitation_chatbot],
+            [user_id, user_preference_elicitation_session, elicitation_chatbot],
+            [user_preference_elicitation_session, elicitation_chatbot],
         )
 
-    def click_control_final_evaluation(tabs):
-        first_comp, ranking_first_comp = tabs["first"]["comp"], tabs["first"]["ranking_first_comp"]
-        second_comp, ranking_second_comp = tabs["second"]["comp"], tabs["second"]["ranking_second_comp"]
-        third_comp, ranking_third_comp = tabs["third"]["comp"], tabs["third"]["ranking_third_comp"]
-        fourth_comp, ranking_fourth_comp = tabs["fourth"]["comp"], tabs["fourth"]["ranking_fourth_comp"]
-        fifth_comp, ranking_fifth_comp = tabs["fifth"]["comp"], tabs["fifth"]["ranking_fifth_comp"]
+    def click_control_final_evaluation(tabs, user_id, first_comp, second_comp, third_comp, fourth_comp, fifth_comp):
+        ranking_first_comp, ranking_second_comp, ranking_third_comp, ranking_fourth_comp, ranking_fifth_comp = (
+            tabs["first"],
+            tabs["second"],
+            tabs["third"],
+            tabs["fourth"],
+            tabs["fifth"],
+        )
         result_textbox = tabs["text_box"]
         submit_ranking = tabs["submit_ranking"]
         submit_ranking.click(
-            lambda ranking_first_comp, ranking_second_comp, ranking_third_comp, ranking_fourth_comp, ranking_fifth_comp: respond_final_ranking(
+            lambda user_id, ranking_first_comp, first_comp, ranking_second_comp, second_comp, ranking_third_comp, third_comp, ranking_fourth_comp, fourth_comp, ranking_fifth_comp, fifth_comp: respond_final_ranking(
+                user_id,
                 first_comp,
                 ranking_first_comp,
                 second_comp,
@@ -539,17 +561,34 @@ def create_demo(
             ),
             # Input components (names and rankings)
             [
+                user_id,
                 ranking_first_comp,
+                first_comp,
                 ranking_second_comp,
+                second_comp,
                 ranking_third_comp,
+                third_comp,
                 ranking_fourth_comp,
+                fourth_comp,
                 ranking_fifth_comp,
+                fifth_comp,
             ],
             # Output component(s) where you want the result to appear, e.g., result_textbox
             [result_textbox],
         )
 
-    def respond(message, history, system_instruction, tab_name=None, user_elicitation=False):
+    def respond(
+        user_id,
+        tab_data,
+        message,
+        history,
+        system_instruction,
+        tab_name=None,
+        user_elicitation=False,
+        user_preference_elicitation_data=None,
+        system_description_without_context=None,
+        system_instruction_context=None,
+    ):
         """
         Return:
         msg
@@ -562,22 +601,22 @@ def create_demo(
             tab_name is not None or user_elicitation is True
         ), "Tab name is required for the start of the conversation unless it is not preference elicitation."
         # Add user profile to system instruction
+        if system_description_without_context is not None and system_instruction_context is not None:
+            system_instruction = system_description_without_context + "\n" + system_instruction_context
         if not user_elicitation:
             system_instruction = add_user_profile_to_system_instruction(
+                user_id,
                 system_instruction,
                 user_preference_elicitation_data,
                 summary=USER_PREFERENCE_SUMMARY,
                 terminator=terminator,
             )
-            # print(f"Tab: {tab_name}\nSystem Instruction:{system_instruction}")
         # Formatting Input
         print(f"User Message: {message} in Tab: {tab_name}")
         # From string to list [{"role":"user", "content": message}, ...]
         history = gradio_to_huggingface_message(history)
         # We can implement context window here as we need all the system interaction. We can cut some of the early interactions if needed.
         history = conversation_window(history, CONV_WINDOW)
-        print(f"History Length: {len(history)}")
-        print(f"History: {history}")
         # Add system instruction to the history
         history = format_context(system_instruction, history)
         # Add user message to the history
@@ -585,32 +624,51 @@ def create_demo(
         # Call API instead of locally handle it
         if API_TYPE == "local":
             outputs_text, history = generate_response_local_api(history_with_user_utterance, terminator, 128, API_URL)
-        else:
+        elif API_TYPE == "together":
             outputs_text, history = generate_response_together_api(history_with_user_utterance, 128, TOGETHER_CLIENT)
+        else:
+            outputs_text, history = generate_response_debugging(history_with_user_utterance)
         # exclude system interaction and store the others in the history
         history = huggingface_to_gradio_message(history)
         if tab_name is not None:
             print(f"Tab: {tab_name}\nSystem Output: {outputs_text}")
 
             # Log the user message and response
-            log_action(tab_name, "User Message", message)
-            log_action(tab_name, "Response", outputs_text)
+            log_action(user_id, tab_name, "User Message", message)
+            log_action(user_id, tab_name, "Response", outputs_text)
             # Store the updated history for this tab
-            tab_data[tab_name]["history"] = history
+            tab_data["history"] = history
         if user_elicitation:
             print(f"User Elicitation\nSystem Output: {outputs_text}")
-            log_action("User_Elicitation", "User Message", message)
-            log_action("User_Elicitation", "Response", outputs_text)
-            user_preference_elicitation_data["history"] = history
-
-        return "", history
-
-    def respond_start_conversation(history, system_instruction, tab_name=None, user_elicitation=False):
+            log_action(user_id, "User_Elicitation", "User Message", message)
+            log_action(user_id, "User_Elicitation", "Response", outputs_text)
+            tab_data["history"] = history
+        if SESSION_DEBUG:
+            log_action(user_id, "Session", "History", history)
+
+        return tab_data, "", history
+
+    def respond_start_conversation(
+        user_id,
+        tab_data,
+        history,
+        system_instruction,
+        tab_name=None,
+        user_elicitation=False,
+        user_preference_elicitation_data=None,
+        system_description_without_context=None,
+        system_instruction_context=None,
+    ):
         assert (
             tab_name is not None or user_elicitation is True
         ), "Tab name is required for the start of the conversation unless it is not preference elicitation."
+        if system_description_without_context is not None and system_instruction_context is not None:
+            system_instruction = system_description_without_context + "\n" + system_instruction_context
         if not user_elicitation:
+            print(f"User Preference Elicitation Data: {user_preference_elicitation_data}")
+            print(f"Tab data: {tab_data}")
             system_instruction = add_user_profile_to_system_instruction(
+                user_id,
                 system_instruction,
                 user_preference_elicitation_data,
                 summary=USER_PREFERENCE_SUMMARY,
@@ -623,44 +681,59 @@ def create_demo(
         history_with_user_utterance = format_user_message(first_message, history)
         if API_TYPE == "local":
             outputs_text, history = generate_response_local_api(history_with_user_utterance, terminator, 128, API_URL)
-        else:
+        elif API_TYPE == "together":
             outputs_text, history = generate_response_together_api(history_with_user_utterance, 128, TOGETHER_CLIENT)
+        else:
+            outputs_text, history = generate_response_debugging(history_with_user_utterance)
         # Format
         history = huggingface_to_gradio_message(history)
         if tab_name is not None:
             print(f"Tab: {tab_name}\nHistory: {history}")
-
             # Log the user message and response
-            log_action(tab_name, "User Message", first_message)
-            log_action(tab_name, "Response", outputs_text)
+            log_action(user_id, tab_name, "User Message", first_message)
+            log_action(user_id, tab_name, "Response", outputs_text)
             # Store the updated history for this tab
-            tab_data[tab_name]["history"] = history
+            tab_data["history"] = history
         if user_elicitation:
             print(f"User Elicitation\nHistory: {history}")
-            log_action("User_Elicitation", "User Message", first_message)
-            log_action("User_Elicitation", "Response", outputs_text)
-            user_preference_elicitation_data["history"] = history
-
+            log_action(user_id, "User_Elicitation", "User Message", first_message)
+            log_action(user_id, "User_Elicitation", "Response", outputs_text)
+            tab_data["history"] = history
+        if SESSION_DEBUG:
+            log_action(user_id, "Session", "History", history)
         return (
+            tab_data,
             history,
             gr.Button(value="Start Conversation", interactive=False),
             gr.Button(value="Send This Message to Advisor", interactive=True),
             gr.Button(value="Show More of the Advisor’s Answer", interactive=True),
         )
 
-    def respond_continue(history, system_instruction, tab_name=None, user_elicitation=False):
+    def respond_continue(
+        user_id,
+        tab_data,
+        history,
+        system_instruction,
+        tab_name=None,
+        user_elicitation=False,
+        user_preference_elicitation_data=None,
+        system_description_without_context=None,
+        system_instruction_context=None,
+    ):
         assert (
             tab_name is not None or user_elicitation is True
         ), "Tab name is required for the start of the conversation."
         # Add user profile to system instruction
+        if system_description_without_context is not None and system_instruction_context is not None:
+            system_instruction = system_description_without_context + "\n" + system_instruction_context
         if not user_elicitation:
             system_instruction = add_user_profile_to_system_instruction(
+                user_id,
                 system_instruction,
                 user_preference_elicitation_data,
                 summary=USER_PREFERENCE_SUMMARY,
                 terminator=terminator,
             )
-            # print(f"Tab: {tab_name}\nSystem Instruction:{system_instruction}")
         message = "continue"
         history = gradio_to_huggingface_message(history)
         history = conversation_window(history, CONV_WINDOW)
@@ -668,31 +741,35 @@ def create_demo(
         history_with_user_utterance = format_user_message(message, history)
         if API_TYPE == "local":
             outputs_text, history = generate_response_local_api(history_with_user_utterance, terminator, 128, API_URL)
-        else:
+        elif API_TYPE == "together":
             outputs_text, history = generate_response_together_api(history_with_user_utterance, 128, TOGETHER_CLIENT)
+        else:
+            outputs_text, history = generate_response_debugging(history_with_user_utterance)
         history = huggingface_to_gradio_message(history)
         if tab_name is not None:
-            log_action(tab_name, "Show More of the Advisor’s Answer", "User continued the conversation")
-            log_action(tab_name, "Response", outputs_text)
+            log_action(user_id, tab_name, "Show More of the Advisor’s Answer", "User continued the conversation")
+            log_action(user_id, tab_name, "Response", outputs_text)
 
             # Update history for this tab
-            tab_data[tab_name]["history"] = history
+            tab_data["history"] = history
         if user_elicitation:
             print(f"User Elicitation\nSystem Output: {outputs_text}")
-            log_action("User_Elicitation", "Response", outputs_text)
-            user_preference_elicitation_data["history"] = history
+            log_action(user_id, "User_Elicitation", "Response", outputs_text)
+            tab_data["history"] = history
+        if SESSION_DEBUG:
+            log_action(user_id, "Session", "History", history)
+        return tab_data, history
 
-        return history
-
-    def respond_evaluation(evals, tab_name):
+    def respond_evaluation(user_id, tab_data, evals, tab_name):
 
         # dropdown, readon_button, multi-evaluator
-        log_action(tab_name, "Round Evaluation", "Following")
+        log_action(user_id, tab_name, "Round Evaluation", "Following")
         for key, value in evals.items():
-            log_action(tab_name, key, value)
+            log_action(user_id, tab_name, key, value)
         # Store the reason for this tab
-        tab_data[tab_name]["multi_evaluator"] = evals
+        tab_data["multi_evaluator"] = evals
         return (
+            tab_data,
             evals["selection"],
             evals["reason"],
             evals["trust"],
@@ -702,6 +779,7 @@ def create_demo(
         )
 
     def respond_final_ranking(
+        user_id,
         first_comp,
         ranking_first_comp,
         second_comp,
@@ -726,56 +804,264 @@ def create_demo(
                         <strong>Please make sure that you are not ranking the same stock multiple times.</strong>
                     </div>"""
         else:
-            log_action("Final_Ranking", first_comp, ranking_first_comp)
-            log_action("Final_Ranking", second_comp, ranking_second_comp)
-            log_action("Final_Ranking", third_comp, ranking_third_comp)
-            log_action("Final_Ranking", fourth_comp, ranking_fourth_comp)
-            log_action("Final_Ranking", fifth_comp, ranking_fifth_comp)
+            log_action(user_id, "Final_Ranking", first_comp, ranking_first_comp)
+            log_action(user_id, "Final_Ranking", second_comp, ranking_second_comp)
+            log_action(user_id, "Final_Ranking", third_comp, ranking_third_comp)
+            log_action(user_id, "Final_Ranking", fourth_comp, ranking_fourth_comp)
+            log_action(user_id, "Final_Ranking", fifth_comp, ranking_fifth_comp)
             return """<div style="background-color: #d4edda; color: #155724; padding: 15px; border: 1px solid #c3e6cb; border-radius: 5px; margin-bottom: 20px;">
                         <strong>Thank you for participating in the experiment. This concludes the session. You may now close the tab.</strong>
                     </div>"""
 
-    def get_context(index):
+    def get_context(index, raw_context_list, stock_context_list):
         comp = raw_context_list[index]["short_name"]
         context = stock_context_list[index]
         general_instruction, round_instruction = get_task_instruction_for_user(raw_context_list[index])
         return comp, context, general_instruction, round_instruction
 
-    with gr.Blocks(title="RAG Chatbot Q&A", theme="Soft") as demo:
-        first_comp, first_context, first_general_instruction, first_round_instruction = get_context(0)
-        second_comp, second_context, second_general_instruction, second_round_instruction = get_context(1)
-        third_comp, third_context, third_general_instruction, third_round_instruction = get_context(2)
-        fourth_comp, fourth_context, forth_general_instruction, forth_round_instruction = get_context(3)
-        fifth_comp, fifth_context, fifth_general_instruction, fifth_round_instruction = get_context(4)
-        user_narrative = markdown.markdown(raw_context_list[0]["user_narrative"].replace("\n", "<br>"))
-
-        # # initialize tab data
-        for comp in [first_comp, second_comp, third_comp, fourth_comp, fifth_comp]:
-            tab_data[comp] = {"history": [], "selection": "", "reason": ""}
+    def set_user_id(request: gr.Request):
+        user_id = request.username
+        narrative_id = user_id.split("_")[-2]
+        personality_id = user_id.split("_")[-1]
+        print(f"User ID: {user_id}, Narrative ID: {narrative_id}, Personality ID: {personality_id}")
+        return user_id, narrative_id, personality_id
+
+    def get_inst_without_context(personality_id):
+        return SYSTEM_INSTRUCTION + "\n" + personality_prompts[int(personality_id)]
+
+    def get_stock_related_context(narrative_id):
+        raw_context_list = build_raw_context_list(context_info_list[int(narrative_id)])
+        stock_context_list = build_context(context_info_list[int(narrative_id)])
+        return raw_context_list, stock_context_list
+
+    def set_initial_values(request: gr.Request):
+        # Set user specific information (Session State)
+        user_id, narrative_id, personality_id = set_user_id(request)
+        # System instruction without prompt
+        system_description_without_context = get_inst_without_context(personality_id)
+        # Stock related context
+        raw_context_list, stock_context_list = get_stock_related_context(narrative_id)
+        # User Narrative
+        user_narrative = get_user_narrative_from_raw(raw_context_list[0]["user_narrative"])
+        # Tab Context
+        first_comp, first_context, first_general_instruction, first_round_instruction = get_context(
+            0, raw_context_list, stock_context_list
+        )
+        second_comp, second_context, second_general_instruction, second_round_instruction = get_context(
+            1, raw_context_list, stock_context_list
+        )
+        third_comp, third_context, third_general_instruction, third_round_instruction = get_context(
+            2, raw_context_list, stock_context_list
+        )
+        fourth_comp, fourth_context, fourth_general_instruction, fourth_round_instruction = get_context(
+            3, raw_context_list, stock_context_list
+        )
+        fifth_comp, fifth_context, fifth_general_instruction, fifth_round_instruction = get_context(
+            4, raw_context_list, stock_context_list
+        )
+        # Final Evaluation
+        ranking_first_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=first_comp)
+        ranking_second_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=second_comp)
+        ranking_third_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=third_comp)
+        ranking_fourth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=fourth_comp)
+        ranking_fifth_comp = gr.Dropdown(choices=[1, 2, 3, 4, 5], label=fifth_comp)
+        return (
+            user_id,
+            narrative_id,
+            personality_id,
+            system_description_without_context,
+            raw_context_list,
+            stock_context_list,
+            user_narrative,
+            first_comp,
+            first_context,
+            first_general_instruction,
+            first_round_instruction,
+            second_comp,
+            second_context,
+            second_general_instruction,
+            second_round_instruction,
+            third_comp,
+            third_context,
+            third_general_instruction,
+            third_round_instruction,
+            fourth_comp,
+            fourth_context,
+            fourth_general_instruction,
+            fourth_round_instruction,
+            fifth_comp,
+            fifth_context,
+            fifth_general_instruction,
+            fifth_round_instruction,
+            ranking_first_comp,
+            ranking_second_comp,
+            ranking_third_comp,
+            ranking_fourth_comp,
+            ranking_fifth_comp,
+        )
 
+    with gr.Blocks(title="RAG Chatbot Q&A", theme="Soft") as demo:
+        # Set user specific information (Session State)
+        user_id = gr.State()
+        narrative_id = gr.State()
+        personality_id = gr.State()
+        system_description_without_context = gr.State()
+        # Context data
+        raw_context_list = gr.State()
+        stock_context_list = gr.State()
+        first_comp = gr.State()
+        first_context = gr.State()
+        second_comp = gr.State()
+        second_context = gr.State()
+        third_comp = gr.State()
+        third_context = gr.State()
+        fourth_comp = gr.State()
+        fourth_context = gr.State()
+        fifth_comp = gr.State()
+        fifth_context = gr.State()
+        # Tab data
+        if DEBUG:
+            user_preference_elicitation_session = gr.State(
+                value={
+                    "history": "",
+                    "summary_history": """Previous Conversations with the Customer about the User Profile: Based on our previous conversation, here's a summary of your investment preferences:
+
+    #     1. **Preferred Industries:** You're interested in investing in the healthcare sector, without a specific preference for sub-industries such as pharmaceuticals, medical devices, biotechnology, or healthcare services.
+    #     2. **Value vs. Growth Stocks:** You prefer growth stocks, which have the potential for high returns but may be riskier.
+    #     3. **Dividend vs. Non-Dividend Stocks:** You're open to both dividend and non-dividend growth stocks, focusing on reinvesting profits for future growth.
+    #     4. **Cyclical vs. Non-Cyclical Stocks:** You're interested in cyclical stocks, which are sensitive to economic fluctuations and tend to perform well during economic expansions.""",
+                }
+            )
+        else:
+            user_preference_elicitation_session = gr.State(value={"history": "", "summary_history": ""})
+        first_comp_session = gr.State(value={"history": [], "selection": "", "reason": ""})
+        second_comp_session = gr.State(value={"history": [], "selection": "", "reason": ""})
+        third_comp_session = gr.State(value={"history": [], "selection": "", "reason": ""})
+        fourth_comp_session = gr.State(value={"history": [], "selection": "", "reason": ""})
+        fifth_comp_session = gr.State(value={"history": [], "selection": "", "reason": ""})
         # EXperiment Instruction
         with gr.Tab("Experiment Instruction") as instruction_tab:
             gr.HTML(value=INSTRUCTION_PAGE, label="Experiment Instruction")
         # User Preference Elicitation Tab
         with gr.Tab("Preference Elicitation Stage") as preference_elicitation_tab:
             user_preference_elicitation_tab = tab_creation_preference_stage()
-            click_control_preference_stage(user_preference_elicitation_tab)
-        with gr.Tab("Financial Decision Stage"):
+            user_narrative = user_preference_elicitation_tab["user_narrative"]
+            click_control_preference_stage(
+                user_preference_elicitation_tab, user_id, user_preference_elicitation_session
+            )
+        with gr.Tab("Financial Decision Stage") as financial_decision:
             # Experiment Tag
-            first_tab = tab_creation_exploration_stage(0)
-            click_control_exploration_stage(first_tab)
-            second_tab = tab_creation_exploration_stage(1)
-            click_control_exploration_stage(second_tab)
-            third_tab = tab_creation_exploration_stage(2)
-            click_control_exploration_stage(third_tab)
-            fourth_tab = tab_creation_exploration_stage(3)
-            click_control_exploration_stage(fourth_tab)
-            fifth_tab = tab_creation_exploration_stage(4)
-            click_control_exploration_stage(fifth_tab)
+            first_tab = tab_creation_exploration_stage(0, first_comp, first_context)
+            first_general_instruction, first_round_instruction = (
+                first_tab["general_instruction"],
+                first_tab["round_instruction"],
+            )
+            click_control_exploration_stage(
+                first_tab,
+                user_id,
+                first_comp_session,
+                user_preference_elicitation_session,
+                system_description_without_context,
+            )
+            second_tab = tab_creation_exploration_stage(1, second_comp, second_context)
+            second_general_instruction, second_round_instruction = (
+                second_tab["general_instruction"],
+                second_tab["round_instruction"],
+            )
+            click_control_exploration_stage(
+                second_tab,
+                user_id,
+                second_comp_session,
+                user_preference_elicitation_session,
+                system_description_without_context,
+            )
+            third_tab = tab_creation_exploration_stage(2, third_comp, third_context)
+            third_general_instruction, third_round_instruction = (
+                third_tab["general_instruction"],
+                third_tab["round_instruction"],
+            )
+            click_control_exploration_stage(
+                third_tab,
+                user_id,
+                third_comp_session,
+                user_preference_elicitation_session,
+                system_description_without_context,
+            )
+            fourth_tab = tab_creation_exploration_stage(3, fourth_comp, fourth_context)
+            fourth_general_instruction, fourth_round_instruction = (
+                fourth_tab["general_instruction"],
+                fourth_tab["round_instruction"],
+            )
+            click_control_exploration_stage(
+                fourth_tab,
+                user_id,
+                fourth_comp_session,
+                user_preference_elicitation_session,
+                system_description_without_context,
+            )
+            fifth_tab = tab_creation_exploration_stage(4, fifth_comp, fifth_context)
+            fifth_general_instruction, fifth_round_instruction = (
+                fifth_tab["general_instruction"],
+                fifth_tab["round_instruction"],
+            )
+            click_control_exploration_stage(
+                fifth_tab,
+                user_id,
+                fifth_comp_session,
+                user_preference_elicitation_session,
+                system_description_without_context,
+            )
         with gr.Tab("Final Evaluation Stage") as final_evaluation:
-            final_evaluation_tab = tab_final_evaluation(first_comp, second_comp, third_comp, fourth_comp, fifth_comp)
-            click_control_final_evaluation(final_evaluation_tab)
+            final_evaluation_tab = tab_final_evaluation()
+            ranking_first_comp, ranking_second_comp, ranking_third_comp, ranking_fourth_comp, ranking_fifth_comp = (
+                final_evaluation_tab["first"],
+                final_evaluation_tab["second"],
+                final_evaluation_tab["third"],
+                final_evaluation_tab["fourth"],
+                final_evaluation_tab["fifth"],
+            )
+            click_control_final_evaluation(
+                final_evaluation_tab, user_id, first_comp, second_comp, third_comp, fourth_comp, fifth_comp
+            )
 
+        demo.load(
+            set_initial_values,
+            inputs=None,
+            outputs=[
+                user_id,
+                narrative_id,
+                personality_id,
+                system_description_without_context,
+                raw_context_list,
+                stock_context_list,
+                user_narrative,
+                first_comp,
+                first_context,
+                first_general_instruction,
+                first_round_instruction,
+                second_comp,
+                second_context,
+                second_general_instruction,
+                second_round_instruction,
+                third_comp,
+                third_context,
+                third_general_instruction,
+                third_round_instruction,
+                fourth_comp,
+                fourth_context,
+                fourth_general_instruction,
+                fourth_round_instruction,
+                fifth_comp,
+                fifth_context,
+                fifth_general_instruction,
+                fifth_round_instruction,
+                ranking_first_comp,
+                ranking_second_comp,
+                ranking_third_comp,
+                ranking_fourth_comp,
+                ranking_fifth_comp,
+            ],
+        )
     return demo
 
 
@@ -793,14 +1079,7 @@ if __name__ == "__main__":
         "jpm_1",
         "jpm_2",
     ]
-    context_info_list = get_context(file_path)  # str to List of Dict
-    # For check, just use fifth one
-    context_info = context_info_list[5]
-    # import ipdb
-
-    # ipdb.set_trace()
-    stock_context_list = build_context(context_info)  # List of str
-    raw_context_list = build_raw_context_list(context_info)  # List of str
+    context_info_list = get_context_list(file_path)  # str to List of Dict
     # system instruction consist of Task, Personality, and Context
     """
     Personality
@@ -810,20 +1089,17 @@ if __name__ == "__main__":
     ["neurotic", "emotionally stable"]
     ["open to experience", "closed to experience"]]
     """
-
-    personality = [
-        "extroverted",
-        "agreeable",
-        "conscientious",
-        "emotionally stable",
-        "open to experience",
-    ]
-
-    personality_prompt = build_personality_prompt(personality)
-    system_instruction_without_context = SYSTEM_INSTRUCTION + "\n" + personality_prompt + "\n"
-    # tokenizer = AutoTokenizer.from_pretrained(RESPONSE_GENERATOR)
-    # tokenizer, terminator = prepare_tokenizer(tokenizer)
+    # Global variables
+    personality = {
+        1: [
+            "extroverted",
+            "agreeable",
+            "conscientious",
+            "emotionally stable",
+            "open to experience",
+        ]
+    }
+    personality_prompts = {i: build_personality_prompt(p) for i, p in personality.items()}
     terminator = ["<eos>", "<unk>", "<sep>", "<pad>", "<cls>", "<mask>"]
-    print(f"Terminator: {terminator}")
-    demo = create_demo(terminator, system_instruction_without_context, stock_context_list, raw_context_list)
-    demo.launch(share=True)
+    demo = create_demo()
+    demo.launch(share=True, auth=[("user_1_1", "pw1"), ("user_2_1", "pw2"), ("user_3_1", "pw3"), ("user_4_1", "pw4")])