Initial Commit

.gitignore

@@ -0,0 +1,74 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+**/__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.eggs/
+dist/
+build/
+sdist/
+*.egg-info/
+pip-log.txt
+pip-wheel-metadata/
+*.whl
+
+# Environments
+.venv/
+venv/
+env/
+ENV/
+*.env
+
+# PyInstaller
+#  Usually these files are written by a python script; ignoring them is safe
+#  https://docs.pyinstaller.org/en/stable/when-things-go-wrong.html
+_MEIPASS*
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.log
+*.rpt
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.db
+*.sqlite3
+*/migrations
+
+# Flask stuff:
+instance/
+*.ini
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx stuff:
+docs/_build
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# VS Code
+.vscode/
+
+# PyCharm
+.idea/
+
+# OS or Editor-specific files
+.DS_Store
+Thumbs.db
+
+.idea/

README.md

@@ -0,0 +1,37 @@
+---
+title: llm-autobiography
+app_file: chatgpt.py
+sdk: gradio
+sdk_version: 3.50.2
+---
+#  Chatbot Frontend
+
+## Prerequisites
+- Python 3.x
+- pip
+
+## Installation
+1. Clone this repository
+
+2. Navigate to the project directory:
+   ```
+   cd chatbot-mimic-notes
+   ```
+3. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+
+## Running the Application
+Start the chatbot by running:
+```
+python chatgpt.py
+```
+
+## Usage
+- Open Chrome and visit `http://localhost:7860` to interact with the chatbot.
+
+## Run Server
+```
+python -m src.server
+```

chatgpt.py

