Upload 5 files

app.py

@@ -0,0 +1,699 @@
+from fastapi import FastAPI, HTTPException
+import streamlit as st
+import pandas as pd
+from pydantic import BaseModel, Field, validator
+import numpy as np
+import plotly.graph_objects as go
+
+from azure_openai import converse_with_patient, create_diagnosis 
+from memory import get_conversation, store_conversation, update_conversation
+import uuid
+
+class ask_question (BaseModel):
+    user_input: str
+    id: str
+
+app = FastAPI()
+
+
+def generate_expert_confidence_chart(diagnosis):
+    """
+    Extracts expert confidence data from JSON and generates a multi-colored bar chart.
+    """
+
+    # Extract expert distribution data
+    expert_distribution = diagnosis["expert_distribution"]
+
+    # Process the data into a structured format
+    rows = []
+    for key, value in expert_distribution.items():
+        expert, attribute = key.rsplit(", ", 1)  # Ensure splitting at the last comma
+        rows.append({"Expert": expert, "Attribute": attribute, "Value": value})
+
+    # Create a DataFrame
+    df = pd.DataFrame(rows)
+
+    # Filter the DataFrame for confidence values only
+    df_confidence = df[df["Attribute"] == "confidence"].copy()
+
+    # Merge confidence values with corresponding thinking explanations
+    df_thinking = df[df["Attribute"] == "thinking"].copy()
+    df_confidence = df_confidence.merge(df_thinking, on="Expert", suffixes=("_confidence", "_thinking"))
+
+    # Convert confidence values to numeric
+    df_confidence["Value_confidence"] = pd.to_numeric(df_confidence["Value_confidence"])
+
+    # Define a function to map confidence scores to colors
+    def confidence_to_color(confidence):
+        """
+        Maps confidence score (0-100) to a blended color between red (0 confidence) and green (100 confidence).
+        """
+        red = np.array([255, 0, 0])
+        green = np.array([0, 255, 0])
+        blend_ratio = confidence / 100  # Normalize between 0 and 1
+        blended_color = (1 - blend_ratio) * red + blend_ratio * green
+        return f"rgb({int(blended_color[0])}, {int(blended_color[1])}, {int(blended_color[2])})"
+
+    # Apply color mapping
+    df_confidence["Color"] = df_confidence["Value_confidence"].apply(confidence_to_color)
+
+    # Create the bar chart
+    fig = go.Figure()
+
+    # Add bars with customized colors and reduced spacing
+    fig.add_trace(go.Bar(
+        y=df_confidence["Expert"],
+        x=df_confidence["Value_confidence"],
+        text=df_confidence["Value_confidence"],
+        hovertext=df_confidence["Value_thinking"],
+        orientation="h",
+        marker=dict(color=df_confidence["Color"]),
+        width=0.3,  # Reduce bar width for closer spacing
+        textposition="inside"
+    ))
+
+    # Update layout for better visibility
+    fig.update_layout(
+        title="Expert Confidence in Diagnosis",
+        xaxis_title="Confidence Score",
+        yaxis_title="Medical Expert",
+        yaxis=dict(tickmode="linear", dtick=1, automargin=True),
+        height=max(400, 40 * len(df_confidence)),  # Adjust height dynamically
+        bargap=0.1  # Reduce spacing between bars
+    )
+
+    # Update hover template
+    fig.update_traces(
+        hovertemplate="<b>%{y}</b><br>Confidence: %{x}%<br>Thinking: %{hovertext}"
+    )
+
+    # Show the plot
+    return fig
+
+
+# FastAPI interface routes
+# @app.get("/")
+# async def root():
+#     return {"message": "Welcome to the GenAI Symptom Checker"}
+
+# @app.post("/ask")
+# async def ask_question(question: ask_question):
+#     try:
+#         user_input = question.user_input
+#         conversation_id = question.id
+   
+#         exists, count, conversation_obj = get_conversation(conversation_id)
+#         if count == 6:
+#             response = converse_with_patient(conversation_obj, user_input)
+#             store_conversation(conversation_id, conversation_id, user_input, response)
+#             exists, count, conversation_obj = get_conversation(conversation_id)
+#             diagnosis = create_diagnosis(conversation_obj)
+#             return {"response": response, "count": count, "diagnosis": diagnosis}
+#         if count > 6:
+#             exists, count, conversation_obj = get_conversation(conversation_id)
+#             diagnosis_content = next((item['content'] for item in conversation_obj if item['role'] == 'diagnosis'), None)
+#             return {"response": "You have reached the maximum number of questions", "count": count, "diagnosis": diagnosis_content}
+#         if exists == "PASS":
+#             response = converse_with_patient(conversation_obj, user_input)
+#             update_conversation(conversation_id, conversation_id, user_input, response)
+#             return {"response": response, "count": count, "diagnosis": "none"}
+        
+#         else:
+#             response = converse_with_patient("",user_input)
+#             store_conversation(conversation_id, conversation_id, user_input, response)
+#             return {"response": response, "count": count, "diagnosis": "none"}
+
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+
+# app config
+
+st.set_page_config(page_title="virtual clinician", page_icon=":medical_symbol:")
+st.title("Virtual Clinician :medical_symbol:")
+
+user_id = st.text_input("Name:", key="user_id")
+
+conversation_id = user_id
+# Ensure user_id is defined or fallback to a default value
+if not user_id:
+    st.warning("Hi, Who am I speaking with?")
+else:
+        # session state
+        if "chat_history" not in st.session_state:
+            st.session_state.chat_history = [
+                {"role": "AI", "content": f"Hello, {user_id} I am the virtual clinician. How can I help you today?"},
+            ]
+
+
+        # conversation
+        for message in st.session_state.chat_history:
+            if message["role"] == "AI":
+                with st.chat_message("AI"):
+                    st.write(message["content"])
+            elif message["role"] == "Human":
+                with st.chat_message("Human"):
+                    st.write(message["content"])
+
+        # user input
+        user_input = st.chat_input("Type your message here...")
+        if user_input is not None and user_input != "":
+            st.session_state.chat_history.append({"role": "Human", "content": user_input})
+        
+
+            with st.chat_message("Human"):
+                st.markdown(user_input)
+
+            # this functions checks to see if the conversation exists
+            exists, count, conversation_obj = get_conversation(conversation_id)
+            # if the conversation does not exist, it creates a new conversation 
+
+
+            if count > 5:
+                response = converse_with_patient(conversation_obj, user_input)
+                conversation_obj = update_conversation(conversation_id, user_input, response)
+                print(conversation_obj)
+                with st.spinner("Creating a diagnosis..."):
+                    outcome, diagnosis = create_diagnosis(conversation_obj)
+                    if outcome == "SUCCESS":
+                        st.subheader("Diagnosis Summary")
+                        st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+                        st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+                        st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+                        st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+                        st.write(f"**Next Best Action:** {diagnosis['next_best_action_']}")
+                        st.write(f"**Next Best Action Explanation:** {diagnosis['next_best_action_explanation']}")
+                        st.write(f"**Next Best Action Confidence:** {diagnosis['next_best_action_confidence']}%")
+
+                        # Generate and display the plotly chart
+                        st.subheader("Expert Confidence Levels")
+                        fig = generate_expert_confidence_chart(diagnosis)
+                        st.plotly_chart(fig)
+
+                    # if the diagnosis is not successful, display a message
+                    if outcome == "FAIL1":
+                        st.write("Diagnosis not available Failed to find concensus")
+                        st.subheader("Incomplete Diagnosis")
+                        st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+                        st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+                        st.write(f"**Next Best Action:** See GP")
+                        st.write(f"**Next Best Action Explanation:** Please give more details to help the AI better understand your symptoms ")
+
+                        # Generate and display the plotly chart
+                        st.subheader("Expert Confidence Levels")
+                        fig = generate_expert_confidence_chart(diagnosis)
+                        st.plotly_chart(fig)
+
+                    if outcome == "FAIL1":
+                        st.write("Diagnosis not available Failed to match described symptoms with know symptoms  for AI diagnosis")
+                        st.subheader("Incomplete Diagnosis")
+                        st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+                        st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+                        st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+                        st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+                        st.write(f"**Next Best Action:** See GP")
+                        st.write(f"**Next Best Action Explanation:** Please give more details to help the AI better understand your symptoms ")
+
+                        # Generate and display the plotly chart
+                        st.subheader("Expert Confidence Levels")
+                        fig = generate_expert_confidence_chart(diagnosis)
+                        st.plotly_chart(fig)
+            
+            if exists == "PASS":
+                    response = converse_with_patient(conversation_obj, user_input)
+                    update_conversation(conversation_id, user_input, response)
+                    st.session_state.chat_history.append({"role": "AI", "content": response})  
+                    with st.chat_message("AI"):
+                        st.write(response) 
+                
+            else:
+                    response = converse_with_patient("",user_input)
+                    store_conversation(conversation_id, user_input, response)
+                    st.session_state.chat_history.append({"role": "AI", "content": response})    
+                    with st.chat_message("AI"):
+                        st.write(response)
+
+
+
+
+
+
+
+
+
+
+    # if exists == "FAIL":
+    #     response = converse_with_patient("",user_query)
+    #     store_conversation(conversation_id, user_query, response)
+    #     st.session_state.chat_history.append({"role": "AI", "content": response})
+
+    # # if the conversation exists use it to inform the AI's context
+    # response = converse_with_patient(st.session_state.chat_history, user_query)
+    # # update the conversation with the new response
+    # update_conversation(conversation_id, user_query, response)
+    # once 6 interactions have been made, the AI will generate a diagnosis
+    # if count > 6:
+    #     # write last question to the chat log
+    #     st.session_state.chat_history.append({"role": "Human", "content": user_query})
+    #     # get an AI response
+    #     response_data = converse_with_patient(st.session_state.chat_history, user_query)
+    #     # write AI response to the chat
+    #     st.session_state.chat_history.append({"role": "AI", "content": response_data})
+    #     # send conversation to the AI to generate a diagnosis
+    #     outcome, diagnosis = create_diagnosis(conversation_obj)
+    #     # if the diagnosis is successful, display the diagnosis data
+    #     if outcome == "PASS":
+    #         st.subheader("Diagnosis Summary")
+    #         st.write(f"**Consensus Confidence:** {['concensus_confidence']}%")
+    #         st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+    #         st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+    #         st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+    #         st.write(f"**Next Best Action:** {diagnosis['next_best_action_']}")
+    #         st.write(f"**Next Best Action Explanation:** {diagnosis['next_best_action_explanation']}")
+    #         st.write(f"**Next Best Action Confidence:** {diagnosis['next_best_action_confidence']}%")
+
+    #         # Generate and display the plotly chart
+    #         st.subheader("Expert Confidence Levels")
+    #         fig = generate_expert_confidence_chart(diagnosis)
+    #         st.plotly_chart(fig)
+
+    #     # if the diagnosis is not successful, display a message
+    #     else:
+    #         st.write("Diagnosis not available")
+
+
+  
+
+
+
+
+# from fastapi import FastAPI, HTTPException
+# import streamlit as st
+# import pandas as pd
+# from pydantic import BaseModel
+# import numpy as np
+# import plotly.graph_objects as go
+
+# from azure_openai import converse_with_patient, create_diagnosis 
+# from memory import get_conversation, store_conversation, update_conversation, retrieve_conversation
+
+# class AskQuestion(BaseModel):
+#     user_input: str
+#     id: str
+
+# app = FastAPI()
+
+# def generate_expert_confidence_chart(diagnosis):
+#     """
+#     Extracts expert confidence data from JSON and generates a multi-colored bar chart.
+#     """
+#     expert_distribution = diagnosis.get("expert_distribution", {})
+#     rows = []
+#     for key, value in expert_distribution.items():
+#         expert, attribute = key.rsplit(", ", 1)
+#         rows.append({"Expert": expert, "Attribute": attribute, "Value": value})
+#     df = pd.DataFrame(rows)
+#     df_confidence = df[df["Attribute"] == "confidence"].copy()
+#     df_thinking = df[df["Attribute"] == "thinking"].copy()
+#     df_confidence = df_confidence.merge(df_thinking, on="Expert", suffixes=("_confidence", "_thinking"))
+#     df_confidence["Value_confidence"] = pd.to_numeric(df_confidence["Value_confidence"])
+
+#     def confidence_to_color(confidence):
+#         red = np.array([255, 0, 0])
+#         green = np.array([0, 255, 0])
+#         blend_ratio = confidence / 100
+#         blended_color = (1 - blend_ratio) * red + blend_ratio * green
+#         return f"rgb({int(blended_color[0])}, {int(blended_color[1])}, {int(blended_color[2])})"
+    
+#     df_confidence["Color"] = df_confidence["Value_confidence"].apply(confidence_to_color)
+#     fig = go.Figure()
+#     fig.add_trace(go.Bar(
+#         y=df_confidence["Expert"],
+#         x=df_confidence["Value_confidence"],
+#         text=df_confidence["Value_confidence"],
+#         hovertext=df_confidence["Value_thinking"],
+#         orientation="h",
+#         marker=dict(color=df_confidence["Color"]),
+#         width=0.3,
+#         textposition="inside"
+#     ))
+#     fig.update_layout(
+#         title="Expert Confidence in Diagnosis",
+#         xaxis_title="Confidence Score",
+#         yaxis_title="Medical Expert",
+#         yaxis=dict(tickmode="linear", dtick=1, automargin=True),
+#         height=max(400, 40 * len(df_confidence)),
+#         bargap=0.1
+#     )
+#     fig.update_traces(
+#         hovertemplate="<b>%{y}</b><br>Confidence: %{x}%<br>Thinking: %{hovertext}"
+#     )
+#     return fig
+
+# conversation_id = "111a1"
+# st.set_page_config(page_title="Virtual Clinician", page_icon="🤖")
+# st.title("Virtual Clinician :toolbox:")
+
+# if "chat_history" not in st.session_state:
+#     st.session_state.chat_history = [
+#         {"role": "AI", "content": "Hello, I am the virtual clinician. How can I help you today?"},
+#     ]
+
+# for message in st.session_state.chat_history:
+#     with st.chat_message(message["role"]):
+#         st.write(message["content"])
+
+# user_query = st.chat_input("Type your message here...")
+# if user_query:
+#     st.session_state.chat_history.append({"role": "Human", "content": user_query})
+#     with st.chat_message("Human"):
+#         st.markdown(user_query)
+
+#     exists, count, conversation_obj = get_conversation(conversation_id)
+
+#     if exists == "FAIL":
+#         response_data = converse_with_patient("", user_query)
+#         st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#         store_conversation(conversation_id, user_query, response_data)
+        
+        
+#     else:
+#         response_data = converse_with_patient(st.session_state.chat_history, user_query)
+#         st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#         update_conversation(conversation_id, conversation_id, user_query, response_data)
+        
+    
+#     if count >= 6:
+#         st.session_state.chat_history.append({"role": "Human", "content": user_query})
+#         response_data = converse_with_patient(st.session_state.chat_history, user_query)
+#         st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#         outcome, diagnosis = create_diagnosis(conversation_obj)
+#         if outcome == "PASS":
+#             st.subheader("Diagnosis Summary")
+#             st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+#             st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+#             st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+#             st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+#             st.write(f"**Next Best Action:** {diagnosis['next_best_action_']}")
+#             st.write(f"**Next Best Action Explanation:** {diagnosis['next_best_action_explanation']}")
+#             st.write(f"**Next Best Action Confidence:** {diagnosis['next_best_action_confidence']}%")
+#             st.subheader("Expert Confidence Levels")
+#             fig = generate_expert_confidence_chart(diagnosis)
+#             st.plotly_chart(fig)
+#         else:
+#             st.write("Diagnosis not available")
+
+    
+#     st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#     with st.chat_message("AI"):
+#         st.write(response_data)
+
+# from fastapi import FastAPI, HTTPException
+# import streamlit as st
+# import pandas as pd
+# from pydantic import BaseModel
+# import numpy as np
+# import plotly.graph_objects as go
+
+# from azure_openai import converse_with_patient, create_diagnosis 
+# from memory import get_conversation, store_conversation, update_conversation, retrieve_conversation
+
+# class AskQuestion(BaseModel):
+#     user_input: str
+#     id: str
+
+# app = FastAPI()
+
+# def generate_expert_confidence_chart(diagnosis):
+#     """
+#     Extracts expert confidence data from JSON and generates a multi-colored bar chart.
+#     """
+#     expert_distribution = diagnosis.get("expert_distribution", {})
+#     rows = []
+#     for key, value in expert_distribution.items():
+#         expert, attribute = key.rsplit(", ", 1)
+#         rows.append({"Expert": expert, "Attribute": attribute, "Value": value})
+#     df = pd.DataFrame(rows)
+#     df_confidence = df[df["Attribute"] == "confidence"].copy()
+#     df_thinking = df[df["Attribute"] == "thinking"].copy()
+#     df_confidence = df_confidence.merge(df_thinking, on="Expert", suffixes=("_confidence", "_thinking"))
+#     df_confidence["Value_confidence"] = pd.to_numeric(df_confidence["Value_confidence"])
+
+#     def confidence_to_color(confidence):
+#         red = np.array([255, 0, 0])
+#         green = np.array([0, 255, 0])
+#         blend_ratio = confidence / 100
+#         blended_color = (1 - blend_ratio) * red + blend_ratio * green
+#         return f"rgb({int(blended_color[0])}, {int(blended_color[1])}, {int(blended_color[2])})"
+    
+#     df_confidence["Color"] = df_confidence["Value_confidence"].apply(confidence_to_color)
+#     fig = go.Figure()
+#     fig.add_trace(go.Bar(
+#         y=df_confidence["Expert"],
+#         x=df_confidence["Value_confidence"],
+#         text=df_confidence["Value_confidence"],
+#         hovertext=df_confidence["Value_thinking"],
+#         orientation="h",
+#         marker=dict(color=df_confidence["Color"]),
+#         width=0.3,
+#         textposition="inside"
+#     ))
+#     fig.update_layout(
+#         title="Expert Confidence in Diagnosis",
+#         xaxis_title="Confidence Score",
+#         yaxis_title="Medical Expert",
+#         yaxis=dict(tickmode="linear", dtick=1, automargin=True),
+#         height=max(400, 40 * len(df_confidence)),
+#         bargap=0.1
+#     )
+#     fig.update_traces(
+#         hovertemplate="<b>%{y}</b><br>Confidence: %{x}%<br>Thinking: %{hovertext}"
+#     )
+#     return fig
+
+# conversation_id = "111a1"
+# st.set_page_config(page_title="Virtual Clinician", page_icon="🤖")
+# st.title("Virtual Clinician :toolbox:")
+
+# if "chat_history" not in st.session_state:
+#     st.session_state.chat_history = get_conversation(conversation_id)[2] or [
+#         {"role": "AI", "content": "Hello, I am the virtual clinician. How can I help you today?"},
+#     ]
+
+# for message in st.session_state.chat_history:
+#     with st.chat_message(message["role"]):
+#         st.write(message["content"])
+
+# user_query = st.chat_input("Type your message here...")
+# if user_query:
+#     st.session_state.chat_history.append({"role": "Human", "content": user_query})
+#     with st.chat_message("Human"):
+#         st.markdown(user_query)
+    
+#     exists, count, conversation_obj = get_conversation(conversation_id)
+#     if not exists:
+#         response_data = converse_with_patient("", user_query)
+#         st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#         store_conversation(conversation_id, conversation_id, user_query, response_data)
+        
+    
+#     response_data = converse_with_patient(st.session_state.chat_history, user_query)
+#     st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#     update_conversation(conversation_id, conversation_id, user_query, response_data)
+    
+#     if count >= 6:
+#         outcome, diagnosis = create_diagnosis(conversation_obj)
+#         if outcome == "PASS":
+#             st.subheader("Diagnosis Summary")
+#             st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+#             st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+#             st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+#             st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+#             st.write(f"**Next Best Action:** {diagnosis['next_best_action_']}")
+#             st.write(f"**Next Best Action Explanation:** {diagnosis['next_best_action_explanation']}")
+#             st.write(f"**Next Best Action Confidence:** {diagnosis['next_best_action_confidence']}%")
+#             st.subheader("Expert Confidence Levels")
+#             fig = generate_expert_confidence_chart(diagnosis)
+#             st.plotly_chart(fig)
+#         else:
+#             st.write("Diagnosis not available")
+    
+#     with st.chat_message("AI"):
+#         st.write(response_data)
+    
+#     store_conversation(conversation_id, conversation_id, "", st.session_state.chat_history)
+
+# from fastapi import FastAPI, HTTPException
+# import streamlit as st
+# import pandas as pd
+# from pydantic import BaseModel
+# import numpy as np
+# import plotly.graph_objects as go
+
+# from azure_openai import converse_with_patient, create_diagnosis 
+# from memory import get_conversation, store_conversation, update_conversation, retrieve_conversation
+
+# class AskQuestion(BaseModel):
+#     user_input: str
+#     id: str
+
+# app = FastAPI()
+
+# def generate_expert_confidence_chart(diagnosis):
+#     """
+#     Extracts expert confidence data from JSON and generates a multi-colored bar chart.
+#     """
+#     expert_distribution = diagnosis.get("expert_distribution", {})
+#     rows = []
+#     for key, value in expert_distribution.items():
+#         expert, attribute = key.rsplit(", ", 1)
+#         rows.append({"Expert": expert, "Attribute": attribute, "Value": value})
+#     df = pd.DataFrame(rows)
+#     df_confidence = df[df["Attribute"] == "confidence"].copy()
+#     df_thinking = df[df["Attribute"] == "thinking"].copy()
+#     df_confidence = df_confidence.merge(df_thinking, on="Expert", suffixes=("_confidence", "_thinking"))
+#     df_confidence["Value_confidence"] = pd.to_numeric(df_confidence["Value_confidence"])
+
+#     def confidence_to_color(confidence):
+#         red = np.array([255, 0, 0])
+#         green = np.array([0, 255, 0])
+#         blend_ratio = confidence / 100
+#         blended_color = (1 - blend_ratio) * red + blend_ratio * green
+#         return f"rgb({int(blended_color[0])}, {int(blended_color[1])}, {int(blended_color[2])})"
+    
+#     df_confidence["Color"] = df_confidence["Value_confidence"].apply(confidence_to_color)
+#     fig = go.Figure()
+#     fig.add_trace(go.Bar(
+#         y=df_confidence["Expert"],
+#         x=df_confidence["Value_confidence"],
+#         text=df_confidence["Value_confidence"],
+#         hovertext=df_confidence["Value_thinking"],
+#         orientation="h",
+#         marker=dict(color=df_confidence["Color"]),
+#         width=0.3,
+#         textposition="inside"
+#     ))
+#     fig.update_layout(
+#         title="Expert Confidence in Diagnosis",
+#         xaxis_title="Confidence Score",
+#         yaxis_title="Medical Expert",
+#         yaxis=dict(tickmode="linear", dtick=1, automargin=True),
+#         height=max(400, 40 * len(df_confidence)),
+#         bargap=0.1
+#     )
+#     fig.update_traces(
+#         hovertemplate="<b>%{y}</b><br>Confidence: %{x}%<br>Thinking: %{hovertext}"
+#     )
+#     return fig
+
+# conversation_id = "111a1"
+# st.set_page_config(page_title="Virtual Clinician", page_icon="🤖")
+# st.title("Virtual Clinician :toolbox:")
+
+# if "chat_history" not in st.session_state:
+#     st.session_state.chat_history = get_conversation(conversation_id)[2] or [
+#         {"role": "AI", "content": "Hello, I am the virtual clinician. How can I help you today?"},
+#     ]
+
+# for message in st.session_state.chat_history:
+#     with st.chat_message(message["role"]):
+#         st.write(message["content"])
+
+# user_query = st.chat_input("Type your message here...")
+# if user_query:
+#     st.session_state.chat_history.append({"role": "Human", "content": user_query})
+#     with st.chat_message("Human"):
+#         st.markdown(user_query)
+    
+#     exists, count, conversation_obj = get_conversation(conversation_id)
+#     if not exists:
+#         response = converse_with_patient("", user_query)
+#         store_conversation(conversation_id, conversation_id, user_query, response)
+#         exists, count, conversation_obj = get_conversation(conversation_id)
+    
+#     response_data = converse_with_patient(st.session_state.chat_history, user_query)
+#     st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#     update_conversation(conversation_id, conversation_id, user_query, response_data)
+    
+#     if count >= 6:
+#         outcome, diagnosis = create_diagnosis(conversation_obj)
+#         if outcome == "PASS":
+#             st.subheader("Diagnosis Summary")
+#             st.write(f"**Consensus Confidence:** {diagnosis['concensus_confidence']}%")
+#             st.write(f"**Consensus Thinking:** {diagnosis['concensus_thinking']}")
+#             st.write(f"**Evaluation Confidence:** {diagnosis['evaluate_confidence']}%")
+#             st.write(f"**Evaluation Explanation:** {diagnosis['evaluate_explanation']}")
+#             st.write(f"**Next Best Action:** {diagnosis['next_best_action_']}")
+#             st.write(f"**Next Best Action Explanation:** {diagnosis['next_best_action_explanation']}")
+#             st.write(f"**Next Best Action Confidence:** {diagnosis['next_best_action_confidence']}%")
+#             st.subheader("Expert Confidence Levels")
+#             fig = generate_expert_confidence_chart(diagnosis)
+#             st.plotly_chart(fig)
+#         else:
+#             st.write("Diagnosis not available")
+    
+#     with st.chat_message("AI"):
+#         st.write(response_data)
+    
+#     store_conversation(conversation_id, conversation_id, "", st.session_state.chat_history)
+
+# conversation_id = "111a1"
+# st.set_page_config(page_title="Virtual Clinician", page_icon="🤖")
+# st.title("Virtual Clinician :toolbox:")
+
+# # Fetch conversation history and ensure it's a list of dictionaries
+# exists, count, conversation_obj = get_conversation(conversation_id)
+
+# if "chat_history" not in st.session_state:
+#     if isinstance(conversation_obj, list) and all(isinstance(item, dict) for item in conversation_obj):
+#         st.session_state.chat_history = conversation_obj
+#     else:
+#         st.session_state.chat_history = [
+#             {"role": "AI", "content": "Hello, I am the virtual clinician. How can I help you today?"},
+#         ]
+
+# # Ensure each message is a dictionary before accessing its keys
+# for message in st.session_state.chat_history:
+#     if isinstance(message, dict) and "role" in message and "content" in message:
+#         with st.chat_message(message["role"]):
+#             st.write(message["content"])
+#     else:
+#         st.error("Invalid message format in chat history.")
+
+# user_query = st.chat_input("Type your message here...")
+# if user_query:
+#     st.session_state.chat_history.append({"role": "Human", "content": user_query})
+#     with st.chat_message("Human"):
+#         st.markdown(user_query)
+
+#     exists, count, conversation_obj = get_conversation(conversation_id)
+    
+#     if not exists:
+#         response = converse_with_patient("", user_query)
+#         store_conversation(conversation_id, conversation_id, user_query, response)
+#         exists, count, conversation_obj = get_conversation(conversation_id)
+    
+#     response_data = converse_with_patient(st.session_state.chat_history, user_query)
+#     st.session_state.chat_history.append({"role": "AI", "content": response_data})
+#     update_conversation(conversation_id, conversation_id, user_query, response_data)
+
+#     if count >= 6:
+#         outcome, diagnosis = create_diagnosis(conversation_obj)
+#         if outcome == "PASS":
+#             st.subheader("Diagnosis Summary")
+#             st.write(f"**Consensus Confidence:** {diagnosis.get('concensus_confidence', 'N/A')}%")
+#             st.write(f"**Consensus Thinking:** {diagnosis.get('concensus_thinking', 'N/A')}")
+#             st.write(f"**Evaluation Confidence:** {diagnosis.get('evaluate_confidence', 'N/A')}%")
+#             st.write(f"**Evaluation Explanation:** {diagnosis.get('evaluate_explanation', 'N/A')}")
+#             st.write(f"**Next Best Action:** {diagnosis.get('next_best_action_', 'N/A')}")
+#             st.write(f"**Next Best Action Explanation:** {diagnosis.get('next_best_action_explanation', 'N/A')}")
+#             st.write(f"**Next Best Action Confidence:** {diagnosis.get('next_best_action_confidence', 'N/A')}%")
+#             st.subheader("Expert Confidence Levels")
+#             fig = generate_expert_confidence_chart(diagnosis)
+#             st.plotly_chart(fig)
+#         else:
+#             st.write("Diagnosis not available")
+
+#     with st.chat_message("AI"):
+#         st.write(response_data)
+
+#     store_conversation(conversation_id, conversation_id, "", st.session_state.chat_history)

