Upload 7 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+knowledge/faiss_index_all_documents/index.faiss filter=lfs diff=lfs merge=lfs -text

ai_config.py

@@ -0,0 +1,41 @@
+from langchain_openai import ChatOpenAI
+from openai import OpenAI
+import tiktoken
+import os
+
+def n_of_questions():
+    n_of_questions = 25
+    return n_of_questions
+
+openai_api_key = os.environ.get("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.1,
+        top_p=0.85
+    )
+
+# Initialize the OpenAI client with the API key
+client = OpenAI(api_key=openai_api_key)
+
+
+def convert_text_to_speech(text, output_file):
+    try:
+        # Convert the final text to speech
+        response = client.audio.speech.create(model="tts-1", voice="alloy", input=text)
+
+        with open(output_file, 'wb') as f:
+            for chunk in response.iter_bytes():
+                f.write(chunk)
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        response = client.audio.speech.create(model="tts-1", voice="alloy", input='Here is my Report!')
+
+        with open(output_file, 'wb') as f:
+            for chunk in response.iter_bytes():
+                f.write(chunk)

app.py

@@ -0,0 +1,153 @@
+import gradio as gr
+import tempfile
+import os
+from pathlib import Path
+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, n_of_questions
+from prompt_instructions import get_interview_initial_message
+
+# Global variables
+temp_mp3_files = []
+initial_audio_path = None
+
+
+# Initialize Gradio interface
+def create_app():
+    global initial_audio_path
+    initial_message = get_interview_initial_message()
+
+    # Generate and save the audio for the initial message in a temporary file
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_initial_audio:
+        initial_audio_path = temp_initial_audio.name
+        convert_text_to_speech(initial_message, initial_audio_path)
+        temp_mp3_files.append(initial_audio_path)
+
+    with gr.Blocks(title="Clinical Psychologist Interviewer 𝚿") as demo:
+        gr.Markdown(
+            """
+            # Clinical Psychologist Interviewer 𝚿
+            This chatbot conducts clinical interviews based on psychological knowledge.
+            Please note that this is a simulation and should not be used as a substitute for professional medical advice.
+            """
+        )
+
+        with gr.Tab("Interview"):
+            audio_output = gr.Audio(
+                label="Sarah",
+                scale=1,
+                value=initial_audio_path,
+                autoplay=True,
+                visible=False,
+                show_download_button=False,
+            )
+            chatbot = gr.Chatbot(value=[("", f"{initial_message}")], label=f"Clinical Interview 𝚿📋")
+            msg = gr.Textbox(label="Type your message here...")
+            send_button = gr.Button("Send")
+
+            pdf_output = gr.File(label="Download Report", visible=False)
+
+            def user(user_message, history):
+                if not isinstance(history, list):
+                    history = []
+                return "", history + [[user_message, None]]
+
+            def bot_response(chatbot, message):
+                global question_count, temp_mp3_files
+                question_count += 1
+
+                response, audio = respond(chatbot, message)
+
+                if isinstance(audio, str) and audio.endswith('.mp3'):
+                    temp_mp3_files.append(audio)
+
+                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!"
+                    response.append((message, conclusion_message))
+
+                    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_audio:
+                        audio_path = temp_audio.name
+                        convert_text_to_speech(conclusion_message, audio_path)
+                        audio = audio_path
+                        temp_mp3_files.append(audio_path)
+
+                    # Generate report automatically
+                    report_content, _ = generate_interview_report(interview_history, language)
+                    with tempfile.NamedTemporaryFile(mode='w', suffix=".txt", delete=False,
+                                                     encoding='utf-8') as temp_report:
+                        temp_report.write(report_content)
+                        temp_report_path = temp_report.name
+
+                    _, pdf_path = generate_report_from_file(temp_report_path, language)
+
+                    # Add report to the chat
+                    response.append(("", f"Interview Report:\n\n{report_content}"))
+
+                    # Clean up temporary files
+                    os.unlink(temp_report_path)
+
+                    # Clean up all MP3 files
+                    for mp3_file in temp_mp3_files:
+                        if os.path.exists(mp3_file):
+                            os.unlink(mp3_file)
+                    temp_mp3_files.clear()
+
+                    return response, audio, gr.File(visible=True, value=pdf_path), gr.Textbox(visible=False)
+
+                return response, audio, gr.File(visible=False), gr.Textbox(visible=True)
+
+            msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                bot_response, [chatbot, msg], [chatbot, audio_output, pdf_output, msg]
+            )
+
+            send_button.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                bot_response, [chatbot, msg], [chatbot, audio_output, pdf_output, msg]
+            )
+
+        with gr.Tab("Upload Document"):
+            file_input = gr.File(label="Upload a TXT, PDF, or DOCX file")
+            language_input = gr.Textbox(label="Preferred Language for Report",
+                                        placeholder="Enter language")
+            generate_button = gr.Button("Generate Report")
+            report_output = gr.Textbox(label="Generated Report", lines=100)
+            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, language_input],
+                outputs=[report_output, pdf_output, pdf_output]
+            )
+
+    return demo
+
+
+# Clean up function
+def cleanup():
+    global temp_mp3_files, initial_audio_path
+    for mp3_file in temp_mp3_files:
+        if os.path.exists(mp3_file):
+            os.unlink(mp3_file)
+    temp_mp3_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()

