Upload 2 files

medical_reports_upgraded.py

@@ -0,0 +1,1079 @@
+import os
+import shutil
+import openai
+import docx
+import base64
+import gradio as gr
+import assemblyai as aai
+from langchain.document_loaders import PyPDFLoader
+from langchain.document_loaders import DirectoryLoader
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import Docx2txtLoader
+from langchain.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains.question_answering import load_qa_chain
+from langchain.callbacks import get_openai_callback
+from langchain.llms import OpenAI
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from pydantic import BaseModel, Field
+
+from langchain import PromptTemplate, LLMChain
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+aai.settings.api_key = os.environ.get("AAPI_KEY")
+openai.api_key = os.environ.get("OPENAI_API_KEY")
+embeddings = OpenAIEmbeddings()
+client = OpenAI()
+
+upload_dir = "/home/user/app/file/"
+upload_files_vector_db = "/home/user/app/file_db/"
+report_vector_db = "/home/user/app/local_db/"
+soap_dir = "/home/user/app/soap_docs/"
+sbar_dir = "/home/user/app/sbar_docs/"
+temp_reports_dir = "/home/user/app/temp_reports/"
+temp_vector_db = "/home/user/app/temp_db/"
+
+directories = [
+    upload_dir,
+    upload_files_vector_db,
+    report_vector_db,
+    soap_dir,
+    sbar_dir,
+    temp_reports_dir,
+    temp_vector_db,
+]
+
+# Create each directory if it doesn't already exist
+for directory in directories:
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+        print(f"Created directory: {directory}")
+    else:
+        print(f"Directory already exists: {directory}")
+llm = ChatOpenAI(model="gpt-4o-mini")
+embedding_model = OpenAIEmbeddings()
+# report_db = FAISS.load_local(report_vector_db, embeddings=embedding_model, allow_dangerous_deserialization=True)
+qa_chain = load_qa_chain(ChatOpenAI(), chain_type="stuff")
+
+"""# Page 1"""
+
+
+def save_file(input_file):
+    os.makedirs(upload_dir, exist_ok=True)
+
+    for file in input_file:
+        shutil.copy(file.name, upload_dir)
+
+    return "File(s) saved successfully!"
+
+
+def vectorise(input_dir, output_dir):
+    loader1 = DirectoryLoader(input_dir, glob="./*.pdf", loader_cls=PyPDFLoader)
+    document1 = loader1.load()
+
+    loader2 = DirectoryLoader(input_dir, glob="./*.txt", loader_cls=TextLoader)
+    document2 = loader2.load()
+
+    loader3 = DirectoryLoader(input_dir, glob="./*.docx", loader_cls=Docx2txtLoader)
+    document3 = loader3.load()
+
+    document1.extend(document2)
+    document1.extend(document3)
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000, chunk_overlap=200, length_function=len
+    )
+
+    docs = text_splitter.split_documents(document1)
+    file_db = FAISS.from_documents(docs, embeddings)
+    file_db.save_local(output_dir)
+
+    return "File(s) processed successfully!"
+
+
+def merge_vectors(vectorDB_path):
+    docs_db1 = FAISS.load_local(
+        report_vector_db, embeddings, allow_dangerous_deserialization=True
+    )
+    docs_db2 = FAISS.load_local(
+        vectorDB_path, embeddings, allow_dangerous_deserialization=True
+    )
+    docs_db2.merge_from(docs_db1)
+    docs_db2.save_local(report_vector_db)
+
+
+def formatted_response(docs, response):
+    formatted_output = response + "\n\nSources"
+
+    for i, doc in enumerate(docs):
+        source_info = doc.metadata.get("source", "Unknown source")
+        page_info = doc.metadata.get("page", None)
+
+        file_name = source_info.split("/")[-1].strip()
+
+        if page_info is not None:
+            formatted_output += f"\n{file_name}\tpage no {page_info}"
+        else:
+            formatted_output += f"\n{file_name}"
+
+    return formatted_output
+
+
+class AI_Medical_Report(BaseModel):
+    patient_name: str = Field(
+        ...,
+        description="The full name of the patient if provided in the context. Otherwise Unknown",
+    )
+    soap_report: str = Field(
+        ...,
+        description="""SOAP reports are a structured way to document patient interactions in healthcare:
+Subjective: Patient’s own description of symptoms and concerns.
+Objective: Factual, measurable data like exam results and vital signs.
+Assessment: The healthcare provider’s diagnosis or clinical impression.
+Plan: Recommended next steps, treatments, or follow-up actions.""",
+    )
+    sbar_report: str = Field(
+        ...,
+        description="""SBAR reports are a structured communication tool in healthcare to convey critical information efficiently:
+Situation: Briefly state the current issue or reason for the communication.
+Background: Provide context, such as patient history or relevant background info.
+Assessment: Share your professional assessment of the problem.
+Recommendation: Suggest actions or what you need from the listener.""",
+    )
+    recommendations_for_doc: str = Field(
+        ...,
+        description="provide 3 recommendations for the doctor like further questions to ask the patient, follow-up tests etc.",
+    )
+
+
+def assemblyai_STT(audio_url: str) -> str:
+    """
+    Transcribes an audio file with speaker labels and returns a formatted string.
+
+    Parameters:
+        audio_url (str): URL or path to the audio file to be transcribed.
+
+    Returns:
+        str: A formatted string with each speaker's label and their corresponding text.
+    """
+    # Configure transcription with speaker labels enabled
+    config = aai.TranscriptionConfig(speaker_labels=True)
+
+    # Perform transcription
+    transcript = aai.Transcriber().transcribe(audio_url, config)
+
+    # Format each utterance into a single string with speaker labels
+    transcription_output = "\n".join(
+        f"Speaker {utterance.speaker}: {utterance.text}"
+        for utterance in transcript.utterances
+    )
+
+    return transcription_output
+
+
+def generate_report(input_text: str = None, file_path: str = None) -> AI_Medical_Report:
+    """
+    Generates a SOAP report from text or audio input using OpenAI's GPT-4 model.
+
+    Args:
+        client (OpenAI): Initialized OpenAI client.
+        input_text (str, optional): Text input containing the patient case study.
+        file_path (str, optional): Path to the audio file. Defaults to None.
+        model (str): Model name to use for generating the report. Defaults to "gpt-4o-audio-preview".
+
+    Returns:
+        SOAPExtraction: Parsed SOAP information including patient name, subjective, objective, assessment, plan, and doctor recommendations.
+    """
+    from openai import OpenAI
+
+    client = OpenAI()
+    try:
+        # Prepare message content based on input type
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "You are an AI medical assistant designed to help doctors. Your job is to convert the patient information into SOAP and SBAR reports. in the given JSON format"
+                ),
+            }
+        ]
+
+        if input_text:
+            # Text-based input
+            messages.append({"role": "user", "content": input_text})
+            model = "gpt-4o"
+        elif file_path:
+            # Audio-based input: load and encode the audio file
+            model = "gpt-4o-audio-preview-2024-10-01"
+            with open(file_path, "rb") as audio_file:
+                wav_data = audio_file.read()
+            encoded_string = base64.b64encode(wav_data).decode("utf-8")
+            messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Please generate Medical reports based on the following audio input",
+                        },
+                        {
+                            "type": "input_audio",
+                            "input_audio": {"data": encoded_string, "format": "wav"},
+                        },
+                    ],
+                }
+            )
+        else:
+            raise ValueError("Either input_text or file_path must be provided.")
+
+        # Create completion request
+        completion = client.beta.chat.completions.parse(
+            model=model,
+            modalities=["text"],
+            messages=messages,
+            response_format=AI_Medical_Report,
+        )
+
+        # Retrieve structured SOAP report
+        report = completion.choices[0].message.parsed
+        return report
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+
+# driver function for making reports
+def report_main(
+    input_text: str = None,
+    audio_file: str = None,
+    transcription_service: str = "OpenAI",
+) -> tuple:
+    """
+    Generates a SOAP and SBAR report based on user input, either from text or audio.
+
+    Args:
+        input_text (str, optional): Text input from the user.
+        audio_file (str, optional): Path to the audio file (if provided).
+        transcription_service (str): Selected transcription service ("AssemblyAI" or "OpenAI").
+
+    Returns:
+        tuple: Contains patient_name, SOAP Report, SBAR_Report,
+               doctor_recommendations, and transcription_text (if audio input was used).
+    """
+    from openai import OpenAI
+
+    client = OpenAI()  # Initialize OpenAI client
+
+    # Initialize empty strings for the SOAP report components
+    patient_name = ""
+    soap_report = ""
+    sbar_report = ""
+    doctor_recommendations = ""
+    transcription_text = ""
+
+    # Process input based on provided input_text or audio_file
+    if input_text:
+        # Generate SOAP report from text input
+        report = generate_report(input_text=input_text)
+
+        # Assign values from the generated report
+        patient_name = report.patient_name
+        soap_report = report.soap_report
+        sbar_report = report.sbar_report
+        doctor_recommendations = report.recommendations_for_doc
+
+    elif audio_file:
+        # Use selected transcription service for audio input
+        if transcription_service == "AssemblyAI":
+            transcription_text = assemblyai_STT(audio_file)
+            report = generate_report(input_text=transcription_text)
+            print(transcription_text)
+        elif transcription_service == "OpenAI":
+            report = generate_report(file_path=audio_file)
+            transcription_text = "OpenAI directly accepts Audio Inputs"
+            print(transcription_text)
+        else:
+            raise ValueError(
+                "Invalid transcription service specified. Choose 'AssemblyAI' or 'OpenAI'."
+            )
+
+        # Assign values from the generated report
+        patient_name = report.patient_name
+        soap_report = report.soap_report
+        sbar_report = report.sbar_report
+        doctor_recommendations = report.recommendations_for_doc
+
+    else:
+        raise ValueError("Either input_text or audio_file must be provided.")
+
+    # Return structured output in a tuple
+    return (
+        patient_name,
+        soap_report,
+        sbar_report,
+        doctor_recommendations,
+        transcription_text,
+    )
+
+
+# x=generate_report(file_path="/content/Cough.wav")
+
+
+def delete_dir(dir):
+    try:
+        shutil.rmtree(dir)
+        return "Deleted Successfully"
+
+    except:
+        return "Already Deleted"
+
+
+def save_reports(file_name, file_content, report_type, destination_folder):
+    # Ensure the destination folder exists
+    if not os.path.exists(destination_folder):
+        os.makedirs(destination_folder)
+
+    # Define the path for the .docx file in the destination folder
+    destination_path = os.path.join(
+        destination_folder, f"{report_type}_{file_name}.docx"
+    )
+
+    # Create a new document and add the SOAP response text
+    doc = docx.Document()
+    doc.add_paragraph(file_content)
+
+    # Save the document to the specified destination folder
+    doc.save(destination_path)
+
+    # Define and create the path for the temp folder
+    if not os.path.exists(temp_reports_dir):
+        os.makedirs(temp_reports_dir)
+
+    # Define the path for the temp copy
+    temp_path = os.path.join(temp_reports_dir, f"{report_type}_{file_name}.docx")
+
+    # Save a copy of the document in the temp folder
+    doc.save(temp_path)
+
+    return f"Successfully saved"
+
+
+# driver function for save
+def save_reports_main(file_name, soap_report_content, sbar_report_content):
+    # Save SOAP report
+    soap_result = save_reports(file_name, soap_report_content, "SOAP", soap_dir)
+    print(soap_result)
+
+    # Save SBAR report
+    sbar_result = save_reports(file_name, sbar_report_content, "SBAR", sbar_dir)
+    print(sbar_result)
+
+    # Vectorize the reports in the temporary directory
+    vectorise(temp_reports_dir, temp_vector_db)
+
+    # Check if report_vector_db is empty
+    if not os.listdir(report_vector_db):  # If report_vector_db is empty
+        # Copy all contents from temp_vector_db to report_vector_db
+        for item in os.listdir(temp_vector_db):
+            source_path = os.path.join(temp_vector_db, item)
+            destination_path = os.path.join(report_vector_db, item)
+            if os.path.isdir(source_path):
+                shutil.copytree(source_path, destination_path)
+            else:
+                shutil.copy2(source_path, destination_path)
+        print("Copied contents from temp_vector_db to report_vector_db.")
+    else:
+        # Call merge_vectors to merge temp_vector_db into report_vector_db
+        merge_vectors(temp_vector_db)
+        print("Merged temp_vector_db into report_vector_db.")
+
+    # Clean up by deleting the temporary directories
+    delete_dir(temp_reports_dir)
+    delete_dir(temp_vector_db)
+    print("Deleted temporary directories.")
+
+    return "Reports saved successfully!"
+
+
+"""#Page 2"""
+
+
+def refresh_files(docs_dir):
+    if not os.path.exists(docs_dir):
+        os.makedirs(docs_dir)
+
+    file_list = []
+
+    for root, dirs, files in os.walk(docs_dir):
+        for file in files:
+            file_list.append(file)
+    return gr.Dropdown(choices=file_list, interactive=True)
+
+
+def soap_refresh():
+    return refresh_files(soap_dir)
+
+
+def sbar_refresh():
+    return refresh_files(sbar_dir)
+
+
+def get_content(docs_dir, selected_file_name):
+    docx_path = os.path.join(docs_dir, selected_file_name)
+
+    # Check if the file exists and has a .docx extension
+    if not os.path.isfile(docx_path) or not docx_path.endswith(".docx"):
+        raise FileNotFoundError(
+            f"File {selected_file_name} not found in {docs_dir} or is not a .docx file."
+        )
+
+    try:
+        # Open and read the document
+        doc = docx.Document(docx_path)
+        paragraphs = [paragraph.text for paragraph in doc.paragraphs if paragraph.text]
+        return "\n\n".join(
+            paragraphs
+        )  # Join paragraphs with double newlines for readability
+
+    except Exception as e:
+        raise IOError(f"An error occurred while reading the document: {e}")
+
+
+def get_soap_report_content(selected_file_name):
+    return get_content(soap_dir, selected_file_name)
+
+
+def get_sbar_report_content(selected_file):
+    return get_content(sbar_dir, selected_file)
+
+
+# Updated generate_response function
+def generate_response(message, history, soap_content):
+    from openai import OpenAI
+
+    client = OpenAI()
+
+    # Format history as expected by OpenAI's API
+    formatted_history = [
+        {
+            "role": "system",
+            "content": "This conversation is based on the following SOAP report content:\n"
+            + soap_content,
+        }
+    ]
+    for interaction in history:
+        if len(interaction) == 2:
+            user, assistant = interaction
+            formatted_history.append({"role": "user", "content": user})
+            formatted_history.append({"role": "assistant", "content": assistant})
+
+    # Add the latest user message to the formatted history
+    formatted_history.append({"role": "user", "content": message})
+
+    # Generate the assistant's response with streaming enabled
+    response = client.chat.completions.create(
+        model="gpt-4o-mini", messages=formatted_history, stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message  # Yield each chunk as it comes
+
+
+# Updated handle_chat_message function
+def handle_chat_message(history, message, soap_content):
+    response_generator = generate_response(message, history, soap_content)
+    new_history = history + [
+        [message, ""]
+    ]  # Initialize with an empty assistant response
+    for partial_response in response_generator:
+        new_history[-1][1] = partial_response  # Update assistant's response in history
+        yield new_history, ""  # Stream the updated history and clear the text box
+
+
+def ask_reports(docs_dir, doc_name, question):
+    # Construct the path to the docx file
+    docx_path = os.path.join(docs_dir, doc_name)
+
+    # Read and extract text from the .docx file
+    doc = docx.Document(docx_path)
+    extracted_text = (
+        f"You are provided with a medical report of a patient {doc_name}.\n\n"
+    )
+    text = ""
+    for paragraph in doc.paragraphs:
+        text += paragraph.text + "\n"
+
+    # Append the question to extracted text
+    extracted_text = (
+        extracted_text
+        + text
+        + "\n\nUse the report to answer the following question:\n"
+        + question
+    )
+
+    if not text:
+        return "Failed to retrieve text from document."
+    from openai import OpenAI
+
+    client = OpenAI()
+    # Prepare the messages for the chat completion request
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a helpful assistant with medical expertise.",
+        },
+        {"role": "user", "content": extracted_text},
+    ]
+
+    # Use the ChatCompletion API to get a response
+    try:
+        completion = client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+        )
+        answer = completion.choices[0].message
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+    return answer
+
+
+def ask_soap(selected_file, question):
+    # Logic to answer the question based on the selected SOAP file
+    return f"Answer to '{question}' based on {selected_file}"
+
+
+def ask_sbar(selected_file, question):
+    # Logic to answer the question based on the selected SBAR file
+    return f"Answer to '{question}' based on {selected_file}"
+
+
+"""# page 3"""
+
+
+def local_search(question):
+    embeddings = OpenAIEmbeddings()
+    file_db = FAISS.load_local(
+        report_vector_db, embeddings, allow_dangerous_deserialization=True
+    )
+    docs = file_db.similarity_search(question)
+
+    chain = load_qa_chain(llm, chain_type="stuff")
+
+    with get_openai_callback() as cb:
+        response = chain.run(input_documents=docs, question=question)
+        print(cb)
+
+    return formatted_response_local(docs, response)
+
+
+def formatted_response_local(docs, response):
+    formatted_output = response + "\n\nSources"
+
+    for i, doc in enumerate(docs):
+        source_info = doc.metadata.get("source", "Unknown source")
+        page_info = doc.metadata.get("page", None)
+
+        file_name = source_info.split("/")[-1].strip()
+
+        if page_info is not None:
+            formatted_output += f"\n{file_name}\tpage no {page_info}"
+        else:
+            formatted_output += f"\n{file_name}"
+
+    return formatted_output
+
+
+def local_gpt(question):
+    template = """Question: {question}
+    Answer: Let's think step by step."""
+
+    prompt = PromptTemplate(template=template, input_variables=["question"])
+
+    llm_chain = LLMChain(prompt=prompt, llm=llm)
+    response = llm_chain.run(question)
+
+    return response
+
+
+"""# Page 4"""
+
+
+def save2_docs(docs):
+
+    import shutil
+    import os
+
+    output_dir = upload_dir
+
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for doc in docs:
+        shutil.copy(doc.name, output_dir)
+
+    return "Successful!"
+
+
+global agent2
+
+
+def create2_agent():
+
+    from langchain.chat_models import ChatOpenAI
+    from langchain.chains.conversation.memory import ConversationSummaryBufferMemory
+    from langchain.chains import ConversationChain
+
+    global agent2
+
+    llm = ChatOpenAI(model_name="gpt-4o-mini")
+    memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=1500)
+    agent2 = ConversationChain(llm=llm, memory=memory, verbose=True)
+
+    return "Successful!"
+
+
+def search2_docs(prompt, question, state):
+
+    from langchain.embeddings.openai import OpenAIEmbeddings
+    from langchain.vectorstores import FAISS
+    from langchain.callbacks import get_openai_callback
+
+    global agent2
+    agent2 = agent2
+
+    state = state or []
+
+    embeddings = OpenAIEmbeddings()
+    docs_db = FAISS.load_local(
+        upload_files_vector_db, embeddings, allow_dangerous_deserialization=True
+    )
+    docs = docs_db.similarity_search(question)
+
+    prompt += "\n\n"
+    prompt += question
+    prompt += "\n\n"
+    prompt += str(docs)
+
+    with get_openai_callback() as cb:
+        response = agent2.predict(input=prompt)
+        print(cb)
+
+    return formatted_response(docs, question, response, state)
+
+
+def delete2_docs():
+
+    import shutil
+
+    path1 = upload_dir
+    path2 = upload_files_vector_db
+
+    try:
+        shutil.rmtree(path1)
+        shutil.rmtree(path2)
+        return "Deleted Successfully"
+
+    except:
+        return "Already Deleted"
+
+
+def process2_docs():
+
+    from langchain.document_loaders import PyPDFLoader
+    from langchain.document_loaders import DirectoryLoader
+    from langchain.document_loaders import TextLoader
+    from langchain.document_loaders import Docx2txtLoader
+    from langchain.document_loaders.csv_loader import CSVLoader
+    from langchain.document_loaders import UnstructuredExcelLoader
+    from langchain.vectorstores import FAISS
+    from langchain.embeddings.openai import OpenAIEmbeddings
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    loader1 = DirectoryLoader(upload_dir, glob="./*.pdf", loader_cls=PyPDFLoader)
+    document1 = loader1.load()
+
+    loader2 = DirectoryLoader(upload_dir, glob="./*.txt", loader_cls=TextLoader)
+    document2 = loader2.load()
+
+    loader3 = DirectoryLoader(upload_dir, glob="./*.docx", loader_cls=Docx2txtLoader)
+    document3 = loader3.load()
+
+    loader4 = DirectoryLoader(upload_dir, glob="./*.csv", loader_cls=CSVLoader)
+    document4 = loader4.load()
+
+    loader5 = DirectoryLoader(
+        upload_dir, glob="./*.xlsx", loader_cls=UnstructuredExcelLoader
+    )
+    document5 = loader5.load()
+
+    document1.extend(document2)
+    document1.extend(document3)
+    document1.extend(document4)
+    document1.extend(document5)
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000, chunk_overlap=200, length_function=len
+    )
+
+    docs = text_splitter.split_documents(document1)
+    embeddings = OpenAIEmbeddings()
+
+    docs_db = FAISS.from_documents(docs, embeddings)
+    docs_db.save_local(upload_files_vector_db)
+
+    return "Successful!"
+
+
+def formatted_response(docs, question, response, state):
+
+    formatted_output = response + "\n\nSources"
+
+    for i, doc in enumerate(docs):
+        source_info = doc.metadata.get("source", "Unknown source")
+        page_info = doc.metadata.get("page", None)
+
+        doc_name = source_info.split("/")[-1].strip()
+
+        if page_info is not None:
+            formatted_output += f"\n{doc_name}\tpage no {page_info}"
+        else:
+            formatted_output += f"\n{doc_name}"
+
+    state.append((question, formatted_output))
+    return state, state
+
+
+"""# UI"""
+
+import gradio as gr
+
+css = """
+.col {
+    max-width: 70%;
+    margin: 0 auto;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+}
+"""
+
+# Define the Gradio interface
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("## <center>Medical App</center>")
+    # Page 1----------------------------------------------------------------------
+    with gr.Tab("SOAP and SBAR Note Creation"):
+        # Tab for generating from audio
+        with gr.Tab("From Audio"):
+            with gr.Row():
+                with gr.Column():
+                    audio_file = gr.Audio(label="Audio Input", type="filepath")
+                with gr.Column():
+                    transcription_service = gr.Dropdown(
+                        label="Select Transcription Service",
+                        choices=["OpenAI", "AssemblyAI"],
+                        value="OpenAI",
+                    )
+                    gr.Markdown(
+                        "<small>Upload an audio file or select a transcription service.</small>"
+                    )
+                    generate_with_audio_button = gr.Button(
+                        "Generate Report", variant="primary"
+                    )
+
+            # Shared output containers
+            audio_patient_name_box = gr.Textbox(
+                label="Patient Name",
+                interactive=True,
+                placeholder="Generated Patient Name",
+                lines=1,
+            )
+            with gr.Row():
+                with gr.Column():
+                    audio_soap_report_box = gr.Textbox(
+                        label="SOAP Report",
+                        interactive=True,
+                        placeholder="Generated SOAP Report",
+                        lines=10,
+                    )
+                with gr.Column():
+                    audio_sbar_report_box = gr.Textbox(
+                        label="SBAR Report",
+                        interactive=True,
+                        placeholder="Generated SBAR Report",
+                        lines=10,
+                    )
+
+            audio_doctor_recommendations_box = gr.Textbox(
+                label="Doctor Recommendations",
+                interactive=False,
+                placeholder="Recommendations",
+                lines=5,
+            )
+            # audio_transcription_box = gr.Textbox(label="Transcription Text", interactive=False, placeholder="Transcribed Text", lines=5)
+
+            # Click event for audio
+            generate_with_audio_button.click(
+                fn=report_main,
+                inputs=[audio_file, transcription_service],
+                outputs=[
+                    audio_patient_name_box,
+                    audio_soap_report_box,
+                    audio_sbar_report_box,
+                    audio_doctor_recommendations_box,
+                    # audio_transcription_box
+                ],
+            )
+
+        # Tab for generating from text input
+        with gr.Tab("From Transcript"):
+            with gr.Column():
+                input_text = gr.Textbox(
+                    label="Patient Case Study (Text Input)",
+                    placeholder="Enter the patient case study here...",
+                    lines=7,
+                )
+                gr.Markdown(
+                    "<small>Enter the patient's details, symptoms, and any relevant information.</small>"
+                )
+                generate_with_text_button = gr.Button(
+                    "Generate Report", variant="primary"
+                )
+
+                # Shared output containers for this tab
+                patient_name_box_text = gr.Textbox(
+                    label="Patient Name",
+                    interactive=True,
+                    placeholder="Generated Patient Name",
+                    lines=1,
+                )
+                with gr.Row():
+                    with gr.Column():
+                        soap_report_box_text = gr.Textbox(
+                            label="SOAP Report",
+                            interactive=True,
+                            placeholder="Generated SOAP Report",
+                            lines=10,
+                        )
+                    with gr.Column():
+                        sbar_report_box_text = gr.Textbox(
+                            label="SBAR Report",
+                            interactive=True,
+                            placeholder="Generated SBAR Report",
+                            lines=10,
+                        )
+
+                doctor_recommendations_box_text = gr.Textbox(
+                    label="Doctor Recommendations",
+                    interactive=False,
+                    placeholder="Recommendations",
+                    lines=5,
+                )
+
+                # Click event for text
+                generate_with_text_button.click(
+                    fn=report_main,
+                    inputs=[input_text],
+                    outputs=[
+                        patient_name_box_text,
+                        soap_report_box_text,
+                        sbar_report_box_text,
+                        doctor_recommendations_box_text,
+                    ],
+                )
+        # Add Save Report Button
+        with gr.Row():
+            save_button = gr.Button("Save Report", variant="secondary")
+            save_message = gr.Textbox(
+                label="Save Status",
+                interactive=False,
+                placeholder="Status of the save operation",
+                lines=1,
+            )
+
+        # Click event for Save Report Button using `patient_name_box_text` as the file name
+        save_button.click(
+            fn=save_reports_main,
+            inputs=[patient_name_box_text, soap_report_box_text, sbar_report_box_text],
+            outputs=[save_message],
+        )
+
+    # Page 2----------------------------------------------------------------------
+    ####|
+    with gr.Tab("SOAP and SBAR Queries"):
+
+        with gr.Tab("Query SOAP Reports"):
+            with gr.Row():
+                with gr.Column():
+                    soap_refresh_button = gr.Button("Refresh")
+                    ask_soap_input = gr.Dropdown(label="Choose File")
+                    soap_content_display = gr.Textbox(
+                        label="SOAP Report Content",
+                        interactive=False,
+                        placeholder="Report content will appear here...",
+                        lines=5,
+                    )
+                with gr.Column():
+                    # Chatbot for Q&A
+                    soap_chatbot = gr.Chatbot(label="SOAP Chatbot")
+                    soap_chat_input = gr.Textbox(
+                        label="Ask a question",
+                        placeholder="Enter your question here...",
+                    )
+                    clear = gr.ClearButton([soap_chat_input, soap_chatbot])
+
+                # Refresh button for SOAP file dropdown
+                soap_refresh_button.click(
+                    fn=soap_refresh, inputs=None, outputs=ask_soap_input
+                )
+
+                # Display selected SOAP report content
+                ask_soap_input.change(
+                    fn=get_soap_report_content,
+                    inputs=ask_soap_input,
+                    outputs=soap_content_display,
+                )
+
+                # Handle chatbot input submission with streaming response
+                soap_chat_input.submit(
+                    handle_chat_message,
+                    inputs=[soap_chatbot, soap_chat_input, soap_content_display],
+                    outputs=[soap_chatbot, soap_chat_input],
+                )
+
+        # Query SBAR Reports Tab
+        with gr.Tab("Query SBAR Reports"):
+            with gr.Row():
+                with gr.Column():
+                    sbar_refresh_button = gr.Button("Refresh")
+                    ask_sbar_input = gr.Dropdown(label="Choose File")
+                    sbar_content_display = gr.Textbox(
+                        label="SBAR Report Content",
+                        interactive=False,
+                        placeholder="Report content will appear here...",
+                        lines=5,
+                    )
+                with gr.Column():
+                    # Chatbot for SBAR Q&A
+                    sbar_chatbot = gr.Chatbot(label="SBAR Chatbot")
+                    sbar_chat_input = gr.Textbox(
+                        label="Ask a question",
+                        placeholder="Enter your question here...",
+                    )
+                    clear_sbar = gr.ClearButton([sbar_chat_input, sbar_chatbot])
+
+                # Refresh button for SBAR file dropdown
+                sbar_refresh_button.click(
+                    fn=sbar_refresh, inputs=None, outputs=ask_sbar_input
+                )
+
+                # Display selected SBAR report content
+                ask_sbar_input.change(
+                    fn=get_sbar_report_content,
+                    inputs=ask_sbar_input,
+                    outputs=sbar_content_display,
+                )
+
+                # Handle chatbot input submission with streaming response
+                sbar_chat_input.submit(
+                    handle_chat_message,
+                    inputs=[
+                        sbar_chatbot,
+                        sbar_chat_input,
+                        sbar_content_display,
+                    ],  # Pass the SBAR content
+                    outputs=[sbar_chatbot, sbar_chat_input],
+                )
+
+    # Page 3----------------------------------------------------------------------
+    ####|Chatbot to query all SOAP and SBAR reports (RAG). Chatbot can ask OpenAI for answers directly
+    with gr.Tab("All Queries"):
+        with gr.Column(elem_classes="col"):
+            local_search_input = gr.Textbox(label="Enter Question here")
+            local_search_button = gr.Button("Search")
+            local_search_output = gr.Textbox(label="Output")
+
+            local_gpt_button = gr.Button("Ask ChatGPT")
+            local_gpt_output = gr.Textbox(label="Output")
+
+    local_search_button.click(
+        local_search, inputs=local_search_input, outputs=local_search_output
+    )
+    local_gpt_button.click(
+        local_gpt, inputs=local_search_input, outputs=local_gpt_output
+    )
+
+    # Page 4----------------------------------------------------------------------
+    ####|
+    with gr.Tab("Documents Queries"):
+        with gr.Column(elem_classes="col"):
+
+            with gr.Tab("Upload and Process Documents"):
+                with gr.Column():
+                    docs2_upload_input = gr.Files(label="Upload File(s)")
+                    docs2_upload_button = gr.Button("Upload")
+                    docs2_upload_output = gr.Textbox(label="Output")
+
+                    docs2_process_button = gr.Button("Process")
+                    docs2_process_output = gr.Textbox(label="Output")
+
+                    create2_agent_button = gr.Button("Create Agent")
+                    create2_agent_output = gr.Textbox(label="Output")
+
+                    gr.ClearButton(
+                        [
+                            docs2_upload_input,
+                            docs2_upload_output,
+                            docs2_process_output,
+                            create2_agent_output,
+                        ]
+                    )
+
+                    docs2_upload_button.click(
+                        save2_docs,
+                        inputs=docs2_upload_input,
+                        outputs=docs2_upload_output,
+                    )
+                    docs2_process_button.click(
+                        process2_docs, inputs=None, outputs=docs2_process_output
+                    )
+                    create2_agent_button.click(
+                        create2_agent, inputs=None, outputs=create2_agent_output
+                    )
+
+            with gr.Tab("Query Documents"):
+                with gr.Column():
+                    docs2_prompt_input = gr.Textbox(label="Custom Prompt")
+
+                    docs2_chatbot = gr.Chatbot(label="Chats")
+                    docs2_state = gr.State()
+
+                    docs2_search_input = gr.Textbox(label="Enter Question")
+                    docs2_search_button = gr.Button("Search")
+
+                    docs2_delete_button = gr.Button("Delete")
+                    docs2_delete_output = gr.Textbox(label="Output")
+
+                    gr.ClearButton(
+                        [docs2_prompt_input, docs2_search_input, docs2_delete_output]
+                    )
+                    docs2_search_button.click(
+                        search2_docs,
+                        inputs=[docs2_prompt_input, docs2_search_input, docs2_state],
+                        outputs=[docs2_chatbot, docs2_state],
+                    )
+                    docs2_delete_button.click(
+                        delete2_docs, inputs=None, outputs=docs2_delete_output
+                    )
+
+demo.launch(debug=True)

requirements.txt

@@ -0,0 +1,12 @@
+pypdf
+langchain 
+PyPDF2 
+docx2txt 
+gradio 
+faiss-cpu 
+openai==1.52.2 
+assemblyai 
+python-docx 
+langchain-community 
+tiktoken 
+langchain-openai==0.2.4