@@ -0,0 +1,318 @@
+import gradio as gr
+import whisper
+import asyncio
+import httpx
+import tempfile
+import os
+import requests
+import time
+import threading
+from datetime import datetime, timedelta
+
+session = requests.Session()
+
+from interview_protocol import protocols as interview_protocols
+
+model = whisper.load_model("base")
+
+base_url = "http://localhost:8080"
+
+timeout = 60
+concurrency_count=10
+
+async def initialization(api_key, username):
+    url = f"{base_url}/api/initialization"
+    headers = {'Content-Type': 'application/json'}
+    data = {
+        'api_key': api_key,
+        'username': username,
+    }
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                return "Initialization successful."
+            else:
+                return f"Initialization failed: {response.text}"
+        except asyncio.TimeoutError:
+            print("The request timed out")
+            return "Request timed out during initialization."
+        except Exception as e:
+            return f"Error in initialization: {str(e)}"
+
+# def fetch_default_prompts(chatbot_type):
+#     url = f"{base_url}?chatbot_type={chatbot_type}"
+#     try:
+#         response = httpx.get(url, timeout=timeout)
+#         if response.status_code == 200:
+#             prompts = response.json()
+#             print(prompts)
+#             return prompts
+#         else:
+#             print(f"Failed to fetch prompts: {response.status_code} - {response.text}")
+#             return {}
+#     except Exception as e:
+#         print(f"Error fetching prompts: {str(e)}")
+#         return {}
+
+async def get_backend_response(api_key, patient_prompt, username, chatbot_type):
+    url = f"{base_url}/responses/doctor"
+    headers = {'Content-Type': 'application/json'}
+    data = {
+        'username': username,
+        'patient_prompt': patient_prompt,
+        'chatbot_type': chatbot_type
+    }
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                response_data = response.json()
+                return response_data
+            else:
+                return f"Failed to fetch response from backend: {response.text}"
+        except Exception as e:
+            return f"Error contacting backend service: {str(e)}"
+
+async def save_conversation_and_memory(username, chatbot_type):
+    url = f"{base_url}/save/end_and_save"
+    headers = {'Content-Type': 'application/json'}
+    data = {
+        'username': username,
+        'chatbot_type': chatbot_type
+    }
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                response_data = response.json()
+                return response_data.get('message', 'Saving Error!')
+            else:
+                return f"Failed to save conversations and memory graph: {response.text}"
+        except Exception as e:
+            return f"Error contacting backend service: {str(e)}"
+
+async def get_conversation_histories(username, chatbot_type):
+    url = f"{base_url}/save/download_conversations"
+    headers = {'Content-Type': 'application/json'}
+    data = {
+        'username': username,
+        'chatbot_type': chatbot_type
+    }
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        try:
+            response = await client.post(url, json=data, headers=headers)
+            if response.status_code == 200:
+                conversation_data = response.json()
+                return conversation_data
+            else:
+                return []
+        except Exception as e:
+            return []
+
+def download_conversations(username, chatbot_type):
+    conversation_histories = asyncio.run(get_conversation_histories(username, chatbot_type))
+    files = []
+    temp_dir = tempfile.mkdtemp()
+    for conversation_entry in conversation_histories:
+        file_name = conversation_entry.get('file_name', f"Conversation_{len(files)+1}.txt")
+        conversation = conversation_entry.get('conversation', [])
+        conversation_text = ""
+        for message_pair in conversation:
+            if isinstance(message_pair, list) and len(message_pair) == 2:
+                speaker, message = message_pair
+                conversation_text += f"{speaker.capitalize()}: {message}\n\n"
+            else:
+                conversation_text += f"Unknown format: {message_pair}\n\n"
+        temp_file_path = os.path.join(temp_dir, file_name)
+        with open(temp_file_path, 'w') as temp_file:
+            temp_file.write(conversation_text)
+        files.append(temp_file_path)
+    return files
+
+# async def get_biography(username, chatbot_type):
+#     url = f"{base_url}/save/generate_autobiography"
+#     headers = {'Content-Type': 'application/json'}
+#     data = {
+#         'username': username,
+#         'chatbot_type': chatbot_type
+#     }
+#     async with httpx.AsyncClient(timeout=timeout) as client:
+#         try:
+#             response = await client.post(url, json=data, headers=headers)
+#             if response.status_code == 200:
+#                 biography_data = response.json()
+#                 biography_text = biography_data.get('biography', '')
+#                 return biography_text
+#             else:
+#                 return "Failed to generate biography."
+#         except Exception as e:
+#             return f"Error contacting backend service: {str(e)}"
+
+# def download_biography(username, chatbot_type):
+#     biography_text = asyncio.run(get_biography(username, chatbot_type))
+#     if not biography_text or "Failed" in biography_text or "Error" in biography_text:
+#         return gr.update(value=None, visible=False), gr.update(value=biography_text, visible=True)
+#     temp_dir = tempfile.mkdtemp()
+#     temp_file_path = os.path.join(temp_dir, "biography.txt")
+#     with open(temp_file_path, 'w') as temp_file:
+#         temp_file.write(biography_text)
+#     return temp_file_path, gr.update(value=biography_text, visible=True)
+
+def transcribe_audio(audio_file):
+    transcription = model.transcribe(audio_file)["text"]
+    return transcription
+
+def submit_text_and_respond(edited_text, api_key, username, history, chatbot_type):
+    response = asyncio.run(get_backend_response(api_key, edited_text, username, chatbot_type))
+    print('------')
+    print(response)
+    if isinstance(response, str):
+        history.append((edited_text, response))
+        return history, "", []
+    doctor_response = response['doctor_response']
+    history.append((edited_text, doctor_response))
+    return history, ""  # Return memory_graph as output
+
+def set_initialize_button(api_key_input, username_input):
+    message = asyncio.run(initialization(api_key_input, username_input))
+    print(message)
+    return message, api_key_input
+
+def save_conversation(username, chatbot_type):
+    response = asyncio.run(save_conversation_and_memory(username, chatbot_type))
+    return response
+
+def start_recording(audio_file):
+    if not audio_file:
+        return ""
+    try:
+        transcription = transcribe_audio(audio_file)
+        return transcription
+    except Exception as e:
+        return f"Failed to transcribe: {str(e)}"
+
+def update_methods(chapter):
+    return gr.update(choices=interview_protocols[chapter], value=interview_protocols[chapter][0])
+
+# def update_memory_graph(memory_data):
+#     table_data = []
+#     for node in memory_data:
+#         table_data.append([
+#             node.get('date', ''),
+#             node.get('topic', ''),
+#             node.get('event_description', ''),
+#             node.get('people_involved', '')
+#         ])
+#     return table_data
+
+# def update_prompts(chatbot_display_name):
+#     chatbot_type = display_to_value.get(chatbot_display_name, 'enhanced')
+#     prompts = fetch_default_prompts(chatbot_type)
+#     return (
+#         gr.update(value=prompts.get('system_prompt', '')),
+#         gr.update(value=prompts.get('conv_instruction_prompt', '')),
+#         gr.update(value=prompts.get('therapy_prompt', '')),
+#         gr.update(value=prompts.get('autobio_generation_prompt', '')),
+#     )
+
+# def update_chatbot_type(chatbot_display_name):
+#     chatbot_type = display_to_value.get(chatbot_display_name, 'enhanced')
+#     return chatbot_type
+
+# CSS to keep the buttons small
+css = """
+#start_button, #reset_button {
+    padding: 4px 10px !important;
+    font-size: 12px !important;
+    width: auto !important;
+}
+"""
+
+with gr.Blocks(css=css) as app:
+    chatbot_type_state = gr.State('enhanced')
+    api_key_state = gr.State()
+    prompt_visibility_state = gr.State(False)
+
+    is_running = gr.State()
+    target_timestamp = gr.State()
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=250):
+            gr.Markdown("## Settings")
+
+            with gr.Box():
+                gr.Markdown("### User Information")
+                username_input = gr.Textbox(
+                    label="Username", placeholder="Enter your username"
+                )
+                
+                api_key_input = gr.Textbox(
+                    label="OpenAI API Key",
+                    placeholder="Enter your openai api key",
+                    type="password"
+                )
+
+            initialize_button = gr.Button("Initialize", variant="primary", size="large")
+            initialization_status = gr.Textbox(
+                label="Status", interactive=False, placeholder="Initialization status will appear here."
+            )
+
+            initialize_button.click(
+                fn=set_initialize_button,
+                inputs=[api_key_input, username_input],  # chatbot_type_dropdown replaced with None
+                outputs=[initialization_status, api_key_state],
+            )
+
+            # define the function to toggle prompts visibility
+            # def toggle_prompts(visibility):
+            #     new_visibility = not visibility
+            #     button_text = "Hide Prompts" if new_visibility else "Show Prompts"
+            #     return gr.update(value=button_text), gr.update(visible=new_visibility), new_visibility
+
+        with gr.Column(scale=3):
+
+            chatbot = gr.Chatbot(label="Provide Your Pre-Operation Notes Here", height=500)
+
+            with gr.Row():
+                transcription_box = gr.Textbox(
+                    label="Transcription (You can edit this)", lines=3
+                )
+                audio_input = gr.Audio(
+                    source="microphone", type="filepath", label="🎤 Record Audio"
+                )
+
+            with gr.Row():
+                submit_button = gr.Button("Submit", variant="primary", size="large")
+                save_conversation_button = gr.Button("End and Save Conversation", variant="secondary")
+                download_button = gr.Button("Download Conversations", variant="secondary")
+
+            audio_input.change(
+                fn=start_recording,
+                inputs=[audio_input],
+                outputs=[transcription_box]
+            )
+
+            state = gr.State([])
+
+            submit_button.click(
+                submit_text_and_respond,
+                inputs=[transcription_box, api_key_state, username_input, state, chatbot_type_state],
+                outputs=[chatbot, transcription_box]
+            )
+
+            download_button.click(
+                fn=download_conversations,
+                inputs=[username_input, chatbot_type_state],
+                outputs=gr.Files()
+            )
+
+            save_conversation_button.click(
+                fn=save_conversation,
+                inputs=[username_input, chatbot_type_state],
+                outputs=None
+            )
+
+
+    app.queue()
+    app.launch(share=True, max_threads=10)

