merged researcher and interviewer functionalities

Interviewer.py

@@ -1,105 +0,0 @@
-import gradio as gr
-import time
-import openai
-from dotenv import find_dotenv
-from dev.study_processor import StudyProcessor
-import json
-from dotenv import load_dotenv
-import os
-from pathlib import Path
-from utils.interviewer import Interviewer
-import whisper
-
-
-load_dotenv()
-whisper_model = whisper.load_model("base")
-project_dir = Path(os.environ['PROJECT_DIR'])
-assert project_dir.exists()
-PARTICIPANT_CODES = ["letmetrythis"]
-with open(project_dir / 'study_prompts.json') as sp:
-    DEFINITION_OBJECTIVE_MAP = json.load(sp)
-
-# todo refactor: move this to study processor
-def_objective_keys = DEFINITION_OBJECTIVE_MAP.keys()  # iterate it in whatever order
-DEFINITION_OBJECTIVE_CHOICES_DICT = {k: DEFINITION_OBJECTIVE_MAP[k]['descriptive_name'] for k in def_objective_keys}
-DEFINITION_CHOICES_OBJECTIVE_DICT = {v: k for k, v in DEFINITION_OBJECTIVE_CHOICES_DICT.items()}
-
-
-def add_text(history, text):
-    """
-    Takes in the history and text and updates the history and sets the text input as disabled so it gives
-    the AI time to think
-    :param history:
-    :param text:
-    :return:
-    """
-    history = history + [(text, None)]
-    return history, gr.update(value="")
-
-
-
-
-def bot(history, m_interviewer, to_speak_out=False):
-    m_recent_human_msg = history[-1][0]
-    bot_message = m_interviewer.llm_chain.predict(human_input=m_recent_human_msg)
-    history[-1][1] = ""
-    if not to_speak_out:
-        for character in bot_message:
-            history[-1][1] += character
-            time.sleep(0.005)
-            yield history, m_interviewer, None
-
-
-
-
-def transcribe_audio(m_audio):
-    model_src="openai"
-
-
-    if model_src == "openai":
-        m_audio_f = open(m_audio, 'rb')
-        transcript = openai.Audio.transcribe("whisper-1", m_audio_f, language="en")
-    else:
-        global whisper_model
-        transcript = whisper_model.transcribe(m_audio)
-    text = transcript.get("text", "")
-    return text
-
-with gr.Blocks() as demo:
-    gr.Markdown(f"Welcome to QualZ. I am your friendly A.I. assistant for research. "
-                f"Go through the various tabs to select a topic and start researching! ")
-    # create a study processor class and keep in memory
-    # accordig to gradio documentation this is specific to a user
-    study_processor = gr.State(value=StudyProcessor())  # todo this should refresh each time a new 'study' is selected
-
-
-    gr.Markdown("Welcome to the study titled - Needs and routines for hair-care grooming.  "
-                "My name is Carlie and I am an AI agent who will be conducting this interview. "
-                "If relevant feel free to use audio to talk to me or send me pictures that are relevant. "
-                "Let me know when you are ready to begin by sending saying something below"
-                "If you need to step away or close this sessions, simply click your unique link again.")
-
-    interviewer = gr.State(value=Interviewer())
-    chatbot = gr.Chatbot(label="Ideation Session", elem_id="chatbot", height=750)
-    audio_in = gr.Audio(source="microphone", label="Speak",
-                     type="filepath")
-    txt = gr.Textbox(
-        show_label=False,
-        placeholder="Enter text and press enter, or upload an image",
-        container=False)
-    btn = gr.UploadButton("📁", file_types=["image", "video", "audio"])
-
-
-
-
-
-    txt_msg = txt.submit(add_text, [chatbot, txt],
-                         [chatbot, txt], queue=False).then(bot, [chatbot, interviewer], [chatbot, interviewer])
-
-
-
-
-if __name__ == "__main__":
-    _ = load_dotenv(find_dotenv())
-    openai.api_key = os.getenv('OPENAI_API_KEY')
-    demo.queue(concurrency_count=10).launch(server_port=8850, share=True)

README_interviewer.md

@@ -1,5 +1,5 @@
 ---
 sdk: gradio
 emoji: 📚
-app_file: Interviewer.py
+app_file: app_interviewer.py
 ---

README_researcher.md

@@ -1,5 +1,5 @@
 ---
 sdk: gradio
 emoji: 📚
-app_file: Researcher.py
+app_file: app_researcher.py
 ---

app_interviewer.py

