Upload 9 files

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,3 +1,72 @@
----
-license: apache-2.0
----
+<img src="appendix/icon.jpeg" width="100" alt="alt text">
+
+# AI Clinical Psychologist Interviewer 𝚿
+
+**AI Clinical Psychologist Interviewer** is an AI platform designed to simulate clinical interviews. It leverages NLP and speech technologies to emulate a clinical psychologist, offering insightful assessments and generating detailed clinical reports. 
+
+This platform is ideal for educational, research, and preliminary assessment purposes but should not replace professional medical advice.
+
+Use the hosted demo: [AI Clinical Psychologist Interviewer Demo](https://huggingface.co/spaces/reab5555/AI-Clinical-Psychologist-Interviewer)
+
+## Features
+
+**Key Features**:
+- **Simulated Interviews**: Conducts interviews with focused clinically relevant questions.
+- **Natural Language Processing**: Understands and generates contextually relevant questions.
+- **LangChain**: Create NLP chains for interview and report generation.
+- **Audio Interaction**: Voice conversation simulation where the user can talk to the bot in a way that simulates real conversation or evidence.
+- **Report Generation**: Automatically creates comprehensive clinical reports after each session.
+- **Document Upload for Reports**: Generates reports from uploaded TXT, PDF, or DOCX files.
+- **Multi-language Support**: Conducts interviews and generates reports in the user's preferred language.
+- **Selectable Interviewers**: Users can select their preferred interviewer, each with a different professional background, experience, and temperament. Options include:
+    - Sarah: An empathic, compassionate clinical psychologist with over 30 years of experience, specializing in trauma, anxiety disorders, and family therapy.
+    - Aaron: A tough minded, clinical psychologist with over 15 years of experience, specializing in stress, trauma, and high-performance demands, with a background as a military officer.
+  
+## Retrieval-Augmented Generation (RAG) and Document Retrieval Process
+
+**Retrieval-Augmented Generation (RAG)** is a method that combines the strengths of retrieval-based and generation-based approaches. RAG helps to ensure that the interview questions generated by the AI are both contextually relevant and grounded in authoritative sources - This optimizes and reduces the response time.
+
+1. **Document Embeddings**: The documents are converted into embeddings using OpenAI’s embedding models. These embeddings capture the semantic meaning of the text and are used to facilitate efficient retrieval.
+2. **FAISS Indexing**: The embeddings are stored in a FAISS (Facebook AI Similarity Search) index. FAISS is optimized for similarity search and clustering of dense vectors, making it ideal for this purpose.
+3. **Query Embedding**: When a user input or interview context is provided, it is also converted into an embedding.
+4. **Similarity Search**: The query embedding is used to search the FAISS index to retrieve the most relevant documents based on their embeddings.
+5. **Top-K Retrieval**: The system retrieves the top-K documents that are most similar to the user’s query embedding. These documents are then used to generate the next interview question, ensuring that the responses are based on relevant and accurate information.
+
+## Documents and Knowledge
+
+The platform uses a rich set of documents and knowledge bases to inform the AI’s questioning and reporting processes. These documents include:
+
+- **DSM-5 (Diagnostic and Statistical Manual of Mental Disorders, 5th Edition)**: Provides standardized criteria for the diagnosis of mental health conditions.
+- **PDM-2 (Psychodynamic Diagnostic Manual, 2nd Edition)**: Offers a psychodynamic perspective on mental health diagnosis.
+- **Personalities Descriptions**: Detailed descriptions of various personality types and traits.
+- **Defence Mechanisms**: Information on psychological strategies used by individuals to cope with reality and maintain self-image.
+- **Big Five Traits**: Descriptions of the five-factor model of personality traits.
+- **Attachment Styles**: Framework for understanding different types of attachment in interpersonal relationships.
+- **Interview Conduction Guides for Clinical Psychologists**: Guidelines and best practices for conducting clinical interviews.
+
+These documents are processed and indexed, enabling the AI to retrieve relevant excerpts during the interview to generate questions that are grounded in established psychological knowledge.
+
+## Contextual and Historical Relevance
+
+Throughout the interview process, the AI uses all chat history to ensure that each follow-up question is contextually relevant. By leveraging both the immediate user input and the full history of the conversation, the AI can provide a coherent and comprehensive interview experience. The use of RAG ensures that the follow-up questions are informed not only by the user's previous responses but also by the most relevant and authoritative information available in the knowledge base.
+
+## Human-like simulated environment 
+It supports audio interactions by converting text questions into speech and transcribing user audio responses into text, facilitated by OpenAI’s text-to-speech (TTS) and Whisper speech-to-text technologies. This creates a simulated environment for real-like conversational interviews, making the interactions more human-like.
+
+### Interview Tab
+
+The session starts with an introductory message delivered in both text and audio formats. Users respond by typing or recording audio responses, which the AI processes to generate and return relevant follow-up questions based on context and the retrieved documents. The conversation continues until a predetermined number of questions have been asked. At the end of the session, a detailed clinical report is generated and available for download as a PDF.
+
+### Upload Document Tab
+
+Users can upload existing documents and specify their preferred language. The system analyzes the document content and generates a detailed clinical report, which can be displayed and downloaded.
+
+<img src="appendix/diagram.png" width="500" alt="alt text">
+
+## Disclaimer
+
+This platform is a simulation and should not replace professional medical advice. Always seek advice from a qualified healthcare provider for medical concerns.
+
+---
+
+**Clinical Psychologist Interviewer 𝚿** stands as a testament to the potential of advanced AI technologies in simulating clinical psychology interviews and generating detailed reports. For technical details, refer to the in-code documentation. This platform offers a valuable tool for educational and research purposes by providing an enriching and interactive user experience.

ai_config.py

@@ -0,0 +1,61 @@
+from io import BytesIO
+from langchain_openai import ChatOpenAI
+from openai import OpenAI
+
+
+def n_of_questions():
+    n_of_questions = 25
+    return n_of_questions
+
+#openai_api_key = os.environ.get("openai_api_key")
+openai_api_key = 'your_openai_api_key'
+
+model = "gpt-4o-mini"
+
+def load_model(openai_api_key):
+    return ChatOpenAI(
+        model_name=model,
+        openai_api_key=openai_api_key,
+        temperature=0.5
+    )
+
+# Initialize the OpenAI client with the API key
+client = OpenAI(api_key=openai_api_key)
+
+
+def convert_text_to_speech(text, output, voice):
+    try:
+        # Convert the final text to speech
+        response = client.audio.speech.create(model="tts-1-hd", voice=voice, input=text)
+
+        if isinstance(output, BytesIO):
+            # If output is a BytesIO object, write directly to it
+            for chunk in response.iter_bytes():
+                output.write(chunk)
+        else:
+            # If output is a file path, open and write to it
+            with open(output, 'wb') as f:
+                for chunk in response.iter_bytes():
+                    f.write(chunk)
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        # Fallback in case of error
+        response = client.audio.speech.create(model="tts-1-hd", voice=voice, input='Here is my Report.')
+
+        if isinstance(output, BytesIO):
+            for chunk in response.iter_bytes():
+                output.write(chunk)
+        else:
+            with open(output, 'wb') as f:
+                for chunk in response.iter_bytes():
+                    f.write(chunk)
+
+
+def transcribe_audio(audio):
+    audio_file = open(audio, "rb")
+    transcription = client.audio.transcriptions.create(
+        model="whisper-1",
+        file=audio_file
+    )
+    return transcription.text

app.py

@@ -0,0 +1,214 @@
+import gradio as gr
+import tempfile
+import os
+from pathlib import Path
+from io import BytesIO
+from settings import (
+    respond,
+    generate_random_string,
+    reset_interview,
+    generate_interview_report,
+    generate_report_from_file,
+    interview_history,
+    question_count,
+    language,
+)
+from ai_config import convert_text_to_speech, transcribe_audio, n_of_questions
+from prompt_instructions import get_interview_initial_message_sarah, get_interview_initial_message_aaron
+
+# Global variables
+temp_audio_files = []
+initial_audio_path = None
+selected_interviewer = "Sarah"
+
+def reset_interview_action(voice):
+    global question_count, interview_history, selected_interviewer
+    selected_interviewer = voice
+    question_count = 0
+    interview_history.clear()
+
+    if voice == "Sarah":
+        initial_message = get_interview_initial_message_sarah()
+        voice_setting = "alloy"
+    else:
+        initial_message = get_interview_initial_message_aaron()
+        voice_setting = "onyx"
+
+    initial_message = str(initial_message)
+
+    initial_audio_buffer = BytesIO()
+    convert_text_to_speech(initial_message, initial_audio_buffer, voice_setting)
+    initial_audio_buffer.seek(0)
+
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+        temp_audio_path = temp_file.name
+        temp_file.write(initial_audio_buffer.getvalue())
+
+    temp_audio_files.append(temp_audio_path)
+
+    return (
+        [(None, initial_message[0] if isinstance(initial_message, tuple) else initial_message)],
+        gr.Audio(value=temp_audio_path, label=voice, autoplay=True),
+        gr.Textbox(value="")
+    )
+
+def create_app():
+    global initial_audio_path, selected_interviewer
+    initial_message = get_interview_initial_message_sarah()
+
+    initial_audio_buffer = BytesIO()
+    convert_text_to_speech(initial_message, initial_audio_buffer, "alloy")
+    initial_audio_buffer.seek(0)
+
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+        initial_audio_path = temp_file.name
+        temp_file.write(initial_audio_buffer.getvalue())
+
+    temp_audio_files.append(initial_audio_path)
+
+    with gr.Blocks(title="AI Clinical Psychologist Interviewer 𝚿") as demo:
+        gr.Image(value="appendix/icon.jpeg", label='icon', width=20, scale=1, show_label=False,
+                 show_download_button=False, show_share_button=False)
+        gr.Markdown(
+            """
+            # Clinical Psychologist Interviewer 𝚿
+            This chatbot conducts clinical interviews based on psychological knowledge.
+
+            The interviewer will prepare a clinical report based on the interview.
+            
+            * Please note that this is a simulation and should not be used as a substitute for professional medical advice.
+            * It is important to emphasize that any information shared is confidential and cannot be accessed. 
+            * In any case, it is recommended not to share sensitive information.
+            """
+        )
+
+        with gr.Tab("Interview"):
+            with gr.Row():
+                reset_button = gr.Button("Select Interviewer", size='sm', scale=1)
+                voice_radio = gr.Radio(["Sarah", "Aaron"], label="Select Interviewer", value="Sarah", scale=1, info='Each interviewer has a unique approach and a different professional background.')
+                audio_output = gr.Audio(
+                    label="Sarah",
+                    scale=3,
+                    value=initial_audio_path,
+                    autoplay=True,
+                    visible=True,
+                    show_download_button=False,
+                )
+
+            chatbot = gr.Chatbot(value=[(None, f"{initial_message}")], label=f"Clinical Interview 𝚿📋")
+            with gr.Row():
+                msg = gr.Textbox(label="Type your message here...", scale=3)
+                audio_input = gr.Audio(sources=(["microphone"]), label="Record your message", type="filepath", scale=1)
+            send_button = gr.Button("Send")
+            pdf_output = gr.File(label="Download Report", visible=False)
+
+            def user(user_message, audio, history):
+                if audio is not None:
+                    user_message = transcribe_audio(audio)
+                return "", None, history + [[user_message, None]]
+
+            def bot_response(chatbot, message, voice_selection):
+                global question_count, temp_audio_files, selected_interviewer
+                selected_interviewer = voice_selection
+                question_count += 1
+
+                last_user_message = chatbot[-1][0] if chatbot else message
+
+                voice = "alloy" if selected_interviewer == "Sarah" else "onyx"
+                response, audio_buffer = respond(chatbot, last_user_message, voice, selected_interviewer)
+
+                for bot_message in response:
+                    chatbot.append((None, bot_message[1]))
+
+                if isinstance(audio_buffer, BytesIO):
+                    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+                        temp_audio_path = temp_file.name
+                        temp_file.write(audio_buffer.getvalue())
+                    temp_audio_files.append(temp_audio_path)
+                    audio_output = gr.Audio(value=temp_audio_path, label=voice_selection, autoplay=True)
+                else:
+                    audio_output = gr.Audio(value=audio_buffer, label=voice_selection, autoplay=True)
+
+                if question_count >= n_of_questions():
+                    conclusion_message = "Thank you for participating in this interview. We have reached the end of our session. I hope this conversation has been helpful. Take care!"
+                    chatbot.append((None, conclusion_message))
+
+                    conclusion_audio_buffer = BytesIO()
+                    convert_text_to_speech(conclusion_message, conclusion_audio_buffer, voice)
+                    conclusion_audio_buffer.seek(0)
+
+                    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+                        temp_audio_path = temp_file.name
+                        temp_file.write(conclusion_audio_buffer.getvalue())
+                    temp_audio_files.append(temp_audio_path)
+                    audio_output = gr.Audio(value=temp_audio_path, label=voice_selection, autoplay=True)
+
+                    report_content, pdf_path = generate_interview_report(interview_history, language)
+                    chatbot.append((None, f"Interview Report:\n\n{report_content}"))
+
+                    return chatbot, audio_output, gr.File(visible=True, value=pdf_path)
+
+                return chatbot, audio_output, gr.File(visible=False)
+
+            msg.submit(user, [msg, audio_input, chatbot], [msg, audio_input, chatbot], queue=False).then(
+                bot_response, [chatbot, msg, voice_radio], [chatbot, audio_output, pdf_output]
+            )
+
+            send_button.click(user, [msg, audio_input, chatbot], [msg, audio_input, chatbot], queue=False).then(
+                bot_response, [chatbot, msg, voice_radio], [chatbot, audio_output, pdf_output]
+            )
+
+            reset_button.click(
+                reset_interview_action,
+                inputs=[voice_radio],
+                outputs=[chatbot, audio_output, msg]
+            )
+
+        with gr.Tab("Upload Document"):
+            gr.Markdown('Please upload a document that contains content written about a patient or by the patient.')
+            gr.Markdown('* Maximum length is up to 100K characters.')
+            gr.Markdown('* It is important to emphasize that the uploaded document is confidential and cannot be accessed.')
+            gr.Markdown('* In any case, it is recommended not to upload sensitive documents.')
+            file_input = gr.File(label="Upload a TXT, PDF, or DOCX file")
+            #language_input = gr.Textbox(label="Preferred Language for Report")
+            language_input = 'English'
+            generate_button = gr.Button("Generate Report")
+            report_output = gr.Textbox(label="Generated Report", lines=100, visible=False)
+            pdf_output = gr.File(label="Download Report", visible=True)
+
+            def generate_report_and_pdf(file, language):
+                report_content, pdf_path = generate_report_from_file(file, language)
+                return report_content, pdf_path, gr.File(visible=True)
+
+            generate_button.click(
+                generate_report_and_pdf,
+                inputs=[file_input],
+                outputs=[report_output, pdf_output, pdf_output]
+            )
+        with gr.Tab("Description"):
+            with open('appendix/description.txt', 'r', encoding='utf-8') as file:
+                description_txt = file.read()
+            gr.Markdown(description_txt)
+            gr.HTML("<div style='height: 15px;'></div>")
+            gr.Image(value="appendix/diagram.png", label='diagram', width=700, scale=1, show_label=False,
+                     show_download_button=False, show_share_button=False)
+
+    return demo
+
+# Clean up function
+def cleanup():
+    global temp_audio_files, initial_audio_path
+    for audio_file in temp_audio_files:
+        if os.path.exists(audio_file):
+            os.unlink(audio_file)
+    temp_audio_files.clear()
+
+    if initial_audio_path and os.path.exists(initial_audio_path):
+        os.unlink(initial_audio_path)
+
+if __name__ == "__main__":
+    app = create_app()
+    try:
+        app.launch()
+    finally:
+        cleanup()

interview_utils.py

@@ -0,0 +1,21 @@
+# interview_utils.py
+
+import random
+from prompt_instructions import get_interview_initial_message_sarah, get_interview_initial_message_aaron, get_interview_prompt_sarah, get_interview_prompt_aaron
+from ai_config import n_of_questions
+
+def random_interviewer(language):
+    if random.choice([True, False]):
+        initial_message, interviewer_name = get_interview_initial_message_sarah()
+        get_interview_prompt = get_interview_prompt_sarah(language, n_of_questions)
+        voice = 'alloy'
+    else:
+        initial_message, interviewer_name = get_interview_initial_message_aaron()
+        get_interview_prompt = get_interview_prompt_aaron(language, n_of_questions)
+        voice = 'onyx'
+    return initial_message, interviewer_name, get_interview_prompt, voice
+
+def get_prompt():
+    # This function should return the actual prompt
+    # You might need to adjust this based on how you're storing the prompt
+    return get_interview_prompt_sarah(language, n_of_questions)  # or whatever is appropriate

knowledge_retrieval.py

@@ -0,0 +1,91 @@
+import random
+from langchain_community.vectorstores import FAISS
+from langchain_openai import OpenAIEmbeddings
+from langchain.chains import create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.retrievers import EnsembleRetriever
+from ai_config import n_of_questions, openai_api_key
+from prompt_instructions import get_interview_prompt_sarah, get_interview_prompt_aaron, get_report_prompt
+
+n_of_questions = n_of_questions()
+
+def setup_knowledge_retrieval(llm, language='english', voice='Sarah'):
+    embedding_model = OpenAIEmbeddings(openai_api_key=openai_api_key)
+
+    documents_faiss_index = FAISS.load_local("knowledge/faiss_index_all_documents", embedding_model,
+                                               allow_dangerous_deserialization=True)
+
+    documents_retriever = documents_faiss_index.as_retriever()
+
+    combined_retriever = EnsembleRetriever(
+        retrievers=[documents_retriever]
+    )
+
+    if voice == 'Sarah':
+        interview_prompt = ChatPromptTemplate.from_messages([
+            ("system", get_interview_prompt_sarah(language, n_of_questions)),
+            ("human", "{input}")
+        ])
+    else:
+        interview_prompt = ChatPromptTemplate.from_messages([
+            ("system", get_interview_prompt_aaron(language, n_of_questions)),
+            ("human", "{input}")
+        ])
+
+    report_prompt = ChatPromptTemplate.from_messages([
+        ("system", get_report_prompt(language)),
+        ("human", "Please provide a concise clinical report based on the interview.")
+    ])
+
+    interview_chain = create_stuff_documents_chain(llm, interview_prompt)
+    report_chain = create_stuff_documents_chain(llm, report_prompt)
+
+    interview_retrieval_chain = create_retrieval_chain(combined_retriever, interview_chain)
+    report_retrieval_chain = create_retrieval_chain(combined_retriever, report_chain)
+
+    return interview_retrieval_chain, report_retrieval_chain, combined_retriever
+
+
+def get_next_response(interview_chain, message, history, question_count):
+    combined_history = "\n".join(history)
+
+    # Check if the interview should end
+    if question_count >= n_of_questions:
+        return "Thank you for your responses. I will now prepare a report."
+
+    # Generate the next question
+    result = interview_chain.invoke({
+        "input": f"Based on the patient's last response: '{message}', and considering the full interview history, ask a specific, detailed question that hasn't been asked before and is relevant to the patient's situation.",
+        "history": combined_history,
+        "question_number": question_count + 1  # Increment question number here
+    })
+
+    next_question = result.get("answer", "Could you provide more details on that?")
+
+    # Update history with the new question and response
+    history.append(f"Q{question_count + 1}: {next_question}")
+    history.append(f"A{question_count + 1}: {message}")
+
+    return next_question
+
+
+def generate_report(report_chain, history, language):
+    combined_history = "\n".join(history)
+
+    result = report_chain.invoke({
+        "input": "Please provide a clinical report based on the interview.",
+        "history": combined_history,
+        "language": language
+    })
+
+    return result.get("answer", "Unable to generate report due to insufficient information.")
+
+
+def get_initial_question(interview_chain):
+    result = interview_chain.invoke({
+        "input": "What should be the first question in a clinical psychology interview?",
+        "history": "",
+        "question_number": 1
+    })
+    return result.get("answer", "Could you tell me a little bit about yourself and what brings you here today?")

prompt_instructions.py

@@ -0,0 +1,151 @@
+from datetime import datetime
+from ai_config import n_of_questions
+current_datetime = datetime.now()
+current_date = current_datetime.strftime("%Y-%m-%d")
+
+n_of_questions = n_of_questions()
+
+
+def get_interview_initial_message_sarah():
+    return f"""Hello, I'm Sarah, an AI clinical psychologist, and I'll be conducting a clinical interview with you.
+    I have of over 30 years of experience, specializing in trauma, anxiety disorders, and family therapy.
+    I've been actively involved in various community service efforts, including several years of work with children with disabilities.
+    I’m here to listen and help you explore your thoughts and feelings.
+    I will ask you about {n_of_questions} questions.
+    Feel free to share as much or as little as you're comfortable with.
+    Could you please tell me which language you prefer to speak or conduct this interview in? 
+    it is important for me to say that my mother tongue is English, so I am sorry in advance if there are any mistakes."""
+
+def get_interview_initial_message_aaron():
+    return f"""Hello, I'm Aaron, an AI clinical psychologist. I'll be conducting a brief interview with you.
+    I have of over 15 years of clinical experience, specializing in stress, trauma, and high-performance demands.
+    I've worked with military personnel, athletes, and business professionals to help them manage their mental well-being. 
+    Our session will involve a series of questions to help me understand you better. 
+    I'll need you to answer the questions so I can get a clear understanding of your situation.
+    Which language do you prefer for this interview? my mother tongue language is English, so bear with me if there are any mistakes."""
+
+
+def get_interview_prompt_sarah(language, n_of_questions):
+    return f"""You are Sarah, an empathic and compassionate Female Psychologist or Psychiatrist, conducting a clinical interview in {language}. 
+A highly experienced and dedicated Clinical Psychologist with over 30 years of experience in clinical practice and research.
+Specializing in trauma, anxiety disorders, and family therapy, Sarah has a proven track record of successfully treating a wide range of psychological conditions.
+Her deep commitment to patient care and mental health advocacy has driven her to develop innovative therapeutic approaches and lead community mental health initiatives.
+Sarah's extensive career is marked by her unwavering dedication to giving back to the community. 
+She has been actively involved in various community service efforts, including several years of work with children with disabilities and autistic children.
+Her compassionate approach and ability to connect with patients of all ages have made her a respected figure in the field of psychology.
+Sarah is not only a skilled clinician but also a passionate advocate for mental health, continuously striving to improve the lives of those she serves.
+Use the following context and interview history to guide your response:
+Context from knowledge base: {{context}}
+Previous interview history:
+{{history}}
+Current question number: {{question_number}}
+Respond to the patient's input briefly and directly in {language}.
+Ask a specific, detailed question that hasn't been asked before.
+You must remember all the previous answers given by the patient, and use this information if necessary.
+If you perceive particularly special, or unusual, or strange things in the answers that require deepening or in-depth understanding - ask about it or direct your question to get answers about it and clarify the matter - this information maybe benefitial and may hint about the patient personality or traits.
+The first question is to ask for the patient name.
+The second question is to ask for age. 
+The third question is to ask where they live.
+The fourth questions is to ask what they does for work.
+The fifth question is to ask about the nature of the relationship with their parents.
+Keep in mind that you have {n_of_questions} total number of questions.
+After {n_of_questions} interactions, indicate that you will prepare a report based on the gathered information."""
+
+
+def get_interview_prompt_aaron(language, n_of_questions):
+    return f"""You are Aaron, a not so much empathic, tough, and impatient Male Psychologist, Coach, and Mentor, conducting a clinical interview in {language}. 
+    Aaron Professional Resume or Summary:
+    Aaron is a highly experienced clinical psychologist with over 15 years of expertise in treating individuals dealing with stress, trauma, and high-performance demands.
+    His background as an army officer in the special forces, where he served for 20 years, provides him with a unique understanding of the mental health challenges faced by soldiers.
+    In addition to his work with military personnel, Aaron extends his practice to athletes, entrepreneurs, and business professionals, offering specialized psychological support that helps them achieve peak performance while managing stress and mental well-being.
+    As a coach and mentor, Aaron is committed to guiding his clients through personal and professional challenges, fostering resilience, and promoting mental wellness.
+    
+    Use the following context and interview history to guide your response:
+    Context from knowledge base: {{context}}
+    Previous interview history:
+    {{history}}
+    Current question number: {{question_number}}
+    Respond to the patient's input briefly and directly in {language}.
+    Ask a specific, detailed question that hasn't been asked before.
+    You must remember all the previous answers given by the patient, and use this information if necessary.
+    If you perceive particularly special, or unusual, or strange things in the answers that require deepening or in-depth understanding - ask about it or direct your question to get answers about it and clarify the matter - this information maybe benefitial and may hint about the patient personality or traits.
+    The first question is to ask for the patient name.
+    The second question is to ask for age. 
+    The third question is to ask where they live.
+    The fourth questions is to ask what they does for work.
+    The fifth question is to ask about the nature of the relationship with their parents.
+    Keep in mind that you have {n_of_questions} total number of questions.
+    After {n_of_questions} interactions, indicate that you will prepare a report based on the gathered information."""
+
+def get_report_prompt(language):
+    return f"""You are a Psychologist or Psychiatrist preparing a clinical report in {language}. 
+Use the following context and interview history to create your report. 
+Keep the report concise and focused on the key observations:
+Context from knowledge base: {{context}}
+Complete interview history:
+{{history}}
+Prepare a brief clinical report in {language} based strictly on the information gathered during the interview. 
+Date to specify in the report: {current_date}
+- Specify name, place of living, and current occupation if available.
+- Use only the terms, criteria for diagnosis, and categories for clinical diagnosis or classifications 
+that are present in the provided knowledge base. Do not introduce any external information or terminology. 
+* In your diagnosis, you must be very careful. That is, you need to have enough evidence and information to rate or diagnose a patient.
+* Your diagnoses must be fact-based when they are implied by what the speakers are saying.
+* Write technical, clinical or professional terms only in the English language.
+* As a rule, in cases where there is little information about the patient through the conversation or through
+the things they say, the diagnosis will be more difficult, and the ratings will be lower, 
+because it is difficult to draw conclusions when our information about the patient is scarce. 
+be very selective and careful with your facts that you write or provide in the report.
+in such a case, this also must be mentioned and taken into consideration.
+* Do not provide any clinical diagnosis or any conclusions in the reports if there is not enough information that the patient provide.
+* Any diagnosis or interpretation requires the presentation of facts, foundations, and explanations.
+* You can also give examples or quotes.
+* There are two parts for the report - main report and additional report.
+* Structure the main report to include observed symptoms, potential diagnoses (if applicable), and any other 
+relevant clinical observations, all within the framework of the given knowledge.
+First, write the main report, than, in addition to the main report, add the following sections as the additional report:
+- An overall clinical impression
+- Dominant personality characteristics
+- Style of communication
+- What mainly preoccupies them - themes or topics that preoccupy them in particular
+- Possible personal weaknesses or triggers
+- Defense Mechanisms
+- How they are likely to react to stressful or emotionally charged situations or events
+- How they might deal with unexpected situations or events
+- How they might behave in a group vs alone
+- How they might behave in intimate relationships, and which partners they usually are drawn or attracted to. these unconscious choices may trigger past events or childhood experiences.
+- How will they function in work environments, and will they be able to contribute and perform properly and over time in a stable manner.
+- Degree of psychological mental health assessment
+- What will the experience be in general to meet such a person
+- Other things or further assessments that can be examined from a psychological perspective, and in which situations it is necessary to examine the person's reactions in order to get more indications of a diagnosis of their personality
+- The type of treatment that is recommended.
+Furthermore, include the following:
+Big Five Traits (ratings of 0-10):
+Extraversion: [rating]
+Agreeableness: [rating]
+Conscientiousness: [rating]
+Neuroticism: [rating]
+Openness: [rating]
+Big Five Traits explanation: [explanation]
+Personality Disorders or Styles (ratings of 0-4):
+Depressed: [rating]
+Paranoid: [rating]
+Schizoid-Schizotypal: [rating]
+Antisocial-Psychopathic: [rating]
+Borderline-Dysregulated: [rating]
+Narcissistic: [rating]
+Anxious-Avoidant: [rating]
+Dependent-Victimized: [rating]
+Hysteric-Histrionic: [rating]
+Obsessional: [rating]
+Personality Disorders or Styles explanation: [explanation]
+Attachment Styles (ratings of 0-10):
+Secured: [rating]
+Anxious-Preoccupied: [rating]
+Dismissive-Avoidant: [rating]
+Fearful-Avoidant: [rating]
+Avoidance: [rating]
+Positive view toward the Self: [rating]
+Positive view toward Others: [rating]
+Attachment Styles explanation: [explanation]
+"""

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+PyPDF2
+python-docx
+reportlab
+langchain-openai
+openai
+faiss-cpu
+python-dotenv
+langchain_community

settings.py

@@ -0,0 +1,237 @@
+import traceback
+from datetime import datetime
+from pathlib import Path
+import os
+import random
+import string
+import tempfile
+import re
+import io
+import PyPDF2
+import docx
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_JUSTIFY
+from ai_config import n_of_questions, load_model, openai_api_key, convert_text_to_speech
+from knowledge_retrieval import setup_knowledge_retrieval, generate_report
+
+# Initialize settings
+n_of_questions = n_of_questions()
+current_datetime = datetime.now()
+human_readable_datetime = current_datetime.strftime("%B %d, %Y at %H:%M")
+current_date = current_datetime.strftime("%Y-%m-%d")
+
+# Initialize the model and retrieval chain
+try:
+    llm = load_model(openai_api_key)
+    interview_retrieval_chain, report_retrieval_chain, combined_retriever = setup_knowledge_retrieval(llm)
+    knowledge_base_connected = True
+    print("Successfully connected to the knowledge base.")
+except Exception as e:
+    print(f"Error initializing the model or retrieval chain: {str(e)}")
+    knowledge_base_connected = False
+    print("Falling back to basic mode without knowledge base.")
+
+question_count = 0
+interview_history = []
+last_audio_path = None  # Variable to store the path of the last audio file
+initial_audio_path = None  # Variable to store the path of the initial audio file
+language = None
+
+def generate_random_string(length=5):
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+def respond(message, history, voice, selected_interviewer):
+    global question_count, interview_history, combined_retriever, last_audio_path, initial_audio_path, language, interview_retrieval_chain, report_retrieval_chain
+
+    if not isinstance(history, list):
+        history = []
+    if not history or not history[-1]:
+        history.append(["", ""])
+
+    # Extract the actual message text
+    if isinstance(message, list):
+        message = message[-1][0] if message and isinstance(message[-1], list) else message[-1]
+
+    question_count += 1
+    interview_history.append(f"Q{question_count}: {message}")
+    history_str = "\n".join(interview_history)
+
+    try:
+        if knowledge_base_connected:
+            if question_count == 1:
+                # Capture the language from the first response
+                language = message.strip().lower()
+                # Reinitialize the interview chain with the new language
+                interview_retrieval_chain, report_retrieval_chain, combined_retriever = setup_knowledge_retrieval(
+                    llm, language, selected_interviewer)
+
+            if question_count < n_of_questions:
+                result = interview_retrieval_chain.invoke({
+                    "input": f"Based on the patient's statement: '{message}', what should be the next question?",
+                    "history": history_str,
+                    "question_number": question_count + 1,
+                    "language": language
+                })
+                question = result.get("answer", f"Can you tell me more about that? (in {language})")
+            else:
+                result = generate_report(report_retrieval_chain, interview_history, language)
+                question = result
+                speech_file_path = None  # Skip audio generation for the report
+
+            if question:
+                random_suffix = generate_random_string()
+                speech_file_path = Path(__file__).parent / f"question_{question_count}_{random_suffix}.mp3"
+                convert_text_to_speech(question, speech_file_path, voice)
+                print(f"Question {question_count} saved as audio at {speech_file_path}")
+
+                # Remove the last audio file if it exists
+                if last_audio_path and os.path.exists(last_audio_path):
+                    os.remove(last_audio_path)
+                last_audio_path = speech_file_path
+            else:
+                speech_file_path = None  # Skip audio generation for the report
+
+        else:
+            # Fallback mode without knowledge base
+            question = f"Can you elaborate on that? (in {language})"
+            if question_count < n_of_questions:
+                speech_file_path = Path(__file__).parent / f"question_{question_count}.mp3"
+                convert_text_to_speech(question, speech_file_path, voice)
+                print(f"Question {question_count} saved as audio at {speech_file_path}")
+
+                if last_audio_path and os.path.exists(last_audio_path):
+                    os.remove(last_audio_path)
+                last_audio_path = speech_file_path
+            else:
+                speech_file_path = None
+
+        history[-1][1] = f"{question}"
+
+        # Remove the initial question audio file after the first user response
+        if initial_audio_path and os.path.exists(initial_audio_path):
+            os.remove(initial_audio_path)
+        initial_audio_path = None
+
+        return history, str(speech_file_path) if speech_file_path else None
+
+    except Exception as e:
+        print(f"Error in retrieval chain: {str(e)}")
+        print(traceback.format_exc())
+        return history, None
+
+
+def reset_interview():
+    """Reset the interview state."""
+    global question_count, interview_history, last_audio_path, initial_audio_path
+    question_count = 0
+    interview_history = []
+    if last_audio_path and os.path.exists(last_audio_path):
+        os.remove(last_audio_path)
+    last_audio_path = None
+    initial_audio_path = None
+
+
+def read_file(file):
+    if file is None:
+        return "No file uploaded"
+
+    if isinstance(file, str):
+        with open(file, 'r', encoding='utf-8') as f:
+            return f.read()
+
+    if hasattr(file, 'name'):  # Check if it's a file-like object
+        if file.name.endswith('.txt'):
+            return file.content
+        elif file.name.endswith('.pdf'):
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(file.content))
+            return "\n".join(page.extract_text() for page in pdf_reader.pages)
+        elif file.name.endswith('.docx'):
+            doc = docx.Document(io.BytesIO(file.content))
+            return "\n".join(paragraph.text for paragraph in doc.paragraphs)
+        else:
+            return "Unsupported file format"
+
+    return "Unable to read file"
+
+def generate_report_from_file(file, language):
+    try:
+        file_content = read_file(file)
+        if file_content == "No file uploaded" or file_content == "Unsupported file format" or file_content == "Unable to read file":
+            return file_content
+
+        file_content = file_content[:100000]
+        
+        report_language = language.strip().lower() if language else "english"
+        print('preferred language:', report_language)
+        print(f"Generating report in language: {report_language}")  # For debugging
+
+        # Reinitialize the report chain with the new language
+        _, report_retrieval_chain, _ = setup_knowledge_retrieval(llm, report_language)
+
+        result = report_retrieval_chain.invoke({
+            "input": "Please provide a clinical report based on the following content:",
+            "history": file_content,
+            "language": report_language
+        })
+        report_content = result.get("answer", "Unable to generate report due to insufficient information.")
+        pdf_path = create_pdf(report_content)
+        return report_content, pdf_path
+    except Exception as e:
+        return f"An error occurred while processing the file: {str(e)}", None
+
+
+def generate_interview_report(interview_history, language):
+    try:
+        report_language = language.strip().lower() if language else "english"
+        print('preferred report_language language:', report_language)
+        _, report_retrieval_chain, _ = setup_knowledge_retrieval(llm, report_language)
+
+        result = report_retrieval_chain.invoke({
+            "input": "Please provide a clinical report based on the following interview:",
+            "history": "\n".join(interview_history),
+            "language": report_language
+        })
+        report_content = result.get("answer", "Unable to generate report due to insufficient information.")
+        pdf_path = create_pdf(report_content)
+        return report_content, pdf_path
+    except Exception as e:
+        return f"An error occurred while generating the report: {str(e)}", None
+
+def create_pdf(content):
+
+    random_string = generate_random_string()
+    
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f'_report.pdf')
+    doc = SimpleDocTemplate(temp_file.name, pagesize=letter)
+    styles = getSampleStyleSheet()
+
+    # Create a custom style for bold text
+    bold_style = ParagraphStyle('Bold', parent=styles['Normal'], fontName='Helvetica-Bold', fontSize=10)
+
+    # Create a custom style for normal text with justification
+    normal_style = ParagraphStyle('Normal', parent=styles['Normal'], alignment=TA_JUSTIFY)
+
+    flowables = []
+
+    for line in content.split('\n'):
+        # Use regex to find words surrounded by **
+        parts = re.split(r'(\*\*.*?\*\*)', line)
+        paragraph_parts = []
+
+        for part in parts:
+            if part.startswith('**') and part.endswith('**'):
+                # Bold text
+                bold_text = part.strip('**')
+                paragraph_parts.append(Paragraph(bold_text, bold_style))
+            else:
+                # Normal text
+                paragraph_parts.append(Paragraph(part, normal_style))
+
+        flowables.extend(paragraph_parts)
+        flowables.append(Spacer(1, 12))  # Add space between paragraphs
+
+    doc.build(flowables)
+    return temp_file.name