requirements.txt

@@ -0,0 +1,67 @@
+aiofiles==23.2.1
+altair==5.4.1
+annotated-types==0.7.0
+anyio==4.5.0
+attrs==24.2.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.3.0
+cycler==0.12.1
+exceptiongroup==1.2.2
+fastapi==0.115.0
+ffmpy==0.4.0
+filelock==3.16.1
+fonttools==4.53.1
+fsspec==2024.9.0
+gradio==3.50.2
+gradio_client==0.6.1
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.2
+huggingface-hub==0.25.0
+idna==3.10
+importlib_resources==6.4.5
+Jinja2==3.1.4
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.7
+llvmlite==0.43.0
+MarkupSafe==2.1.5
+matplotlib==3.9.2
+more-itertools==10.5.0
+mpmath==1.3.0
+narwhals==1.8.1
+networkx==3.3
+numba==0.60.0
+numpy==1.26.4
+openai-whisper==20231117
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pillow==10.4.0
+pydantic==2.9.2
+pydantic_core==2.23.4
+pydub==0.25.1
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+python-multipart==0.0.9
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+regex==2024.9.11
+requests==2.32.3
+rpds-py==0.20.0
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.1
+starlette==0.38.5
+sympy==1.13.3
+tiktoken==0.7.0
+torch
+tqdm==4.66.5
+typing_extensions==4.12.2
+tzdata==2024.1
+urllib3==2.2.3
+uvicorn==0.30.6
+websockets==11.0.3

src/agents/chat_agent.py

@@ -0,0 +1,39 @@
+import json
+import os
+
+from src.agents.context import Context
+from src.utils.utils import load_config
+from src.agents.chat_llm import chat_llm
+
+class BaseChatAgent:
+    def __init__(self, config_path) -> None:
+        self.agent_config = load_config(config_path)
+        # conversation context
+        self.context = Context()
+        self.history_conversations = []
+        # set default interview protocal index
+
+        self.hist_conv_summarization = None
+    
+
+    def talk_to_user(
+        self,
+        user_response=None,
+    ):
+
+        self.context.add_user_prompt(user_response['patient_prompt'])
+
+        response = chat_llm(
+            messages=self.context.msg,
+            model=self.agent_config.llm_model_path,
+            temperature=self.agent_config.temperature,
+            max_tokens=self.agent_config.max_tokens,
+            n=1,
+            timeout=self.agent_config.timeout,
+            stop=None,
+        )
+
+        self.context.add_assistant_prompt(response)
+
+        return response["generations"][0]
+    

src/agents/chat_llm.py