@@ -0,0 +1,225 @@
+import os
+import gradio as gr
+import time
+import openai
+from utils.app_common import *
+from dotenv import load_dotenv, find_dotenv
+from interviewer_utils.interviewer import Interviewer
+from interviewer_utils import voice_controller as vc
+from utils import eleven_voice_cache
+import interviewer_utils.global_variables as global_variables
+from bson import ObjectId
+
+from utils.study_repository import StudyRepository
+from utils.study import Study
+
+from utils.database_helper import DatabaseIO
+
+
+def add_text(history, text):
+    """
+    Takes in the history and text and updates the history and sets the text input as disabled so it gives
+    the AI time to think
+    :param history:
+    :param text:
+    :return:
+    """
+    history = history + [[text, None]]
+    return history, gr.update(value=""), history[-1][-2]
+
+
+# chat_bot reply
+def bot(this_active_study, this_user_id, history, m_interviewer, this_study_repository):
+    """
+
+    :param this_active_study:
+    :param this_user_id:
+    :param history:
+    :param m_interviewer:
+    :param this_study_repository:
+    :return:
+    """
+    this_study_id = this_active_study._id
+    this_human_message = history[-1][0]
+    this_bot_message = m_interviewer.chat_handler.converse(this_human_message)
+    history[-1][1] = this_bot_message
+    this_study_repository.append_to_transcript(study_id=this_study_id,
+                                               user_id=this_user_id,
+                                               human_text=this_human_message,
+                                               ai_response=this_bot_message)
+
+    return history, m_interviewer, history[-1][1]
+
+
+def on_select(evt: gr.SelectData):
+    return evt.value
+
+
+# function to choose subject from dropdown
+def change_study_details(study_id, m_interviewer):
+    """
+
+    Args:
+        study_id:
+        m_interviewer:
+
+    Returns:
+
+    """
+    m_study_dropdown_value = global_variables.study_topic_id[0]
+    global_variables.study_id = ObjectId(study_id)
+    print("Hi", m_study_dropdown_value)
+    m_interviewer.update_llm_prompt(study_subject=m_study_dropdown_value)
+    return m_interviewer
+
+
+def enable_chat():
+    return
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        f"Welcome to your interview session. To Begin, enter your registered email address"
+        f" and the code the study facilitator provided. "
+    )
+
+    gr.Markdown(
+        "If you need to step away or close this sessions, simply come back here "
+        "and enter the details again to continue"
+    )
+
+    # initializing the Interviewer object and creating a state variable for the session
+
+    view_study_repository = gr.State(value=StudyRepository(collection_name_studies=STUDIES_COLLECTION))
+    # existing_studies_dropdown_choices = get_dropdown_choices()
+    view_active_study = gr.State(value=None)
+    # field to hold the user_id, will refactor this for a user object with a factory pattern todo
+    view_user_id = gr.Text(value="", interactive=False, visible=False)
+
+    view_interviewer = gr.State(value=None)  # will set the interviewer along with details
+
+    # initializing transcripts for rendering in 2d list form
+    rendering_transcript = gr.State()
+
+    # subject id and user email validation form field
+    status = gr.Textbox(interactive=False, label="System messages will appear here")
+
+    with gr.Row():
+        user_email = gr.Textbox(label="Enter email", min_width=50)
+        study_code = gr.Textbox(label="Enter Code", min_width=50)
+
+    study_and_user_select_btn = gr.Button(value="Submit", min_width=50)
+
+    # interface for the chatbot
+    chatbot = gr.Chatbot(label="Ideation Session", elem_id="chatbot", height=750)
+
+    txt = gr.Textbox(
+        show_label=False,
+        placeholder="Enter text and press enter, or upload an image",
+        container=False,
+        interactive=False,  # when button is clicke it should be true
+    )
+
+    with gr.Row():
+        # integrating the feature upload document
+        upload_files_btn = gr.UploadButton("📁", file_types=["image", "video", "audio"], interactive=False)
+
+    # adjusting the row columns
+    with gr.Row():
+        # the audio features
+        audio = gr.Audio(source="microphone", type="filepath", label="Audio input", interactive=False)
+
+        # radio indicator to control the AI voice response
+        voice_response_radio = gr.Radio(
+            ["On", "Off"],
+            label="Voice Setting",
+            interactive=False,
+            value="Off",
+            info="Turn on or off voice system",
+        )
+
+        voice_persona_dropdown = gr.Dropdown(
+            choices=[
+                eleven_voice_cache.VOICES_CACHE[i].name
+                for i in range(len(eleven_voice_cache.VOICES_CACHE))
+            ],
+            label="choose the voice over",
+            interactive=False,
+            value="Rachel",
+        )
+
+        study_and_user_select_btn.click(set_user_and_study,
+                                        inputs=[view_study_repository,
+                                                study_code,
+                                                user_email,
+                                                ],
+                                        outputs=[view_active_study, view_user_id, status,
+                                                 txt, upload_files_btn,
+                                                 audio, voice_response_radio, voice_persona_dropdown],
+                                        queue=False).then(
+            setup_conversation_context,
+            inputs=[
+                view_active_study,
+                view_study_repository,
+                view_user_id,
+            ],
+            outputs=[
+                chatbot,
+                view_interviewer,
+                status
+            ],
+            queue=False
+        )
+
+        # call dropdown from function
+        voice_response_radio.select(on_select, None, voice_response_radio)
+        voice_persona_dropdown.select(on_select, None, voice_persona_dropdown)
+
+        # audio output with transcript initialization
+        audio_response_output = gr.Audio(label="Audio Output", autoplay=True)
+
+        audio_message_transcription = gr.Textbox(visible=False)
+        msg_response_from_AI = gr.Textbox(visible=False)
+
+        # human transcript to sent to database used in db function
+        human_transcript_to_db = gr.State(value="")
+
+        # on stop recording functionality
+        audio.stop_recording(
+            fn=vc.speech_to_text,
+            inputs=[audio],
+            outputs=[audio_message_transcription],
+        ).then(
+            add_text,
+            [chatbot, audio_message_transcription],
+            [chatbot, audio_message_transcription, human_transcript_to_db],
+        ).then(
+            bot,
+            inputs=[view_active_study, view_user_id, chatbot, view_interviewer, view_study_repository],
+            # try to add interview instant
+            outputs=[chatbot, view_interviewer, msg_response_from_AI],
+        ).then(
+            fn=vc.text_to_speech,
+            inputs=[
+                msg_response_from_AI,
+                voice_response_radio,
+                voice_persona_dropdown,
+            ],
+            outputs=[audio_response_output],
+        )
+
+    # on pressing enter functionalities while sending chat
+    txt.submit(
+        add_text, [chatbot, txt], [chatbot, txt, human_transcript_to_db], queue=True
+    ).then(
+        bot,
+        inputs=[view_active_study, view_user_id, chatbot, view_interviewer, view_study_repository],
+        outputs=[chatbot, view_interviewer, msg_response_from_AI],
+        queue=True,
+    )
+
+# running the main file
+if __name__ == "__main__":
+    _ = load_dotenv(find_dotenv())
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    demo.queue(concurrency_count=10).launch(server_port=8850, share=False, debug=True)