azure_openai.py

@@ -0,0 +1,253 @@
+import os
+import pandas as pd
+import streamlit as st
+# from langchain.chat_models import AzureChatOpenAI
+from langchain_openai import AzureChatOpenAI
+from langchain_core.output_parsers import StrOutputParser, PydanticOutputParser
+from langchain_core.prompts.chat import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate
+from pydantic import BaseModel, Field, validator
+from langchain.output_parsers.enum import EnumOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnableParallel
+from enum import Enum
+from helpers import read_md_files_from_doctors
+
+
+# os.environ["LANGCHAIN_TRACING_V2"]="true"
+# os.environ["LANGCHAIN_ENDPOINT"]="https://api.smith.langchain.com"
+# LANGCHAIN_API_KEY = st.secrets['LANGCHAIN_API_KEY']
+# os.environ["LANGCHAIN_PROJECT"]="UC2e2e"
+
+# LLM Langchain Definition
+OPENAI_API_KEY = st.secrets['azure_api_key']
+OPENAI_API_TYPE = "azure"
+OPENAI_API_BASE = "https://davidfearn-gpt4.openai.azure.com"
+OPENAI_API_VERSION = "2024-08-01-preview"
+OPENAI_MODEL = "gpt-4o-mini"
+
+llm = AzureChatOpenAI(
+    openai_api_version=OPENAI_API_VERSION,
+    openai_api_key=OPENAI_API_KEY,
+    azure_endpoint=OPENAI_API_BASE,
+    openai_api_type=OPENAI_API_TYPE,
+    deployment_name=OPENAI_MODEL,
+    temperature=0,
+    )
+
+
+# Function to read file contents
+def read_file(folder, file):
+    """
+    Reads the content of a text file and returns it as a string.
+    :param file: The file name to read from the 'assets' directory.
+    :return: The content of the file as a string or None if an error occurs.
+    """
+    fp = f"{folder}/{file}.md"
+    try:
+        with open(fp, 'r', encoding='utf-8') as file:
+            content = file.read()
+        return content
+    except FileNotFoundError:
+        print(f"The file at {fp} was not found.")
+    except IOError:
+        print(f"An error occurred while reading the file at {fp}.")
+    return None
+
+# Function to generate structured insights
+def converse_with_patient(converstaional_history, latest_message):
+    # test coversational history if empty return string "first iteraction" else return converstaional history
+    if converstaional_history == False:
+        converstaional_history = "first iteraction"
+
+    SystemMessage = read_file("conversation", "intake_system")
+    UserMessage = "This is the conversational history between the patient and the virtual doctor if one exists {converstaional_history} and this is the latest message from the patient {latest_message}"
+
+    # class symptoms_capture(BaseModel):
+    #     follow_up_question: str = Field(description="This feild is used to ask a question to refine your understanding of users symtoms")
+
+    system_message_template = SystemMessagePromptTemplate.from_template(SystemMessage)
+    # structured_llm = llm.with_structured_output(symptoms_capture)
+    prompt = ChatPromptTemplate.from_messages([system_message_template, UserMessage])
+
+    chain = prompt | llm | StrOutputParser()
+
+    
+    return chain.invoke({"converstaional_history": converstaional_history, "latest_message": latest_message})
+
+
+
+def diagnosis_consensus(diagnosis_results, conversational_history):
+    # Take the diagnosis results from the different models and generate a consensus diagnosis. The consensus diagnosis should be based on the confidence levels of the different models. The model with the highest confidence level should be given the most weight in the consensus diagnosis. The consensus diagnosis should be returned as a string.
+    class Diagnosis_Consensus(BaseModel):
+        diagnosis: str = Field(description="This field is used to give the diagnosis")
+        explanation: str = Field(description="This field is used to explain the diagnosis")
+        confidence: int = Field(description="This field is used to show the confidence level of the diagnosis")
+        
+
+        
+    system_message_template = SystemMessagePromptTemplate.from_template("You are a medical manager you will be given a number of diagnosis from different doctors as well as the original conversation that occurred between the triaging doctor and the patient. You will need to provide a consensus diagnosis based on the confidence levels of the different doctors. You need to provide a final diagnosis, an explanation of the diagnosis and you overall confidence in the diagnosis. ONLY USE THE INFORMATION PROVIDED TO YOU. ONLY CHOOSE ONE DIAGNOSIS")    
+    structured_llm_consensus = llm.with_structured_output(Diagnosis_Consensus)
+    StandardUserMessage = "This is the conversational history between the patient and the virtual doctor {conversational_history}"
+    prompt = ChatPromptTemplate.from_messages([system_message_template, StandardUserMessage])
+    chain = prompt | structured_llm_consensus
+    response = chain.invoke({"conversational_history": diagnosis_results})
+
+    return {
+        "diagnosis": response.diagnosis,
+        "explanation": response.explanation,
+        "confidence": response.confidence
+    }
+
+
+def evaluate_diagnosis(diagnosis_results, conversational_history):
+    #this is a simularity function that will compare the diagnosis results and the conversational history to known symtoms for this diagnosis and return a confidence level of the diagnosis
+    class Diagnosis_Evaluation(BaseModel):
+        confidence: int = Field(description="This field is used to show the confidence level of the diagnosis")
+        explanation: str = Field(description="This field is used to explain the confidence level of the diagnosis")
+
+    system_message_template = SystemMessagePromptTemplate.from_template(read_file("evaluator", "eval_system_message"))
+    StandardUserMessage = "This is the conversational history between the patient and the virtual doctor: {conversational_history}, this is the diagnosis our AI system has come up with: {diagnosis_results}"
+    structured_llm_consensus = llm.with_structured_output(Diagnosis_Evaluation)
+    prompt = ChatPromptTemplate.from_messages([system_message_template, StandardUserMessage])
+    chain = prompt | structured_llm_consensus
+    response = chain.invoke({"diagnosis_results": diagnosis_results, "conversational_history": conversational_history})
+
+    return {
+        "confidence": response.confidence,
+        "explanation": response.explanation
+    }
+
+def next_best_action(diagnosis, conversational_history):
+    # Take the diagnosis and return the next best action for the patient. The next best action should be based on the diagnosis and the conversational history. The next best action should be returned as a string.
+    # Next best actions available are: Goto the GP / family doctor, goto a specialist, goto the hospital, go to the pharmacist or stay at home and rest. 
+    
+    class actions(str, Enum):
+        GP = "GP / family doctor"
+        SPECIALIST = "specialist"
+        HOSPITAL = "hospital"
+        PHARMACIST = "pharmacist"
+        REST = "stay at home and rest"
+        
+    # Define the Pydantic model for the structured output
+    
+    class next_best_action(BaseModel):
+        action: actions = Field(description="This field is used to give the next best action for the patient")
+        explanation: str = Field(description="This field is used to explain the next best action for the patient")
+        confidence: int = Field(description="This field is used to show the confidence level of the next best action")
+    
+    system_message_template = SystemMessagePromptTemplate.from_template(read_file("nba", "nba_system"))
+    structured_llm_action = llm.with_structured_output(next_best_action)
+    StandardUserMessage = "This is the conversational history between the patient and the virtual doctor: {conversational_history}, and this is the diagnosis: {diagnosis}"
+    prompt = ChatPromptTemplate.from_messages([system_message_template, StandardUserMessage])
+    chain = prompt | structured_llm_action
+
+    response = chain.invoke({"diagnosis": diagnosis, "conversational_history": conversational_history})
+
+    return {"action": response.action.value, "explanation": response.explanation, "confidence": response.confidence}
+
+
+def create_diagnosis(converstaional_history):
+    # Take the conversational history and generate a diagnosis. The diagnosis should pass the conversational history to a model specific to a medical specialty. This specialty will be provided by system messages in the doctors folder. The system messages will be in .md format.
+
+    class Diagnosis(BaseModel):
+        diagnosis: str = Field(description="This field is used to give the diagnosis")
+        confidence: int = Field(description="This field is used to show the confidence level of the diagnosis")
+        thinking: str = Field(description="This field is used to show the thinking of why you choose the diagnosis")
+    
+
+    system_message_df = read_md_files_from_doctors()
+    structured_llm_diagnosis = llm.with_structured_output(Diagnosis)
+    StandardUserMessage = "This is the conversational history between the patient and the virtual doctor {conversational_history}"
+
+    # Extract the system messages from system_message_df content column and the name of the file from the filename column
+    # In parallel, run the system messages through the model to get the diagnosis
+    # For each system message in system_message_df, create a chain named by the content filename column
+  
+
+    chains = {}
+    for index, row in system_message_df.iterrows():
+        system_message_template = SystemMessagePromptTemplate.from_template(row['content'])
+        prompt = ChatPromptTemplate.from_messages([system_message_template, StandardUserMessage])
+        chains[row['filename']] = prompt | structured_llm_diagnosis
+
+    map_chain = RunnableParallel(**chains)
+
+    response = map_chain.invoke({"conversational_history": converstaional_history})
+    diagnosis_results = {}
+    for filename, result in response.items():
+        filename_base = filename.split('.')[0]
+        diagnosis_results[f"{filename_base}, diagnosis"] = result.diagnosis
+        diagnosis_results[f"{filename_base}, thinking"] = result.thinking
+        diagnosis_results[f"{filename_base}, confidence"] = result.confidence
+        
+    
+
+   
+    consensus = diagnosis_consensus(diagnosis_results, converstaional_history)
+    # Return the diagnosis and the confidence level of the diagnosis
+    # """{
+    #     "confidence": response.confidence,
+    #     "explanation": response.explanation
+    # }"""
+    print(consensus["confidence"])
+    if consensus["confidence"] < 80:
+        return "FAIL1", {
+            "diagnosis_completion": "fail",
+            "concensus_diagnosis": consensus["diagnosis"],
+            "expert_distribution": diagnosis_results,
+            "concensus_confidence": consensus["confidence"],
+            "concensus_thinking": consensus["explanation"],
+            "next_best_action_": "GP / family doctor",
+            "Error": "The confidence level of the consensus diagnosis is below 80%"
+        }
+
+
+    final_diagnosis = evaluate_diagnosis(consensus, converstaional_history)
+    # return the final diagnosis and the confidence level of the final diagnosis
+    # """{
+    #     "diagnosis": response.diagnosis,
+    #     "explanation": response.explanation,
+    #     "confidence": response.confidence
+    # }"""
+    
+    if final_diagnosis["confidence"] < 80:
+        return "FAIL2", {
+            "diagnosis_completion": "fail",
+            "concensus_diagnosis": consensus["diagnosis"],
+            "expert_distribution": diagnosis_results,
+            "concensus_confidence": consensus["confidence"],
+            "concensus_thinking": consensus["explanation"],
+            "evaluate_confidence": final_diagnosis["diagnosis"],
+            "evaluate_confidence": final_diagnosis["confidence"],
+            "evaluate_explanation": final_diagnosis["explanation"],
+            "next_best_action_": "GP / family doctor",
+            "Error": "The confidence level of the final diagnosis is below 80%"
+        }
+    
+    next_action = next_best_action(consensus["diagnosis"], converstaional_history)
+    # return the next best action for the patient
+    # {"action": response.action, "explanation": response.explanation, "confidence": response.confidence}
+
+    return "SUCCESS", {
+        "diagnosis_completion": "success",
+        "concensus_diagnosis": consensus["diagnosis"],
+        "expert_distribution": diagnosis_results,
+        "concensus_confidence": consensus["confidence"],
+        "concensus_thinking": consensus["explanation"],
+        "evaluate_confidence": final_diagnosis["confidence"],
+        "evaluate_explanation": final_diagnosis["explanation"],
+        "next_best_action_": next_action["action"],
+        "next_best_action_explanation": next_action["explanation"],
+        "next_best_action_confidence": next_action["confidence"]
+    }
+
+
+# conversation = """{'conversation_id': '12345623', 'patient': 'John Doe', 'conversation': [{'role': 'user', 'content': 'I have a pain in my lower right hand side.'}, {'role': 'assistant', 'content': 'how bad is the pain on a scale of 1 to 10?'}, {'role': 'user', 'content': '10 out of 10 and its lasted 2 hours'}, {'role': 'assistant', 'content': 'Does the pain radiate to any other part of your body?'}, {'role': 'user', 'content': 'No its just in my abdomen.'}, {'role': 'assistant', 'content': 'have you had any other symptoms like nausea or vomiting?'}, {'role': 'user', 'content': 'I do feel a bit sick'}, {'role': 'assistant', 'content': 'thank you for this information'}]}
+# ('PASS', 4, {'conversation_id': '12345623', 'patient': 'John Doe', 'conversation': [{'role': 'user', 'content': 'I have a pain in my lower right hand side.'}, {'role': 'assistant', 'content': 'how bad is the pain on a scale of 1 to 10?'}, {'role': 'user', 'content': '10 out of 10 and its lasted 2 hours'}, {'role': 'assistant', 'content': 'Does the pain radiate 
+# to any other part of your body?'}, {'role': 'user', 'content': 'No its just in my abdomen.'}, {'role': 'assistant', 'content': 'have you had any other symptoms like nausea or vomiting?'}, {'role': 'user', 'content': 'I do feel a bit sick'}, {'role': 'assistant', 'content': 'thank you for this information'}]})"""
+
+# print(create_diagnosis(conversation))
+
+
+
+