@@ -0,0 +1,79 @@
+import yaml
+from box import Box
+from langchain.chat_models import ChatOpenAI
+from langchain_community.chat_models import ChatOpenAI
+from langchain_community.llms import DeepInfra
+from langchain.schema import HumanMessage, SystemMessage, AIMessage
+import logging
+import os
+
+
+def chat_llm(messages, model, temperature, max_tokens, n, timeout=600, stop=None, return_tokens=False):
+    if model.__contains__("gpt"):
+        iterated_query = False
+        try:
+            chat = ChatOpenAI(model_name=model,
+                            temperature=temperature,
+                            max_tokens=max_tokens,
+                            n=n,
+                            request_timeout=timeout,
+                            model_kwargs={"seed": 0,
+                                            "top_p": 0
+                                            })
+        except Exception as e:
+            print(f"Error in loading model: {e}")
+            return None
+    else:
+        # deepinfra
+        iterated_query = True
+        chat = ChatOpenAI(model_name=model,
+                          openai_api_key=None,
+                          temperature=temperature,
+                          max_tokens=max_tokens,
+                          n=1,
+                          request_timeout=timeout,
+                          openai_api_base="https://api.deepinfra.com/v1/openai")
+
+    longchain_msgs = []
+    for msg in messages:
+        if msg['role'] == 'system':
+            longchain_msgs.append(SystemMessage(content=msg['content']))
+        elif msg['role'] == 'user':
+            print('human message', msg)
+            longchain_msgs.append(HumanMessage(content=msg['content']))
+        elif msg['role'] == 'assistant':
+            longchain_msgs.append(AIMessage(content=msg['content']))
+        else:
+            raise NotImplementedError
+    # add an empty user message to avoid no user message error
+    longchain_msgs.append(HumanMessage(content=""))
+    if n > 1 and iterated_query:
+        response_list = []
+        total_completion_tokens = 0
+        total_prompt_tokens = 0
+        for n in range(n):
+            generations = chat.generate([longchain_msgs], stop=[
+                stop] if stop is not None else None)
+            responses = [
+                chat_gen.message.content for chat_gen in generations.generations[0]]
+            response_list.append(responses[0])
+            completion_tokens = generations.llm_output['token_usage']['completion_tokens']
+            prompt_tokens = generations.llm_output['token_usage']['prompt_tokens']
+            total_completion_tokens += completion_tokens
+            total_prompt_tokens += prompt_tokens
+        responses = response_list
+        completion_tokens = total_completion_tokens
+        prompt_tokens = total_prompt_tokens
+    else:
+        generations = chat.generate([longchain_msgs], stop=[
+                                    stop] if stop is not None else None)
+        responses = [
+            chat_gen.message.content for chat_gen in generations.generations[0]]
+        completion_tokens = generations.llm_output['token_usage']['completion_tokens']
+        prompt_tokens = generations.llm_output['token_usage']['prompt_tokens']
+
+    return {
+        'generations': responses,
+        'completion_tokens': completion_tokens,
+        'prompt_tokens': prompt_tokens
+    }

src/agents/context.py

@@ -0,0 +1,41 @@
+
+class ContextAttributeError(BaseException):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+class Context:
+    def __init__(self) -> None:
+        self.msg = []
+        pass
+
+    def add_system_prompt(self, prompt: str):
+        pt = {
+            'role': 'system',
+            'content': prompt
+        }
+
+        # replace the last system prompt if it exists or insert to 0 if it doesn't
+        if len(self.msg) > 0 and self.msg[0]['role'] == 'system':
+            self.msg[0] = pt
+        else:
+            self.msg.insert(0, pt)
+
+    def add_user_prompt(self, prompt: str):
+        pt = {
+            'role': 'user',
+            'content': prompt
+        }
+        self.msg.append(pt)
+
+    def remove_last_prompt(self):
+        self.msg.pop(-1)
+
+    def add_assistant_prompt(self, prompt: str):
+        pt = {
+            'role': 'assistant',
+            'content': prompt
+        }
+
+        self.msg.append(pt)

src/configs/Mixtral-8x22B.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: mistralai/Mixtral-8x22B-Instruct-v0.1
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/Qwen2-72B-Instruct.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: Qwen/Qwen2-72B-Instruct
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/anthony_trollope.yaml

@@ -0,0 +1,12 @@
+agent_name: Patient
+#llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4o
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+patient_id: 'Anthony_Trollope'
+autobiography_path_for_summary: ./assets/autobiography/anthony_trollope/autobiography_chapters_Anthony_Trollope.json
+autobiography_path_for_rag: ./assets/autobiography/anthony_trollope/An_Autobiography_of_Anthony_Trollope.txt
+autobiography_pre_summary_path: ./assets/autobiography/anthony_trollope/autobiography_pre_summary_Anthony_Trollope.json
+autobiography_pre_event_path: ./assets/autobiography/anthony_trollope/autobiography_pre_event_parsed_Anthony_Trollope.json

src/configs/catherine_helen_spence.yaml