Researcher.py → app_researcher.py

@@ -2,19 +2,19 @@ import gradio as gr
 import openai
 from dotenv import find_dotenv
 # from utils.study_processor import StudyProcessor
-from typing import List
 import json
 from dotenv import load_dotenv
 import os
 from pathlib import Path
 from utils.study_repository import StudyRepository
 from utils.study import Study
+from utils.app_common import * # common functions for both apps
 import hashlib
-from utils.eleven_voice_cache import VOICES_CACHE
-from utils.interviewer_persona import AI_PERSONALITIES
+from interviewer_utils.interviewer_persona import AI_PERSONALITIES
 from utils.database_helper import DatabaseIO
 import bcrypt
 import pymongo
+import pymongo.errors
 load_dotenv()
 
 USER_ID = os.environ["DEV_USER_ID"]
@@ -73,7 +73,7 @@ FRAMEWORK_CHOICES = {
 def check_credentials(username, password):
 
     try:
-        with DatabaseIO(collection_name="Users") as db_io:
+        with DatabaseIO(collection_name=INTERVIEW_USERS_COLLECTION) as db_io:
             user_collection = db_io.collection
             user = user_collection.find_one({"username": username})
             if user is not None:
@@ -183,17 +183,7 @@ def guess_study_objective(study_access_obj,
         return study_access_obj, study_objective, study_reasoning
 
 
-def set_active_study(this_study_repository,
-                     active_study_obj,
-                     study_id):
-    study_id = study_id.split(':')[0]
-    this_study = this_study_repository.get_studies(study_id=study_id)
-    if type(this_study) == list and len(this_study):
-        this_study = this_study[0]
-    # initialize a new study with this study in memory!
-    active_study_obj = Study(**this_study)
 
-    return active_study_obj, ""
 
 def start_synthetic_interviews(this_study_obj):
     if not this_study_obj:
@@ -339,8 +329,10 @@ def show_existing_study_fields(this_study_obj):
          'Reason': "",
          'Discussion': ""})
 
-    return this_study_obj, this_study_obj._id, this_study_obj.study_descriptive_name, this_study_obj.study_topic, this_study_obj.study_objective, \
-        this_study_obj.study_framework, this_study_obj.research_questions, this_study_obj.interview_guidelines, this_synthetic_panel_markdown, ""
+    return this_study_obj, this_study_obj._id, this_study_obj.study_descriptive_name, this_study_obj.study_topic,\
+        this_study_obj.study_objective, \
+        this_study_obj.study_framework, this_study_obj.research_questions, this_study_obj.interview_guidelines, \
+        this_synthetic_panel_markdown, ""
 
 
 def get_dropdown_choices(dropdown_choices_study_repository_obj=None):