knowledge/faiss_index_all_documents/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12862dc2569f08087b731be2f75ff4a81e940f9573a742e16cb55b2c6e2f8e37
+size 5283885

knowledge/faiss_index_all_documents/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4e90c1c58172c666127f1d39aef3aaf8293e83069778e5363d3fb3242027f17
+size 2786587

knowledge_retrieval.py

@@ -0,0 +1,86 @@
+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, get_report_prompt
+
+n_of_questions = n_of_questions()
+
+def setup_knowledge_retrieval(llm, language='english'):
+    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]
+    )
+
+    interview_prompt = ChatPromptTemplate.from_messages([
+        ("system", get_interview_prompt(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,119 @@
+from datetime import datetime
+current_datetime = datetime.now()
+current_date = current_datetime.strftime("%Y-%m-%d")
+
+def get_interview_initial_message():
+    return """Hello, I'm Sarah, an AI clinical psychologist, and I'll be conducting a clinical interview with you.
+    
+    Before we begin, I want to assure you that this is a safe and confidential space.
+    
+    Our session will involve a series of questions to help me understand your situation better. 
+    
+    Feel free to share as much or as little as you're comfortable with. There are no right or wrong answers - I'm here to listen and learn about your experiences.
+    
+    To ensure I can communicate with you most effectively, could you please tell me which language you prefer to speak or conduct this interview in?"""
+
+def get_interview_prompt(language, n_of_questions):
+    return f"""You are a Psychologist or Psychiatrist conducting a clinical interview in {language}. 
+Use the following context and interview history to guide your response. 
+Keep your responses concise and to the point:
+
+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, and keep it short.
+Do not repeat the same questions.
+When asking questions, the way the questions are asked must take into account the patient's personality.
+For example, if the person is more introverted or extraverted, the way the questions are asked will be accordingly.
+If the person is very sensitive for example, there is a need to take that into consideration when asking the questions.
+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 few questions are general questions about the patient that can give us an overall view.
+The 1st question is to ask for name.
+The 2nd question is to ask for age. 
+The 3rd question is to ask where they live.
+The 4th questions is to ask what they does for work.
+The 5th question is to ask about the nature of the relationship with their parents.
+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}
+- 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
+- Degree of psychological mental health assessment
+- Style of communication
+- What mainly preoccupies them - themes or topics that preoccupy them in particular
+- Possible personal weaknesses or triggers
+- 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
+- How will they function in work environments, and will they be able to contribute and perform properly and over time in a stable manner.
+- 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 Personality: [rating]
+Paranoid: [rating]
+Schizoid-Schizotypal: [rating]
+Antisocial-Psychopathic: [rating]
+Borderline-Dysregulated: [rating]
+Narcissistic: [rating]
+Anxious-Avoidant: [rating]
+Dependent-Victimized: [rating]
+Obsessional: [rating]
+Personality Disorders or Styles explanation: [explanation]
+
+Attachment Styles (ratings of 0-10):
+Secured Attachment: [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]
+"""

settings.py

@@ -0,0 +1,233 @@
+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
+from ai_config import n_of_questions, openai_api_key, load_model
+
+# 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):
+    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)
+
+            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)
+                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)
+                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
+
+        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):
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.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