@@ -0,0 +1,12 @@
+agent_name: Patient
+#llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4o
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+patient_id: 'Catherine_Helen_Spence'
+autobiography_path_for_summary: ./assets/autobiography/catherine_helen_spence/autobiography_chapters_Catherine_Helen_Spence.json
+autobiography_path_for_rag: ./assets/autobiography/catherine_helen_spence/An_Autobiography_by_Catherine_Helen_Spence.txt
+autobiography_pre_summary_path: ./assets/autobiography/catherine_helen_spence/autobiography_pre_summary_Catherine_Helen_Spence.json
+autobiography_pre_event_path: ./assets/autobiography/catherine_helen_spence/autobiography_pre_event_parsed_Catherine_Helen_Spence.json

src/configs/counselor_config.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: gpt-3.5-turbo
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/eval_config.yaml

@@ -0,0 +1,9 @@
+llm_model_path: gpt-4-turbo-preview
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+autobiography_path_for_summary: ./assets/autobiography_chapters.json
+autobiography_path_for_rag: ./assets/autobiography/13991012000013_Test.txt
+autobiography_pre_summary_path: ./assets/autobiography_pre_summary.json
+autobiography_pre_event_path: ./assets/autobiography_pre_event.json

src/configs/gpt-4o_counselor_config.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: gpt-4o-2024-05-13
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/jane_eyre_config.yaml

@@ -0,0 +1,12 @@
+agent_name: Patient
+#llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4o
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+patient_id: 'Jane_Eyre'
+autobiography_path_for_summary: ./assets/autobiography/jane_eyre/autobiography_chapters_Jane_Eyre.json
+autobiography_path_for_rag: ./assets/autobiography/jane_eyre/Jane_Eyre_An_Autobiography.txt
+autobiography_pre_summary_path: ./assets/autobiography/jane_eyre/autobiography_pre_summary_Jane_Eyre.json
+autobiography_pre_event_path: ./assets/autobiography/jane_eyre/autobiography_pre_event_parsed_Jane_Eyre.json

src/configs/llama3-70b_counselor_config.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: meta-llama/Meta-Llama-3-70B-Instruct
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/llama3-8b_counselor_config.yaml

@@ -0,0 +1,9 @@
+agent_name: Doctor
+llm_model_path: meta-llama/Meta-Llama-3-8B-Instruct
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+use_emotion_module: False
+session_max_tokens: 4096
+patient_conv_history_dir: ./assets/conversation_history

src/configs/memory_graph_config.yaml

@@ -0,0 +1,5 @@
+llm_model_path: gpt-4o
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0

src/configs/metric_config.yaml

@@ -0,0 +1,9 @@
+llm_model_path: gpt-4-turbo-preview
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+autobiography_pre_memory_path: ./assets/demo/conv_history_w_interview_protocol_w_memorygraph/Obama/memory_graph
+autobiography_pre_event_path: ./assets/autobiography_pre_event_parsed.json
+autobiography_pre_event_emb_path: ./assets/autobiography_pre_event_emb.json
+metrics_output_path: ./assets/eval_output/

src/configs/obama_config.yaml

@@ -0,0 +1,12 @@
+agent_name: Patient
+# llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4-turbo
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+patient_id: 'Obama'
+autobiography_path_for_summary: ./assets/autobiography/obama/autobiography_chapters.json
+autobiography_path_for_rag: ./assets/autobiography/obama/13991012000013_Test.txt
+autobiography_pre_summary_path: ./assets/autobiography/obama/autobiography_pre_summary.json
+autobiography_pre_event_path: ./assets/autobiography/obama/autobiography_pre_event_parsed.json

src/configs/patient_config.yaml

@@ -0,0 +1,11 @@
+agent_name: Patient
+#llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4-turbo
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+patient_id: 'Obama'
+autobiography_path_for_summary: ./assets/autobiography/obama/autobiography_chapters.json
+autobiography_path_for_rag: ./assets/autobiography/obama/13991012000013_Test.txt
+autobiography_pre_summary_path: ./assets/autobiography/obama/autobiography_pre_summary.json

src/configs/patient_config_autobio_summary.yaml

@@ -0,0 +1,29 @@
+agent_name: Patient
+#llm_model_path: gpt-4o-2024-05-13
+llm_model_path: gpt-4-turbo
+max_tokens: 1024
+timeout: 600
+num_generations: 1
+temperature: 0
+# patient_id: 'Obama'
+# autobiography_path_for_summary: ./assets/autobiography_chapters_demo.json
+# autobiography_path_for_rag: ./assets/autobiography/13991012000013_Test.txt
+# autobiography_pre_summary_path: ./assets/autobiography_pre_summary.json
+
+# patient_id: 'Trollope'
+# autobiography_pre_summary_path: ./assets/autobiography_pre_summary_Anthony_Trollope.json
+# autobiography_path_for_summary: ./assets/autobiography_chapters_Anthony_Trollope.json
+# autobiography_pre_event_path: ./assets/autobiography_pre_event_Anthony_Trollope.json
+# autobiography_event_parsed_path: ./assets/autobiography_pre_event_parsed_Anthony_Trollope.json
+
+# patient_id: 'Spence'
+# autobiography_pre_summary_path: ./assets/autobiography_pre_summary_Catherine_Helen_Spence.json
+# autobiography_path_for_summary: ./assets/autobiography_chapters_Catherine_Helen_Spence.json
+# autobiography_pre_event_path: ./assets/autobiography_pre_event_Catherine_Helen_Spence.json
+# autobiography_event_parsed_path: ./assets/autobiography_pre_event_parsed_Catherine_Helen_Spence.json
+
+patient_id: 'Jane_Eyre'
+autobiography_pre_summary_path: ./assets/autobiography_pre_summary_Jane_Eyre.json
+autobiography_path_for_summary: ./assets/autobiography_chapters_Jane_Eyre.json
+autobiography_pre_event_path: ./assets/autobiography_pre_event_Jane_Eyre.json
+autobiography_event_parsed_path: ./assets/autobiography_pre_event_parsed_Jane_Eyre.json