@@ -585,7 +577,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                                       outputs=[existing_status_update])
     study_choice_dropdown.select(set_active_study,
                                  inputs=[view_study_repository,
-                                         view_active_study,
                                          study_choice_dropdown],
                                  outputs=[view_active_study, existing_status_update], queue=False).then(
         show_existing_study_fields,

dev/voiceover.ipynb

@@ -1,34 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [],
-   "metadata": {
-    "collapsed": false
-   }
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

interviewer_utils/data_process.py

@@ -0,0 +1,189 @@
+from utils.database_helper import DatabaseIO
+import os
+import dotenv
+from bson import ObjectId
+import interviewer_utils.global_variables as global_variables
+from interviewer_utils.interviewer import Interviewer
+
+
+dotenv.load_dotenv()
+# dev_user_id = os.environ["DEV_USER_ID"]
+
+
+class DataProcess:
+    # validate weather the data exist or not
+    def get_existing_data(must_have_keys: []):
+        # create the query
+        query = (
+            {key: {"$exists": True} for key in must_have_keys} if must_have_keys else {}
+        )
+        print(query)
+        results = []
+
+        # query the collection
+        results = DatabaseIO.read_documents(DatabaseIO(), query=query)
+        results = list(results)
+        # convert results to a list (if the result set is too large, consider returning a cursor instead)
+        return results
+
+    # for getting study topic from base to dropdown
+    # def get_dropdown_choices():
+    #     existing_studies = DataProcess.get_existing_data(
+    #         must_have_keys=["_id", "study_name"]
+    #     )
+    #     _ids = [st["_id"] for st in existing_studies]
+    #     _descriptions = [st["study_name"] for st in existing_studies]
+    #     global_variables.study_topic_id.append(_ids)
+    #     global_variables.study_topic_id.append(_descriptions)
+    #     return [desc for desc in _descriptions]
+
+    # fetch user_id information
+    def get_set_user_information(object_id, AI_interviewer):
+        existing_users = DatabaseIO.read_documents(
+            DatabaseIO(collection_name="Users"), {"_id": global_variables.User_id}
+        )
+        existing_users = list(existing_users)
+
+        User_info = [
+            {
+                "AI_interviewer": AI_interviewer,
+                "Human_Respondent": {
+                    "participant_id": global_variables.User_id,
+                    "email": existing_users[0]["email"],
+                    "age": 22,
+                    "gender": "Male",
+                    "Profession": "Retail Worker",
+                },
+                "transcript": [],
+            }
+        ]
+
+        user = DatabaseIO.insert_document(
+            DatabaseIO(collection_name="Post_Get_Transmission"),
+            article=User_info[0],
+            embedded_table_validation="interviews.human_interviews.Human_Respondent.participant_id",
+            unique_field=global_variables.User_id,
+            unique_id=global_variables.study_id,
+            target_table_insertion=User_info,
+            embedded_table_insertion="interviews.human_interviews",
+            loop_times=1,
+        )
+        return user
+
+    # a function to insert transcript data from interviewer
+    def insert_conversation_transcripts(text, ai_response):
+        transcript_json = [
+            {
+                "turn": "Human",
+                "text": text,
+            },
+            {
+                "turn": "AI",
+                "text": ai_response,
+            },
+        ]
+        conversational_transcripts = DatabaseIO.insert_transcript_document(
+            DatabaseIO(collection_name="Post_Get_Transmission"),
+            article=transcript_json,
+            loop_times=2,
+            embedded_table_validation="interviews.human_interviews.Human_Respondent.participant_id",
+            unique_field=global_variables.User_id,
+            unique_id=global_variables.study_id,
+            target_table_insertion=transcript_json,
+            embedded_table_insertion="interviews.human_interviews.$.transcript",
+        )
+        return conversational_transcripts
+
+    # get transcripts of specfici study of specific user
+    def get_transcripts_of_user():
+        existing_document = DatabaseIO.read_transcripts(
+            DatabaseIO(),
+            query={
+                "_id": global_variables.study_id,
+                "interviews.human_interviews.Human_Respondent.participant_id": global_variables.User_id,
+            },
+        )
+        existing_document = list(existing_document)
+        exisitng_transcripts = existing_document[0]["interviews"]["human_interviews"][
+            0
+        ]["transcript"]
+        return exisitng_transcripts
+
+    # chaning json format into list
+    def changing_json_list(self):
+        exisitng_transcripts = DataProcess.get_transcripts_of_user()
+        combined_messages = []
+        text_list = []
+
+        try:
+            for item in exisitng_transcripts:
+                if item["turn"] == "Human":
+                    if text_list:
+                        combined_messages.append(text_list)
+                    text_list = [item["text"]]
+                elif item["turn"] == "AI":
+                    text_list.append(item["text"])
+
+            if text_list:
+                combined_messages.append(text_list)
+            return combined_messages
+        except:
+            print("No interview conversation initiated")
+
+    # function to convert into memory storage format
+    def convert_to_memory_chain_context(m_interviewer):
+        transcripts = DataProcess.get_transcripts_of_user()
+        result = []
+        conversation = []
+
+        for index, entry in enumerate(transcripts):
+            turn = entry["turn"]
+            text = entry["text"]
+
+            if index == 0 or turn == "Human":
+                if conversation:
+                    result.append(conversation)
+                conversation = []
+            conversation.append({turn: text})
+
+        if conversation:
+            result.append(conversation)
+
+        # loading the context by calling memory function
+        m_interviewer.set_memory_chain(scripts=result, m_interviewer=m_interviewer)
+
+        return "done"
+
+    # function to read user information
+    def read_useremail(user_email):
+        existing_user = DatabaseIO.read_documents(
+            DatabaseIO(collection_name="Users"),
+            query={"email": user_email},
+        )
+        existing_user = list(existing_user)
+        global_variables.User_id = existing_user[0]["_id"]
+        print(global_variables.User_id, type(global_variables.User_id))
+        return existing_user
+
+    # function to read study information
+    def read_study(study_code):
+        existing_study = DatabaseIO.read_documents(
+            DatabaseIO(),
+            query={"_id": study_code},
+        )
+        existing_study = list(existing_study)
+        global_variables.study_topic_id.append(existing_study[0]["study_name"])
+        print(global_variables.study_topic_id[0])
+        return existing_study
+
+    # function to validate both study and user
+    def validating_studycode_user(study_code, user_email):
+        if study_code == None or user_email == None:
+            return False
+        else:
+            existing_user = DataProcess.read_useremail(user_email)
+            existing_study = DataProcess.read_study(study_code)
+            if existing_study == [] or existing_user == []:
+                return False
+            else:
+                return True

interviewer_utils/global_variables.py

@@ -0,0 +1,4 @@
+study_id = None
+study_topic_id = []
+User_id = None
+Count = "a"

interviewer_utils/interview_llm_helper.py

@@ -0,0 +1,106 @@
+from langchain.schema import SystemMessage, HumanMessage
+from langchain.chat_models import ChatOpenAI
+import ast
+import warnings
+from pathlib import Path
+import os, json
+from ra_utils.synthetic_panel_datamodel import parse_synthetic_panel_output
+from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory
+from langchain import LLMChain
+from langchain.chains import ConversationChain
+from langchain.schema import AIMessage, HumanMessage
+from langchain.memory.chat_memory import ChatMessageHistory
+from langchain.prompts import PromptTemplate
+
+
+class InterviewLLMHandler:
+    def __init__(self,
+                 llm_model_name: str = 'gpt-3.5-turbo-16k',
+                 llm_temperature: float = 0.2,
+                 expertise_message: str = "",
+                 research_topic: str = "",
+                 research_objectives: str = "",
+                 research_questions: str = "",
+                 interview_guidelines: str = "",
+                 verbose: bool = False,
+                 existing_conversation_history=None
+                 ):
+
+        self.llm = ChatOpenAI(temperature=llm_temperature, model_name=llm_model_name)
+
+        project_dir = Path(os.environ['PROJECT_DIR'])
+        assert project_dir.exists()
+        with open(project_dir / 'study_prompts.json') as sp:
+            self.definition_objective_maps = json.load(sp)
+
+        if not len(expertise_message):
+            expertise_message = f"Assistant is a world renowned expert in conducting qualitative research."
+
+        self.expertise_message = expertise_message
+
+        self.setup_message = f"Assistant is conducting a qualitative interview, for which the details will " \
+                             f"be given below. It is very important that assistant assume the role of an impartial" \
+                             f"qualitative researcher. IF any questions from the user does not pertain to the study" \
+                             f"assistant will move on the next question. Assistant will not ask leading questions " \
+                             f"and will never respond in a toxic way. If any response is needed about large language" \
+                             f"model capabilities , assistant will say, that is beyond the scope of this conversation" \
+                             f"lets move on to the next question and continue the conversation."
+        self.study_specific_message = f"""The description and the details of the study are below. The actual details 
+        of the study is below within triple backticks after the description of the details.   
+        The topic of research is: ```{research_topic}```. 
+        The RESEARCH OBJECTIVES i.e. The overarching goal of the study: ```{research_objectives}```. 
+        The RESEARCH QUESTIONS i.e. A few questions the researcher wants answered are: ```{research_questions}```.
+        The INTERVIEW GUIDELINES i.e. a set of reference questions to get answers for are :```{interview_guidelines}```.
+Here are some things to focus on:
+Rapport Building: Begin by explaining the interview's purpose and ensuring confidentiality. 
+Encourage candidness with no right or wrong answers.
+Guided Conversation: Use the  as anchor points, but don't read verbatim. 
+Initiate with broad questions and narrow down as the conversation evolves.
+Active Listening: Be attentive. Seek deeper understanding through probing and spontaneous follow-up queries. 
+Always align with the study's objectives.
+Concluding: Summarize the main insights, allow for participant's added input, and thank them.
+        """
+        self.interview_system_template = self.expertise_message + " " + self.setup_message \
+                                         + self.study_specific_message + """
+        When responding, asking questions or followups, you should remember the current conversation where you
+         are the AI and the participant is the human. 
+            Current conversation:
+            {history}
+            Human: {input}
+            AI Assistant: 
+                    """
+        self.interview_system_prompt = PromptTemplate(
+            input_variables=["history", "input"], template=self.interview_system_template
+        )
+        self.interview_memory = ConversationBufferWindowMemory(ai_prefix="AI Assistant")
+
+        if existing_conversation_history and len(existing_conversation_history):
+            self.set_memory_with_history(existing_conversation_history)
+        else:
+            self.interview_memory = ConversationBufferWindowMemory(ai_prefix="AI Assistant")
+
+        self.interview_chain = ConversationChain(
+            llm=self.llm,
+            verbose=verbose,
+            memory=self.interview_memory,
+            prompt=self.interview_system_prompt
+        )
+
+    def converse(self, message: str = ""):
+        return self.interview_chain.predict(input=message)
+
+    def set_memory_with_history(self, history):
+        """
+        Takes a history object with a list of conversation and resets the memory
+        :param history:
+        :return:
+        """
+        retrieved_messages = \
+            [AIMessage(content=entry['text']) if entry['turn'] == 'AI'
+             else HumanMessage(content=entry['text']) for entry in
+         history]
+
+        retrieved_chat_history = ChatMessageHistory(messages=retrieved_messages)
+        self.interview_memory = ConversationBufferWindowMemory(ai_prefix="AI Assistant",
+                                                               chat_memory=retrieved_chat_history)
+

interviewer_utils/interviewer.py

@@ -0,0 +1,69 @@
+from typing import List
+
+from langchain import LLMChain, PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from interviewer_utils import interviewer_persona
+from interviewer_utils.interview_llm_helper import InterviewLLMHandler
+
+
+class Interviewer:
+    def __init__(
+            self,
+            llm_temperature: float = 0.4,  # going for some amount of creativity
+            llm_model_name="gpt-3.5-turbo-16k",
+            persona: str = "Rachel",
+            research_topic: str = "",
+            research_objectives: str = "",
+            research_questions: str = "",
+            interview_guidelines: str = "",
+            existing_conversation_history=List[List[str]]
+
+    ):
+        interviewer_personas = interviewer_persona.AI_PERSONALITIES
+        self.interviewer_persona = interviewer_personas.get(persona, "Rachel")
+        self.chat_handler = InterviewLLMHandler(
+            llm_model_name=llm_model_name,
+            llm_temperature=llm_temperature,
+            research_topic=research_topic,
+            research_objectives=research_objectives,
+            research_questions=research_questions,
+            interview_guidelines=interview_guidelines,
+            existing_conversation_history=existing_conversation_history
+        )
+
+    def update_llm_prompt(self, study_subject):
+        print("After : ", study_subject)
+        # update prompt on dropdown selection
+        self.study_subject = study_subject
+        self.system_template = """ You are an expert in  %s. You are a qualitative researcher.
+        You are conducting an interview in this topic %s. Please create rapport and ask me some questions
+        related to the topic. You should ask follow-up questions if necessary. Questions should be open ended.
+        
+        {history}
+        {human_input}
+        
+        AI: """ % (
+            self.study_subject,
+            self.study_subject,
+        )
+
+        self.system_prompt = PromptTemplate(
+            input_variables=["history", "human_input"], template=self.system_template
+        )
+        self.llm_chain = LLMChain(
+            llm=self.llm,
+            prompt=self.system_prompt,
+            verbose=False,
+            memory=self.memory,
+        )
+
+    # feeding stored scripts in memory so that AI can remember the previous conversation
+    def set_memory_chain(self, scripts, m_interviewer):
+        # not sure why is happening here
+        # need to load the history parse it and then load as history object
+        # https://stackoverflow.com/questions/75965605/how-to-persist-langchain-conversation-memory-save-and-load
+        for i in scripts:
+            self.memory.save_context(i[0], i[1])
+        response = m_interviewer.llm_chain.predict(human_input="what was my name?")
+        print(response)
+        return response

interviewer_utils/voice_controller.py

@@ -0,0 +1,78 @@
+import gradio as gr
+import openai
+import os, requests
+import dotenv
+from utils import eleven_voice_cache
+
+
+dotenv.load_dotenv()
+
+eleven_labs_API = os.getenv("ELEVENLABS_API")
+
+messages = []
+
+
+def speech_to_text(audio):
+    """
+    takes an audio file and returns a transcription
+    Args:
+        audio:
+    Return
+    """
+
+    # reading audio file
+    audio_file = open(audio, "rb")
+
+    # converting audio into text through "whisper"
+    transcript = openai.Audio.transcribe("whisper-1", audio_file)
+
+    # append the messages
+    messages.append({"role": "user", "content": transcript["text"]})
+
+    return transcript["text"]
+
+
+# function to convert speech to text
+def text_to_speech(audio_transcription, radio_value, audio_voice_persona):
+    """
+    take converted transcription from the function speech to text,
+    checks the radio_value to control the voice response
+    select the voice over persona
+    use elvenlabs to convert to audio
+    send the response to"""
+    # voice over selection id
+    for voice in eleven_voice_cache.VOICES_CACHE:
+        if voice.name == audio_voice_persona:
+            voice_over_id = voice.voice_id
+
+    # using chatGpt response system
+    # response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=messages)
+    # r = Interviewer(llm_model_name="gpt-3.5-turbo-16k")
+    # response = r.llm_chain.predict(human_input=audio_transcription)
+    response = audio_transcription
+    print(response)
+    # storing system message
+    # system_message = response["choices"][0]["message"]["content"]
+
+    # append the message
+    messages.append({"role": "assistant", "content": response})
+
+    if radio_value == "On":
+        # text to speech using elevenlabs
+        url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_over_id}/stream"
+        data = {
+            "text": response,
+            "voice_settings": {"stability": 0.1, "similarity_boost": 0.8},
+        }
+
+        elevenlabs_response = requests.post(
+            url, headers={"xi-api-key": eleven_labs_API}, json=data, stream=True
+        )
+
+        output_filename = "buddy.mp3"
+        with open(output_filename, "wb") as output:
+            output.write(elevenlabs_response.content)
+
+        return output_filename
+    else:
+        return None