helpers.py

@@ -0,0 +1,19 @@
+import os
+import pandas as pd
+
+def read_md_files_from_doctors():
+    doctors_folder = 'doctors'
+    data = []
+
+    for filename in os.listdir(doctors_folder):
+        if filename.endswith('.md'):
+            file_path = os.path.join(doctors_folder, filename)
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+                data.append({'filename': filename, 'content': content})
+
+    df = pd.DataFrame(data)
+    return df
+
+# Example usage
+

memory.py

@@ -0,0 +1,184 @@
+# This file will be used to store the interim conversational state of the doctor and patient and then store the various diagnostic results and the final diagnosis and next best action.
+# To store the data we will use Azure blob store and each file will be stored as a json file with the conversation id as the file name.
+
+# Steps
+# 1. Create a class to store the conversation state
+# 2. Create a function to check if this is a new conversation or an existing conversation
+# 3. Create a function to count interactions in the conversation if existing exists
+# 4. Create a function to store the conversation in Azure blob storage
+# 5. Create a function to retrieve the conversation from Azure blob storage
+# 6. Create a function to update the conversation in Azure blob storage
+# 7. Create a function to delete the conversation from Azure blob storage
+
+# Import the required libraries
+import os
+import json
+from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
+
+# Azure connection string
+connect_str = "DefaultEndpointsProtocol=https;AccountName=chatlogs;AccountKey=7tiHxmMbbdEp3/yrydWOEoAc7PPDkVHXV5QXZWR1jTH0hX8/O2gIrSHwMNqXwEnEwWWAD8pqIwuV+AStWqHVNA==;EndpointSuffix=core.windows.net"
+container_name = "vme25"
+
+# Create a class to store the conversation state
+class Conversation:
+    def __init__(self, conversation_id, patient, conversation):
+        self.conversation_id = conversation_id
+        self.patient = patient
+        self.conversation = conversation
+
+# Create a function to check if this is a new conversation or an existing conversation
+def check_conversation(conversation_id):
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    if blob_client.exists():
+        return True
+    else:
+        return False
+
+# Create a function to count interactions in the conversation if existing exists
+def count_interactions(conversation_id):
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    
+    # Retrieve the existing conversation
+    conversation_json = blob_client.download_blob().readall()
+    conversation_obj = json.loads(conversation_json)
+    
+    # Count the number of user interactions
+    user_interactions = sum(1 for message in conversation_obj['conversation'] if message['role'] == 'user')
+    
+    return user_interactions
+
+# Create a function to store the conversation in Azure blob storage
+def initail_conversation(conversation_id, patient, from_user, response_from_ai):
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+
+    # Initialize the conversation with the first user and assistant messages
+    conversation = [
+        {'role': 'user', 'content': from_user},
+        {'role': 'assistant', 'content': response_from_ai}
+    ]
+
+    conversation_obj = Conversation(conversation_id, patient, conversation)
+    conversation_json = json.dumps(conversation_obj.__dict__)
+    blob_client.upload_blob(conversation_json)
+
+# Create a function to retrieve the conversation from Azure blob storage
+def retrieve_conversation(conversation_id):
+    print("Retrieving conversation")
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    conversation_json = blob_client.download_blob().readall()
+    conversation_obj = json.loads(conversation_json)
+    return conversation_obj
+
+# Create a function to update the conversation in Azure blob storage
+def update_conversation(conversation_id, from_user, response_from_ai):
+    paitent = "patient"
+    print("Updating conversation")
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    
+    # Retrieve the existing conversation
+    conversation_obj = retrieve_conversation(conversation_id)
+    
+    # Update the conversation with new messages
+    conversation_obj['conversation'].append({'role': 'user', 'content': from_user})
+    conversation_obj['conversation'].append({'role': 'assistant', 'content': response_from_ai})
+    
+    # Convert the updated conversation to JSON
+    conversation_json = json.dumps(conversation_obj)
+    
+    # Upload the updated conversation, overwriting the existing blob
+    blob_client.upload_blob(conversation_json, overwrite=True)
+    return conversation_json
+
+def write_diagnosis(conversation_id, diagnosis):
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    
+    # Retrieve the existing conversation
+    conversation_obj = retrieve_conversation(conversation_id)
+    
+    # Update the conversation with new messages
+    conversation_obj['conversation'].append({'role': 'diagnosis', 'content': diagnosis})
+    
+    # Convert the updated conversation to JSON
+    conversation_json = json.dumps(conversation_obj)
+    
+    # Upload the updated conversation, overwriting the existing blob
+    blob_client.upload_blob(conversation_json, overwrite=True)
+
+# Create a function to delete the conversation from Azure blob storage
+def delete_conversation(conversation_id):
+    # Create a blob service client
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(conversation_id)
+    blob_client.delete_blob()
+
+def store_conversation(conversation_id, from_user, response_from_ai):
+    patient = "patient"
+    # Create a blob service client
+    try:
+        print("Storing conversation")
+        res_check = check_conversation(conversation_id)
+        print(res_check)
+        if res_check == False:
+            print("Conversation doesn't exists, starting new conversation")
+            initail_conversation(conversation_id, patient, from_user, response_from_ai)
+            print("Conversation stored")
+        else:            
+            update_conversation(conversation_id, patient, from_user, response_from_ai)
+            print("Conversation updated")
+    except Exception as e:
+        return "FAIL", str(e)
+
+def get_conversation(conversation_id):
+    # Create a blob service client
+    try:
+        res_check = check_conversation(conversation_id)
+        if res_check == True:
+            print("Conversation exists")
+            count = count_interactions(conversation_id)
+            conversation_obj = retrieve_conversation(conversation_id)
+            return "PASS", count, conversation_obj
+        else:
+            print("Conversation doesn't exists")
+            return "FAIL", 0, "Conversation does not exist"
+    except Exception as e:
+        print("an error occured")
+        return "FAIL", str(e)
+
+
+
+# # Test the functions
+# conversation_id = "12345623"
+# patient = "John Doe"
+# from_user = "I do feel a bit sick"
+# response_from_ai = "thank you for this information"
+# # print(get_conversation(conversation_id))
+
+# store_conversation(conversation_id, patient, from_user, response_from_ai)
+#print(check_conversation(conversation_id))
+# print(count_interactions(conversation_id))
+# conversation_obj = retrieve_conversation(conversation_id)
+# print(conversation_obj)
+
+# update_conversation(conversation_id, patient, "What is your name?", "I am an AI assistant.")
+# conversation_obj = retrieve_conversation(conversation_id)
+# print(conversation_obj)
+# delete_conversation(conversation_id)

requirements.txt

@@ -0,0 +1,13 @@
+langchain
+langchain_core
+langchain-openai 
+pandas
+langchain-text-splitters
+tiktoken
+openevals
+langsmith
+azure-storage-blob
+azure-identity
+fastAPI==0.111.0
+streamlit
+plotly