src/conversation.py

@@ -0,0 +1,101 @@
+
+import os.path
+import copy
+from datetime import datetime
+import pytz
+
+class Conversation:
+    def __init__(self) -> None:
+        self.patient_info = ""
+
+        self.conversation = []
+
+        self.patient_out = None
+        self.doctor_out = None
+
+        self.patient = None
+        self.doctor = None
+
+        self.time_stamp = datetime.now(pytz.timezone('US/Eastern')).strftime("%m/%d/%Y, %H:%M:%S, %f")
+
+    def set_patient(self, patient):
+        self.patient = patient
+        self.patient_info = {
+            "patient_model_config": patient.agent_config,
+            # "patient_story": patient.agent_config
+        }
+
+    def set_doctor(self, doctor):
+        self.doctor = doctor
+
+    def generate_doctor_response(self):
+        '''
+        Must be called after setting the patient and doctor
+        '''
+        self.doctor_out = self.doctor.talk_to_patient(self.patient_out, 
+                                                      conversations=self.conversation)[0]
+        return self.doctor_out
+
+    def generate_patient_response(self):
+        '''
+        Must be called after setting the patient and doctor
+        '''
+        self.patient_out = self.patient.talk_to_doctor(self.doctor_out)[0]
+        return self.patient_out
+
+    def submit_doctor_response(self, response):
+        self.conversation.append(("doctor", response))
+        self.doctor.context.add_assistant_prompt(response)
+
+    def submit_patient_response(self, response):
+        self.conversation.append(("patient", response))
+        self.patient.context.add_assistant_prompt(response)
+
+    def get_virtual_doctor_token(self):
+        return self.doctor.current_tokens
+
+
+    def start_session(self, num_conv_round):
+        self.conversation_round = 1
+        while True:
+
+            doctor_out = self.generate_doctor_response()
+            self.submit_doctor_response(doctor_out)
+            print(f'Round {self.conversation_round} Doctor: {doctor_out}')
+
+            patient_out = self.generate_patient_response()
+            self.submit_patient_response(patient_out)
+            print(f'Round {self.conversation_round} Patient: {patient_out}')
+
+            self.conversation_round += 1
+            # Condition when we jump out of the loop
+            if self.conversation_round >= num_conv_round:
+                break
+
+    def set_condition(self, _type, value=None):
+        # TODO not implemented
+        pass
+
+    def to_dict(self):
+        return {
+            'time_stamp': self.time_stamp,
+            'patient': {
+                'patient_user_id': self.patient.patient_id,
+                'patient_info': self.patient_info,
+                'patient_context': self.patient.context.msg
+            },
+            'doctor': {
+                'doctor_model_config': self.doctor.agent_config,
+                'doctor_context': self.doctor.context.msg
+            },
+            "conversation": self.conversation,
+        }
+
+    def __json__(self):
+        return self.to_dict()
+
+
+if __name__ == '__main__':
+    os.environ["OPENAI_API_KEY"] = "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"
+    c = Conversation()
+    c.start_session()

src/server.py