notebooks/modify_schema.ipynb

@@ -0,0 +1,104 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2023-08-27T23:03:35.706464200Z",
+     "start_time": "2023-08-27T23:03:35.692464300Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from utils.database_helper import DatabaseIO\n",
+    "from pymongo import MongoClient\n",
+    "from bson import ObjectId"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Updates completed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "with DatabaseIO(collection_name=\"Studies_v02\") as db_io:\n",
+    "    for document in db_io.collection.find():\n",
+    "        new_human_interviews = {}\n",
+    "        new_synthetic_interviews = {}\n",
+    "\n",
+    "        # Process the 'human_interviews' list\n",
+    "        for interview in document['interviews'].get('human_interviews', []):\n",
+    "            participant_id = str(interview['Human_Respondent']['participant_id'])\n",
+    "            new_human_interviews[participant_id] = interview\n",
+    "\n",
+    "        # Process the 'synthetic_interviews' list\n",
+    "        for interview in document['interviews'].get('synthetic_interviews', []):\n",
+    "            new_id = str(ObjectId())  # Generate a new unique ObjectId\n",
+    "            new_synthetic_interviews[new_id] = interview\n",
+    "\n",
+    "        # Update the fields with the new structures\n",
+    "        updates = {}\n",
+    "        if new_human_interviews:\n",
+    "            updates['interviews.human_interviews'] = new_human_interviews\n",
+    "        if new_synthetic_interviews:\n",
+    "            updates['interviews.synthetic_interviews'] = new_synthetic_interviews\n",
+    "\n",
+    "        if updates:\n",
+    "            db_io.collection.update_one(\n",
+    "                {'_id': document['_id']},\n",
+    "                {'$set': updates}\n",
+    "            )\n",
+    "\n",
+    "print(\"Updates completed!\")\n",
+    "\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-28T00:06:10.976700800Z",
+     "start_time": "2023-08-28T00:06:10.425108Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

utils/app_common.py

@@ -0,0 +1,201 @@
+import re
+from bson import ObjectId
+from dotenv import load_dotenv
+import os
+from interviewer_utils.interviewer import Interviewer
+from utils.study import Study
+from utils.study_repository import StudyRepository
+from typing import Union, List
+from utils.database_helper import DatabaseIO
+import gradio as gr
+
+load_dotenv()
+INTERVIEW_USERS_COLLECTION = os.environ['MONGO_COLLECTION_USERS']
+RESEARCHER_USERS_COLLECTION = os.environ['MONGO_COLLECTION_USERS']
+STUDIES_COLLECTION = os.environ['MONGO_COLLECTION_STUDIES']
+
+
+def is_valid_email(email):
+    # Simple regex pattern for email validation
+    pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+    return bool(re.match(pattern, email))
+
+
+def set_active_study(this_study_repository,
+                     study_id):
+    """
+    Using a repository object creates a study object for the given id
+    returns the study object and a status message
+    """
+
+    study_id = study_id.split(':')[0]
+    this_study = this_study_repository.get_studies(study_id=study_id)
+
+    if not this_study:
+        return {}
+
+    if type(this_study) == list and len(this_study):
+        this_study = this_study[0]
+
+    # initialize a new study with this study in memory!
+    try:
+        # study validation is here! if db schema is older, will be notified during dev
+        active_study_obj = Study(**this_study)
+    except Exception as e:
+        return None, f"Study not found due to {e}"
+
+    return active_study_obj, ""
+
+
+def configure_interviewer(this_interviewer: Interviewer,
+                          this_study_obj: Study,
+                          history: List[List[str]]):
+    """
+    takes an existing interviewer object and initializes it with details from the provided study object
+
+    :param history:
+    :param this_interviewer:
+    :param this_study_obj:
+    :return: interviewer object with the right initializations
+    """
+    this_status = "Successfully configured interviewer object"
+
+    if this_study_obj is None or type(this_study_obj) != Study:
+        this_status = "The research study you are participating in does not" \
+                      " exist or is not ready, please contact the researcher"
+
+    # if this study has
+
+    return this_interviewer, this_status
+
+
+def lookup_userid_by_email(email):
+    """
+    Looks up email address and finds the right user and returns the user_id
+    :param email:
+    :return:
+    """
+    if email is None or not is_valid_email(email):
+        return None, "Try with a valid email please!"
+
+    with DatabaseIO(collection_name=INTERVIEW_USERS_COLLECTION) as db_io:
+        user = db_io.collection.find_one({"email": email}, {"_id": 1})
+        if user:
+            return str(user["_id"]), "Found correct user"
+        else:
+            return None, "Error finding user"
+
+
+def process_transcript_to_chatbot_history(this_transcript):
+    messages_in_chatbot_format = []
+    for i in range(0, len(this_transcript), 2):
+        human_turn = this_transcript[i]['text']
+        ai_turn = this_transcript[i + 1]['text']
+        messages_in_chatbot_format.append([human_turn, ai_turn])
+    return messages_in_chatbot_format
+
+
+def set_user_and_study(
+        this_study_repository,
+        this_study_code,
+        this_user_email,
+
+):
+    this_user_id, user_exists_message = lookup_userid_by_email(this_user_email)
+
+    interaction_disabled = gr.update(interactive=False)
+    interaction_enabled = gr.update(interactive=True)
+
+    if not this_user_id or not len(this_user_id):
+        this_return_message = user_exists_message
+        return None, "", this_return_message, *([interaction_disabled] * 5)
+
+    this_active_study, study_exists_message = set_active_study(this_study_repository, study_id=str(this_study_code))
+    if not this_active_study:
+        this_return_message = study_exists_message
+        return None, this_user_id, this_return_message, *([interaction_disabled] * 5)
+    this_return_message = user_exists_message + " " + study_exists_message
+
+    return this_active_study, this_user_id, this_return_message, *([interaction_enabled] * 5)
+
+
+def setup_conversation_context(this_active_study, this_study_repository, this_user_id):
+    """
+    Populates the interview object
+    :param this_active_study:
+    :param this_user_id:
+    :return:
+    """
+    this_transcript = load_previous_transcript(this_active_study,
+                                                         this_user_id,
+                                                         this_study_repository)
+    this_user_id_str = str(this_user_id)
+    this_interviewer = Interviewer(
+        research_topic=this_active_study.study_topic,
+        research_objectives=this_active_study.study_objective,
+        research_questions=this_active_study.research_questions,
+        interview_guidelines=this_active_study.interview_guidelines,
+        existing_conversation_history=this_transcript
+    )
+
+    if not this_transcript or not len(this_transcript):
+        # no previous conversation
+        ai_response = this_interviewer.chat_handler.converse('Hello')
+        this_constructed_transcript = [{'turn': 'Human', 'text': 'Hello'}, {'turn': 'AI', 'text': ai_response}]
+        # transcript did not exist, so must create the user info in database
+
+        this_view_chat_history = process_transcript_to_chatbot_history(this_constructed_transcript)
+        #
+        if 'human_interviews' not in this_active_study.interviews or not this_active_study.interviews['human_interviews']:
+            this_active_study.interviews['human_interviews'] = {}
+        this_previous_interview = this_active_study.interviews['human_interviews'].get(this_user_id)
+        # If not found, initialize an empty one
+        if not this_previous_interview:
+            this_previous_interview = {
+                "AI_interviewer": "Sophia (AI Researcher)",
+                "Human_Respondent": {
+                    "participant_id": this_user_id_str
+                },
+                "transcript": []
+            }
+            this_active_study.interviews['human_interviews'][this_user_id_str] = this_previous_interview
+        this_active_study.interviews['human_interviews'][str(this_user_id)]['transcript'] = this_constructed_transcript
+        this_study_repository.update_study(study_id=this_active_study._id, updated_data=this_active_study.to_dict())
+        this_message = "First time talking to you ... "
+    else:
+        this_view_chat_history = process_transcript_to_chatbot_history(this_transcript)
+        this_message = "Welcome back, lets start where we left off!"
+
+    return this_view_chat_history, this_interviewer, this_message
+
+
+def load_previous_transcript(this_study: Study,
+                             this_user_id: Union[ObjectId | str],
+                             this_study_repository: StudyRepository):
+    """
+    loads existing interview
+    :param this_study:
+    :param this_user_id:
+    :param this_study_repository
+    :return:
+    """
+    this_user_id_str = str(this_user_id)
+
+    # Ensure 'human_interviews' exists and is initialized properly
+
+    try:
+        # Try to get the interview of the participant
+        human_interviews = this_study.interviews['human_interviews']
+        this_previous_interview = human_interviews.get(this_user_id_str, None)
+        return this_previous_interview['transcript']
+
+    except (AttributeError, KeyError, Exception) as ae:
+        return []
+
+
+if __name__ == "__main__":
+    # unit tests
+    study_repository = StudyRepository(collection_name_studies=STUDIES_COLLECTION)
+    sample_study_id = "64dc833a12e518bb5d4ea2b4"
+    sample_email = "paudyalprajwal@qualz.net"
+    interviewer = Interviewer(existing_conversation_history=['a', 'b'])