@@ -0,0 +1,297 @@
+from agents.chat_agent import BaseChatAgent
+from src.utils.utils import save_as_json
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+import sys
+import time
+import traceback
+import boto3
+import argparse
+import pytz
+import json
+from datetime import datetime
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+class Server:
+    def __init__(self) -> None:
+        self.patient_info = ""
+
+        self.conversation = []
+
+        self.patient_out = None
+        self.doctor_out = None
+        self.patient = None
+        self.doctor = None
+
+        self.conversation_round = 0
+        self.interview_protocol_index = None
+
+    def set_timestamp(self):
+        self.timestamp = datetime.now(pytz.timezone('US/Eastern')).strftime("%m/%d/%Y-%H:%M:%S")
+
+    def set_patient(self, patient):
+        self.patient = patient
+        self.patient_info = {
+            "patient_model_config": patient.agent_config,
+        }
+
+    def set_doctor(self, doctor):
+        self.doctor = doctor
+
+    def set_interview_protocol_index(self, interview_protocol_index):
+        self.interview_protocol_index = interview_protocol_index
+
+    def generate_doctor_response(self):
+        '''
+        Must be called after setting the patient and doctor
+        '''
+        self.doctor_out = self.doctor.talk_to_user(
+            self.patient_out, conversations=self.conversation)[0]
+        return self.doctor_out
+
+    def submit_doctor_response(self, response):
+        self.conversation.append(("doctor", response))
+        self.doctor.context.add_assistant_prompt(response)
+
+    def submit_patient_response(self, response):
+        self.conversation.append(("patient", response))
+        self.patient.context.add_assistant_prompt(response)
+
+    def get_response(self, patient_prompt):
+        self.patient_out = patient_prompt
+        self.submit_patient_response(patient_prompt)
+        print(f'Round {self.conversation_round} Patient: {patient_prompt}')
+    
+        if patient_prompt is not None:
+            self.conversation_round += 1
+
+        doctor_out = self.generate_doctor_response()
+        self.submit_doctor_response(doctor_out)
+        print(f'Round {self.conversation_round} Doctor: {doctor_out}')
+
+        return {"response": doctor_out}
+
+    def to_dict(self):
+        return {
+            'time_stamp': self.timestamp,
+            'patient': {
+                'patient_user_id': self.patient.patient_id,
+                'patient_info': self.patient_info,
+                'patient_context': self.patient.context.msg
+            },
+            'doctor': {
+                'doctor_model_config': self.doctor.agent_config,
+                'doctor_context': self.doctor.context.msg
+            },
+            "conversation": self.conversation,
+            "interview_protocol_index": self.interview_protocol_index
+        }
+
+    def __json__(self):
+        return self.to_dict()
+
+    def reset(self):
+        self.conversation = []
+        self.conversation_round = 0
+        if hasattr(self.doctor, 'reset') and callable(getattr(self.doctor, 'reset')):
+            self.doctor.reset()
+        if hasattr(self.patient, 'reset') and callable(getattr(self.patient, 'reset')):
+            self.patient.reset()
+
+
+def create_app():
+    app = Flask(__name__)
+    CORS(app)
+    app.user_servers = {}
+    return app
+
+
+def configure_routes(app, args):
+
+    @app.route('/', methods=['GET'])
+    def home():
+        '''
+        This api will return the default prompts used in the backend, including system prompt, autobiography generation prompt, therapy prompt, and conversation instruction prompt
+        Return:
+            {
+            system_prompt: String,
+            autobio_generation_prompt: String,
+            therapy_prompt: String,
+            conv_instruction_prompt: String
+            }
+        '''
+
+
+        return jsonify({
+        }), 200
+
+
+    @app.route('/api/initialization', methods=['POST'])
+    def initialization():
+        '''
+        This API processes user configurations to initialize conversation states. It specifically accepts the following parameters:
+        api_key, username, chapter_name, topic_name, and prompts. The API will then:
+        1. Initialize a Server() instance for managing conversations and sessions.
+        2. Configure the user-defined prompts.
+        3. Set up the chapter and topic for the conversation.
+        4. Configure the save path for both local storage and Amazon S3.
+        '''
+        data = request.get_json()
+        username = data.get('username')
+
+        os.environ["OPENAI_API_KEY"] = "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"
+
+        # initialize
+        # server.patient.patient_id = username
+        counselor = BaseChatAgent(config_path=args.counselor_config_path)
+        print(counselor)
+        server = Server()
+        # server.set_doctor = counselor
+        server.doctor = counselor
+        app.user_servers[username] = server
+
+        return jsonify({"message": "API key set successfully"}), 200
+
+    @app.route('/save/download_conversations', methods=['POST'])
+    def download_conversations():
+        """
+        This API retrieves the user's conversation history based on their username and returns the conversation data to the frontend.
+        Return:
+            conversations: List[String]
+        """
+        data = request.get_json()
+        username = data.get('username')
+        chatbot_type = data.get('chatbot_type')
+        if not username:
+            return jsonify({'error': 'Username not provided'}), 400
+        if not chatbot_type:
+            return jsonify({'error': 'Chatbot type not provided'}), 400
+
+        conversation_dir = os.path.join('user_data', chatbot_type, username, 'conversation')
+        if not os.path.exists(conversation_dir):
+            return jsonify({'error': 'User not found or no conversations available'}), 404
+
+        # Llist all files in the conversation directory
+        files = os.listdir(conversation_dir)
+        conversations = []
+
+        # read each conversation file and append the conversation data to the list
+        for file_name in files:
+            file_path = os.path.join(conversation_dir, file_name)
+            try:
+                with open(file_path, 'r') as f:
+                    conversation_data = json.load(f)
+                    # extract the 'conversation' from the JSON
+                    conversation_content = conversation_data.get('conversation', [])
+                    conversations.append({
+                        'file_name': file_name,
+                        'conversation': conversation_content
+                    })
+            except Exception as e:
+                print(f"Error reading {file_name}: {e}")
+                continue
+
+        return jsonify(conversations), 200
+
+    @app.route('/save/end_and_save', methods=['POST'])
+    def save_conversation_memory():
+        """
+        This API saves the current conversation history and memory events to the backend, then synchronizes the data with the Amazon S3 server.
+        """
+        data = request.get_json()
+        username = data.get('username')
+        chatbot_type = data.get('chatbot_type')
+
+        if not username:
+            return jsonify({"error": "Username not provided"}), 400
+        if not chatbot_type:
+            return jsonify({"error": "Chatbot type not provided"}), 400
+        server = app.user_servers.get(username)
+        if not server:
+            return jsonify({"error": "User session not found"}), 400
+
+        # save conversation history
+        server.set_timestamp()
+        save_name = f'{server.chapter_name}-{server.topic_name}-{server.timestamp}.json'
+        save_name = save_name.replace(' ', '-').replace('/', '-')
+        print(save_name)
+
+        # save to local file
+        local_conv_file_path = os.path.join(server.patient.conv_history_path, save_name)
+        save_as_json(local_conv_file_path, server.to_dict())
+
+        local_memory_graph_file = os.path.join(server.patient.memory_graph_path, save_name)
+        # if the chatbot type is 'baseline', create a dummy memory graph file
+        if chatbot_type == 'baseline':
+            save_as_json(local_memory_graph_file, {'time_indexed_memory_chain': []})
+        else:
+            # save memory graph
+            server.doctor.memory_graph.save(local_memory_graph_file)
+        
+        return jsonify({"message": "Current conversation and memory graph are saved!"}), 200
+
+    @app.route('/responses/doctor', methods=['POST'])
+    def get_response():
+        """
+        This API retrieves the chatbot's response and returns both the response and updated memory events to the frontend.
+        Return:
+            {
+            doctor_response: String,
+            memory_events: List[dict]
+            }
+        """
+        data = request.get_json()
+        username = data.get('username')
+
+        # patient_prompt = data.get('patient_prompt')
+        # chatbot_type = data.get('chatbot_type')
+        # if not username or not patient_prompt:
+        #     return jsonify({"error": "Username or patient prompt not provided"}), 400
+        # if not chatbot_type:
+        #     return jsonify({"error": "Chatbot type not provided"}), 400
+        # if not
+        # server = app.user_servers.get(username)
+        # if not server:
+        #     return jsonify({"error": "User session not found"}), 400
+
+        # print(server.patient.patient_id, server.chapter_name, server.topic_name)
+        # doctor_response = server.get_response(patient_prompt=patient_prompt)
+        
+        # if chatbot_type == 'baseline':
+        #     memory_events = []
+        # else:
+        #     memory_events = server.doctor.memory_graph.to_list()
+        print('username', username)
+        server = app.user_servers.get(username)
+        llm_chatbot = server.doctor
+        response = llm_chatbot.talk_to_user(data)
+
+        return jsonify({'doctor_response': response})
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    # parser.add_argument('--patient-config-path', type=str,
+    #                     default='./src/configs/patient_config.yaml')
+    parser.add_argument('--counselor-config-path', type=str,
+                        default='./src/configs/counselor_config.yaml')
+    # parser.add_argument('--retriever-config-path', type=str,
+    #                     default='./src/configs/retrievers/faiss_retriever.yaml')
+    parser.add_argument('--store-dir',
+                        type=str, default='./user_data')
+    # parser.add_argument('--memory-graph-config', default='./src/configs/memory_graph_config.yaml')
+    # parser.add_argument('--num-conversation-round', type=int, default=30)
+    args = parser.parse_args()
+
+    app = create_app()
+    configure_routes(app, args)
+
+    port = int(os.environ.get('PORT', 8080))
+    app.run(port=port, host='0.0.0.0', debug=False)
+
+
+if __name__ == '__main__':
+    main()

src/utils/utils.py

@@ -0,0 +1,44 @@
+
+import yaml
+import json
+import os
+from box import Box
+import re
+
+MAX_INPUT_TOKEN_NUM = 128000
+
+def load_config(config_path):
+    config = Box.from_yaml(
+        filename=config_path, Loader=yaml.FullLoader)
+    return config
+
+
+
+def save_as_json(path, data):
+    '''
+    outout a json file with indent equals to 2
+    '''
+    json_data = json.dumps(data, indent=2)
+    # Save JSON to a file
+    try:
+        # Create the directory structure if it doesn't exist
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        # Write data to the JSON file
+        with open(path, 'w') as json_file:
+            json_file.write(json_data)
+
+        print(f"Experiment results written to '{path}' successfully.")
+
+        class ContextAttributeError(BaseException):
+            def __init__(self, message):
+                self.message = message
+                super().__init__(self.message)
+
+        return True
+    except Exception as e:
+        print(f"Failed to write experiment results to '{path}': {e}")
+        return False
+
+    pass
+