utils/llm_helper.py

@@ -1,13 +1,12 @@
+from langchain.schema import SystemMessage, HumanMessage
 from langchain.chat_models import ChatOpenAI
-from langchain.prompts.chat import ChatMessage
-from langchain.schema import SystemMessage, HumanMessage, AIMessage
-from langchain.chat_models import ChatOpenAI
-from langchain.prompts.chat import ChatMessage
 import ast
 import warnings
 from pathlib import Path
 import os, json
-from utils.synthetic_panel_datamodel import SyntheticPanelOutput, parse_synthetic_panel_output
+from ra_utils.synthetic_panel_datamodel import parse_synthetic_panel_output
+from langchain.memory import ConversationBufferMemory
+from langchain import LLMChain
 
 class LLMChatHandler:
     def __init__(self,
@@ -16,6 +15,7 @@ class LLMChatHandler:
                  expertise_message: str = ""):
         self.llm = ChatOpenAI(temperature=temperature, model_name=llm_model_name)
 
+
         project_dir = Path(os.environ['PROJECT_DIR'])
         assert project_dir.exists()
         with open(project_dir / 'study_prompts.json') as sp:
@@ -24,13 +24,16 @@ class LLMChatHandler:
         if not len(expertise_message):
             expertise_message = f"Assistant is a world renowned expert in qualitative research." \
                                 f" Assistant is well known in your field worldwide and has published several books " \
-                                f"and whitepapers. Assistant is also an expert qualitative research analyst " \
+                                f"and white-papers. Assistant is also an expert qualitative research analyst " \
                                 f"who is thorough and methodical."
         self.expertise_message = expertise_message
 
+
+
     def predict(self, messages):
         return self.llm.predict_messages(messages)
 
+
     def guess_research_questions(self,
                                  research_name: str,
                                  research_topic: str,

utils/study.py

@@ -45,7 +45,8 @@ class Study:
         self.additional_fields = kwargs
         self.chat_handler = LLMChatHandler()
 
-        self.synthetic_panel_pending_interviews = synthetic_panel_pending_interviews if synthetic_panel_pending_interviews else []
+        self.synthetic_panel_pending_interviews = synthetic_panel_pending_interviews if\
+            synthetic_panel_pending_interviews else []
         # Check if synthetic_interviews exists and is not empty
         # if 'synthetic_interviews' in self.interviews and len(self.interviews.get('synthetic_interviews', "")):
         #     # Extract AI_Respondent from each item in synthetic_interviews and append to self.synthetic_panelists

utils/study_repository.py

@@ -1,19 +1,14 @@
 import dotenv
 
-import os, sys
+import os
 
-from typing import Dict, Optional, List, Any, Tuple, Mapping
-import pymongo
-from pymongo.errors import PyMongoError
-from pymongo.server_api import ServerApi
+from typing import Optional, List, Tuple
 from typing import Dict, Any
 from utils.study import Study
 from utils.database_helper import DatabaseIO
 from bson import ObjectId
 from typing import Union
-from utils.synthetic_panel_datamodel import SyntheticPanelOutput
 
-import ast
 from utils.llm_helper import LLMChatHandler
 
 
@@ -65,6 +60,44 @@ class StudyRepository:
             study_id = db_io.collection.insert_one(study_data).inserted_id
             return study_id
 
+    def append_to_transcript(self, study_id, user_id, human_text, ai_response):
+        """
+        Append the recent conversation to the transcript in the database.
+
+        :param db_url: MongoDB database URL.
+        :param db_name: Name of the MongoDB database.
+        :param collection_name: Name of the collection storing the transcripts.
+        :param participant_id: ID of the participant for whom the transcript is being updated.
+        :param human_text: The text/message from the human.
+        :param ai_response: The response from the AI.
+        """
+
+        # Initialize the MongoDB client and select the database and collection
+        user_id = str(user_id)
+        # Define the conversation entries to be appended
+        new_entries = [
+            {
+                "turn": "Human",
+                "text": human_text,
+            },
+            {
+                "turn": "AI",
+                "text": ai_response,
+            }
+        ]
+
+        # Append new entries to the transcript
+        with DatabaseIO(collection_name=self.collection_name_studies) as db_io:
+            query = {"_id": ObjectId(study_id)}
+
+            # Append new entries to the transcript using a dynamic field update
+            update_field = f"interviews.human_interviews.{user_id}.transcript"
+            update_action = {"$push": {update_field: {"$each": new_entries}}}
+
+            # Execute the update
+            db_io.collection.update_one(query, update_action)
+
+
     def get_studies(self,
                     study_id: Optional[str] = None,
                     user_id: Optional[str] = None,
@@ -79,13 +112,12 @@ class StudyRepository:
         :return: The studies or a specific study data, or a tuple with a message if an error occurs.
         """
 
-        # If study_id is provided, return just that study.
         if study_id:
             study_id = ObjectId(study_id)
             with DatabaseIO(db_name=self.db_name, collection_name=self.collection_name_studies) as db_io:
                 study = db_io.collection.find_one({"_id": study_id})
                 if not study:
-                    return {}, "Study not found."
+                    return {}
                 return study
 
         # If user_id is provided and filter is desired, return studies the user is authorized to view.
@@ -154,6 +186,7 @@ class StudyRepository:
 
         return return_msg
 
+
     def delete_study(self, study_id: str):
         """
         Delete a study by its ID.