Added MongoDB functionality

.gitignore

@@ -177,7 +177,7 @@ cython_debug/
 
 # Jupyter NB Checkpoints
 .ipynb_checkpoints/
-
+*.ipynb
 # exclude data from source control by default
 /data/
 

app_config.py

@@ -0,0 +1,15 @@
+ISSUES = ['Anxiety','Suicide']
+SOURCES = ['OA_rolemodel', 'OA_finetuned']
+SOURCES_LAB = {"OA_rolemodel":'OpenAI GPT3.5',
+               "OA_finetuned":'Finetuned OpenAI'}
+
+def source2label(source):
+    return SOURCES_LAB[source]
+
+ENVIRON = "dev"
+
+DB_SCHEMA = 'prod_db' if ENVIRON == 'prod' else 'test_db' 
+DB_CONVOS = 'conversations'
+DB_COMPLETIONS = 'comparison_completions'
+DB_BATTLES = 'battles'
+DB_ERRORS = 'completion_errors'

app_utils.py

@@ -0,0 +1,66 @@
+import datetime as dt
+import streamlit as st
+from streamlit.logger import get_logger
+import langchain
+from langchain.memory import ConversationBufferMemory
+
+from app_config import ENVIRON
+from models.openai.finetuned_models import finetuned_models, get_finetuned_chain
+from models.openai.role_models import get_role_chain, role_templates
+from mongo_utils import new_convo
+
+langchain.verbose = ENVIRON=="dev"
+logger = get_logger(__name__)
+
+def add_initial_message(model_name, memory):
+    if "Spanish" in model_name:
+        memory.chat_memory.add_ai_message("Hola necesito ayuda") 
+    else:
+        memory.chat_memory.add_ai_message("Hi I need help")
+
+
+def push_convo2db(memories, username, language):
+    if len(memories) == 1:
+        issue =  memories['memory']['issue']
+        model_one = memories['memory']['source']
+        new_convo(st.session_state['db_client'], issue, language, username, False, model_one)
+    else:
+        issue =  memories['commonMemory']['issue']
+        model_one = memories['memoryA']['source']
+        model_two = memories['memoryB']['source']
+        new_convo(st.session_state['db_client'], issue, language, username, True, model_one, model_two)
+
+def change_memories(memories, username, language, changed_source=False):
+    for memory, params in memories.items():
+        if (memory not in st.session_state) or changed_source:
+            source = params['source']
+            logger.info(f"Source for memory {memory} is {source}")
+            if source in ('OA_rolemodel','OA_finetuned'):
+                st.session_state[memory] = ConversationBufferMemory(ai_prefix='texter', human_prefix='helper')
+    
+    if ("convo_id" in st.session_state) and changed_source:
+        del st.session_state['convo_id']
+    
+
+def clear_memory(memories, username, language):
+    for memory, _ in memories.items():
+        st.session_state[memory].clear()
+
+    if "convo_id" in st.session_state:
+        del st.session_state['convo_id']
+    
+
+def create_memory_add_initial_message(memories, username, language, changed_source=False):
+    change_memories(memories, username, language, changed_source=changed_source)
+    for memory, _ in memories.items():
+        if len(st.session_state[memory].buffer_as_messages) < 1:
+            add_initial_message(language, st.session_state[memory])
+
+
+def get_chain(issue, language, source, memory, temperature):
+    if source in ("OA_finetuned"):
+        OA_engine = finetuned_models[f"{issue}-{language}"]
+        return get_finetuned_chain(OA_engine, memory, temperature)
+    elif source in ('OA_rolemodel'):
+        template = role_templates[f"{issue}-{language}"]
+        return get_role_chain(template, memory, temperature)

convosim.py

@@ -1,38 +1,53 @@
-import openai 
 import os
 import streamlit as st
+from streamlit.logger import get_logger
 from langchain.schema.messages import HumanMessage
+from mongo_utils import get_db_client
+from app_utils import create_memory_add_initial_message, clear_memory, get_chain, push_convo2db
+from app_config import ISSUES, SOURCES, source2label
 
-from utils import create_memory_add_initial_message, clear_memory, get_chain
-
+logger = get_logger(__name__)
 openai_api_key = os.environ['OPENAI_API_KEY'] 
-memories = ['memory']
+memories = {'memory':{"issue": ISSUES[0], "source": SOURCES[0]}}
+
+if 'previous_source' not in st.session_state:
+    st.session_state['previous_source'] = SOURCES[0]
+if 'db_client' not in st.session_state:
+    st.session_state["db_client"] = get_db_client()
 
 with st.sidebar:
+    username = st.text_input("Username", value='ivnban-ctl', max_chars=30)
     temperature = st.slider("Temperature", 0., 1., value=0.8, step=0.1)
-    issue = st.selectbox("Select an Issue", ['Anxiety','Suicide'], index=0,
-                            on_change=clear_memory, args=(memories,)
+    issue = st.selectbox("Select an Issue", ISSUES, index=0,
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
                         )
     supported_languages = ['English', "Spanish"] if issue == "Anxiety" else ['English']
     language = st.selectbox("Select a Language", supported_languages, index=0,
-                            on_change=clear_memory, args=(memories,)
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
                         )
                             
-    source = st.selectbox("Select a source Model A", ['OpenAI GPT3.5','Finetuned OpenAI'], index=1,
-                            on_change=clear_memory, args=(memories,)
+    source = st.selectbox("Select a source Model A", SOURCES, index=1,
+                          format_func=source2label, 
                         )
 
-create_memory_add_initial_message(memories, language)
-llm_chain = get_chain(issue, language, source, st.session_state[memories[0]], temperature)
+memories = {'memory':{"issue":issue, "source":source}}
+changed_source = st.session_state['previous_source'] != source
+create_memory_add_initial_message(memories, username, language, changed_source=changed_source)
+st.session_state['previous_source'] = source
+memoryA = st.session_state[list(memories.keys())[0]]
+llm_chain, stopper = get_chain(issue, language, source, memoryA, temperature)
 
 st.title("💬 Simulator") 
 
-for msg in st.session_state[memories[0]].buffer_as_messages:
+for msg in memoryA.buffer_as_messages:
     role = "user" if type(msg) == HumanMessage else "assistant"
     st.chat_message(role).write(msg.content)
 
 if prompt := st.chat_input():
+    if 'convo_id' not in st.session_state:
+        push_convo2db(memories, username, language)
+
     st.chat_message("user").write(prompt)
-    response = llm_chain.predict(input=prompt, stop="helper:")
+    response = llm_chain.predict(input=prompt, stop=stopper)
     # response = update_memory_completion(prompt, st.session_state["memory"], OA_engine, temperature)
     st.chat_message("assistant").write(response)

models/openai/finetuned_models.py

@@ -1,9 +1,11 @@
-import openai
+# from streamlit.logger import get_logger
 from models.custom_parsers import CustomStringOutputParser
 from langchain.chains import LLMChain
 from langchain.llms import OpenAI
 from langchain.prompts import PromptTemplate
-import logging
+
+# logger = get_logger(__name__)
+# logger.debug("START APP")
 
 finetuned_models = {
     # "olivia_babbage_engine": "babbage:ft-crisis-text-line:exp-olivia-babbage-2023-02-23-19-57-19",
@@ -67,9 +69,8 @@ def get_finetuned_chain(model_name, memory, temperature=0.8):
     llm_chain = LLMChain(
         llm=llm,
         prompt=PROMPT,
-        verbose=True,
         memory=memory,
         output_parser = CustomStringOutputParser()
     )
-    logging.debug(f"loaded fine tuned model {model_name}")
-    return llm_chain
+    # logger.debug(f"{__name__}: loaded fine tuned model {model_name}")
+    return llm_chain, "helper:"

models/openai/role_models.py

@@ -49,9 +49,8 @@ def get_role_chain(template, memory, temperature=0.8):
     llm_chain = ConversationChain(
         llm=llm,
         prompt=PROMPT,
-        verbose=True,
         memory=memory,
         output_parser=CustomStringOutputParser()
     )
     logging.debug(f"loaded GPT3.5 model")
-    return llm_chain
+    return llm_chain, "helper:"

mongo_utils.py

@@ -0,0 +1,143 @@
+import os
+import datetime as dt
+import streamlit as st
+from streamlit.logger import get_logger
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+from app_config import DB_SCHEMA, DB_COMPLETIONS, DB_CONVOS, DB_BATTLES, DB_ERRORS
+
+DB_URL = os.environ['MONGO_URL']
+DB_USR = os.environ['MONGO_USR']
+DB_PWD = os.environ['MONGO_PWD']
+
+logger = get_logger(__name__)
+
+def get_db_client():
+    uri = f"mongodb+srv://{DB_USR}:{DB_PWD}@{DB_URL}/?retryWrites=true&w=majority"
+    # Create a new client and connect to the server
+    client = MongoClient(uri, server_api=ServerApi('1'))
+    # Send a ping to confirm a successful connection
+    try:
+        client.admin.command('ping')
+        logger.info(f"DBUTILS: Pinged your deployment. You successfully connected to MongoDB!")
+        return client
+    except Exception as e:
+        logger.error(e)
+
+def new_convo(client, issue, language, username, is_comparison, model_one, model_two=None):
+    convo = {
+        "start_timestamp": dt.datetime.now(tz=dt.timezone.utc),
+        "issue": issue,
+        "language": language,
+        "username": username,
+        "is_comparison": is_comparison,
+        "model_one": model_one,
+        "model_two": model_two,
+    }
+
+    db = client[DB_SCHEMA]
+    convos = db[DB_CONVOS]
+    convo_id = convos.insert_one(convo).inserted_id
+    logger.info(f"DBUTILS: new convo id is {convo_id}")
+    st.session_state['convo_id'] = convo_id
+
+def new_comparison(client, prompt_timestamp, completion_timestamp, 
+                   chat_history, prompt, completionA, completionB,
+                   source="webapp", subset=None
+                   ):
+    comparison = {
+        "prompt_timestamp": prompt_timestamp,
+        "completion_timestamp": completion_timestamp,
+        "source": source,
+        "subset": subset,
+        "model_one_args": {
+            'temperature':0.8
+        },
+        "model_two_args": {
+            'temperature':0.8
+        },
+        "convo_id": st.session_state['convo_id'],
+        "chat_history": chat_history,
+        "prompt": prompt,
+        "compeltion_model_one": completionA,
+        "compeltion_model_two": completionB,
+    }
+
+    db = client[DB_SCHEMA]
+    comparisons = db[DB_COMPLETIONS]
+    comparison_id = comparisons.insert_one(comparison).inserted_id
+    logger.info(f"DBUTILS: new comparison id is {comparison_id}")
+    st.session_state['comparison_id'] = comparison_id
+
+def new_battle_result(client, comparison_id, convo_id, username, model_one, model_two, winner):
+    battle = {
+        "battle_timestamp": dt.datetime.now(tz=dt.timezone.utc),
+        "comparison_id": comparison_id,
+        "convo_id": convo_id,
+        "username": username,
+        "model_one": model_one,
+        "model_two": model_two,
+        "winner": winner,
+    
+    }
+
+    db = client[DB_SCHEMA]
+    battles = db[DB_BATTLES]
+    battle_id = battles.insert_one(battle).inserted_id
+    logger.info(f"DBUTILS: new battle id is {battle_id}")
+
+def new_completion_error(client, comparison_id, username, model):
+    error = {
+        "error_timestamp": dt.datetime.now(tz=dt.timezone.utc),
+        "comparison_id": comparison_id,
+        "username": username,
+        "model": model,    
+    }
+
+    db = client[DB_SCHEMA]
+    errors = db[DB_ERRORS]
+    error_id = errors.insert_one(error).inserted_id
+    logger.info(f"DBUTILS: new error id is {error_id}")
+
+def get_non_assesed_comparison(client, username):
+    from bson.son import SON
+    pipeline = [
+        {'$lookup': {
+            'from': DB_BATTLES, 
+            'localField': '_id', 
+            'foreignField': 'comparison_id', 
+            "pipeline": [
+                {"$match": {"username":username}},
+            ],
+            'as': 'battles'
+        }},
+        {'$lookup': {
+            'from': DB_CONVOS, 
+            'localField': 'convo_id', 
+            'foreignField': '_id', 
+            'as': 'convo_info'
+        }},
+        {"$match":{
+            "battles": {"$size":0},
+        }},
+        {"$addFields": {
+        "priority": {
+            "$cond":[
+                {"$eq": ["$source","manual"]},
+                1,
+                0
+            ]
+            },
+        }},
+        {"$sort": SON([
+                ("priority", -1),
+                ("prompt_timestamp", 1),
+                ("convo_id", 1),
+            ])
+        },
+        {"$limit": 1}
+    ]
+
+    db = client[DB_SCHEMA]
+    return list(db[DB_COMPLETIONS].aggregate(pipeline))
+    

pages/comparisor.py

@@ -1,14 +1,27 @@
-import openai 
+
 import os
+import random
+import datetime as dt
 import streamlit as st
+from streamlit.logger import get_logger
 from langchain.schema.messages import HumanMessage
-import logging
-
-from utils import create_memory_add_initial_message, clear_memory, get_chain
+from mongo_utils import get_db_client, new_comparison, new_battle_result
+from app_utils import create_memory_add_initial_message, clear_memory, get_chain, push_convo2db
+from app_config import ISSUES, SOURCES, source2label
 
+logger = get_logger(__name__)
 openai_api_key = os.environ['OPENAI_API_KEY'] 
-memories = ['memoryA', 'memoryB', 'commonMemory']
-
+memories = {
+    'memoryA': {"issue": ISSUES[0], "source": SOURCES[0]},
+    'memoryB': {"issue": ISSUES[0], "source": SOURCES[1]},
+    'commonMemory': {"issue": ISSUES[0], "source": SOURCES[0]}
+}
+if 'db_client' not in st.session_state:
+    st.session_state["db_client"] = get_db_client()
+if 'previous_sourceA' not in st.session_state:
+    st.session_state['previous_sourceA'] = SOURCES[0]
+if 'previous_sourceB' not in st.session_state:
+    st.session_state['previous_sourceB'] = SOURCES[1]
 
 def delete_last_message(memory):
     last_prompt = memory.chat_memory.messages[-2].content
@@ -20,59 +33,91 @@ def replace_last_message(memory, new_message):
     memory.chat_memory.add_ai_message(new_message)
 
 def regenerateA():
-    last_prompt = delete_last_message(st.session_state[memories[0]])
-    new_response = llm_chainA.predict(input=last_prompt, stop="helper:")
+    last_prompt = delete_last_message(memoryA)
+    new_response = llm_chainA.predict(input=last_prompt, stop=stopperA)
     col1.chat_message("user").write(last_prompt)
     col1.chat_message("assistant").write(new_response)
+    return new_response
 
 def regenerateB():
-    last_prompt = delete_last_message(st.session_state[memories[1]])
-    new_response = llm_chainB.predict(input=last_prompt, stop="helper:")
+    last_prompt = delete_last_message(memoryB)
+    new_response = llm_chainB.predict(input=last_prompt, stop=stopperB)
     col2.chat_message("user").write(last_prompt)
     col2.chat_message("assistant").write(new_response)
+    return new_response
 
 def replaceA():
-    last_prompt = st.session_state[memories[1]].chat_memory.messages[-2].content
-    new_message = st.session_state[memories[1]].chat_memory.messages[-1].content
-    replace_last_message(st.session_state[memories[0]], new_message)
+    last_prompt = memoryB.chat_memory.messages[-2].content
+    new_message = memoryB.chat_memory.messages[-1].content
+    replace_last_message(memoryA, new_message)
     st.session_state['commonMemory'].save_context({"inputs":last_prompt}, {"outputs":new_message})
 
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='model_two'
+                    )
+
 def replaceB():
-    last_prompt = st.session_state[memories[0]].chat_memory.messages[-2].content
-    new_message = st.session_state[memories[0]].chat_memory.messages[-1].content
-    replace_last_message(st.session_state[memories[1]], new_message)
+    last_prompt = memoryA.chat_memory.messages[-2].content
+    new_message = memoryA.chat_memory.messages[-1].content
+    replace_last_message(memoryB, new_message)
     st.session_state['commonMemory'].save_context({"inputs":last_prompt}, {"outputs":new_message})
 
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='model_one'
+                    )
+
 def regenerateBoth():
-    regenerateA()
-    regenerateB()
+    promt_ts = dt.datetime.now(tz=dt.timezone.utc)
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='both_bad'
+                    )
+    
+    responseA = regenerateA()
+    responseB = regenerateB()
+    completion_ts = dt.datetime.now(tz=dt.timezone.utc)
+    new_comparison(st.session_state['db_client'], promt_ts, completion_ts,
+                   st.session_state['commonMemory'].buffer_as_str, prompt, responseA, responseB)
 
 def bothGood():
-    if len(st.session_state['memoryA'].buffer_as_messages) == 1:
+    if len(memoryA.buffer_as_messages) == 1:
         pass
     else:
-        last_prompt = st.session_state[memories[0]].chat_memory.messages[-2].content
-        last_reponse = st.session_state[memories[0]].chat_memory.messages[-1].content
+        i = random.choice([memoryA, memoryB])
+        last_prompt = i.chat_memory.messages[-2].content
+        last_reponse = i.chat_memory.messages[-1].content
         st.session_state['commonMemory'].save_context({"inputs":last_prompt}, {"outputs":last_reponse})
+        
+        new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='tie'
+                    )
 
 with st.sidebar:
-    issue = st.selectbox("Select an Issue", ['Anxiety','Suicide'], index=0,
-                            on_change=clear_memory, args=(memories,)
+    username = st.text_input("Username", value='ivnban-ctl', max_chars=30)
+    issue = st.selectbox("Select an Issue", ISSUES, index=0,
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
                         )
     supported_languages = ['English', "Spanish"] if issue == "Anxiety" else ['English']
     language = st.selectbox("Select a Language", supported_languages, index=0,
-                            on_change=clear_memory, args=(memories,)
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
                         )
     
     with st.expander("Model A"):
         temperatureA = st.slider("Temperature Model A", 0., 1., value=0.8, step=0.1)
-        sourceA = st.selectbox("Select a source Model A", ['OpenAI GPT3.5','Finetuned OpenAI'], index=0,
-                                on_change=clear_memory, args=(memories,)
+        sourceA = st.selectbox("Select a source Model A", SOURCES, index=0,
+                               format_func=source2label
                             )
     with st.expander("Model B"):
         temperatureB = st.slider("Temperature Model B", 0., 1., value=0.8, step=0.1)
-        sourceB = st.selectbox("Select a source Model B", ['OpenAI GPT3.5','Finetuned OpenAI'], index=1,
-                                on_change=clear_memory, args=(memories,)
+        sourceB = st.selectbox("Select a source Model B", SOURCES, index=1,
+                               format_func=source2label
                             )
         
     sbcol1, sbcol2 = st.columns(2)
@@ -86,9 +131,20 @@ with st.sidebar:
     # regenB = sbcol2.button("Regenerate B", on_click=regenerateB)
     clear = st.button("Clear History", on_click=clear_memory, args=(memories,))
 
-create_memory_add_initial_message(memories, language)
-llm_chainA = get_chain(issue, language, sourceA, st.session_state[memories[0]], temperatureA)
-llm_chainB = get_chain(issue, language, sourceB, st.session_state[memories[1]], temperatureB)
+memories = {
+    'memoryA': {"issue": issue, "source": sourceA},
+    'memoryB': {"issue": issue, "source": sourceB},
+    'commonMemory': {"issue": issue, "source": SOURCES[0]}
+}
+changed_source = any([
+    st.session_state['previous_sourceA'] != sourceA,
+    st.session_state['previous_sourceB'] != sourceB
+])
+create_memory_add_initial_message(memories, username, language, changed_source=changed_source)
+memoryA = st.session_state[list(memories.keys())[0]]
+memoryB = st.session_state[list(memories.keys())[1]]
+llm_chainA, stopperA = get_chain(issue, language, sourceA, memoryA, temperatureA)
+llm_chainB, stopperB = get_chain(issue, language, sourceB, memoryB, temperatureB)
 
 st.title(f"💬 History") 
 for msg in st.session_state['commonMemory'].buffer_as_messages:
@@ -115,12 +171,20 @@ def disable_chat():
         return True
 
 if prompt := st.chat_input(disabled=disable_chat()):
+    if 'convo_id' not in st.session_state:
+        push_convo2db(memories, username, language)
+
+    promt_ts = dt.datetime.now(tz=dt.timezone.utc)
     col1.chat_message("user").write(prompt)
     col2.chat_message("user").write(prompt)
 
-    responseA = llm_chainA.predict(input=prompt, stop="helper:")
-    responseB = llm_chainB.predict(input=prompt, stop="helper:")
+    responseA = llm_chainA.predict(input=prompt, stop=stopperA)
+    responseB = llm_chainB.predict(input=prompt, stop=stopperB)
+    completion_ts = dt.datetime.now(tz=dt.timezone.utc)
 
+    new_comparison(st.session_state['db_client'], promt_ts, completion_ts,
+                   st.session_state['commonMemory'].buffer_as_str, prompt, responseA, responseB)
+    
     col1.chat_message("assistant").write(responseA)
     col2.chat_message("assistant").write(responseB)
 

pages/manual_comparisor.py

@@ -0,0 +1,108 @@
+
+import os
+import random
+import datetime as dt
+import streamlit as st
+from streamlit.logger import get_logger
+from langchain.schema.messages import HumanMessage
+from mongo_utils import get_db_client, new_battle_result, get_non_assesed_comparison, new_completion_error
+from app_config import ISSUES, SOURCES
+
+logger = get_logger(__name__)
+openai_api_key = os.environ['OPENAI_API_KEY'] 
+if 'db_client' not in st.session_state:
+    st.session_state["db_client"] = get_db_client()
+
+def disable_buttons():
+    return len(comparison) == 0
+
+def replaceA():
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='model_two'
+                    )
+
+def replaceB():
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='model_one'
+                    )
+
+def regenerateBoth():
+    new_battle_result(st.session_state['db_client'],
+                    st.session_state['comparison_id'],
+                    st.session_state['convo_id'],
+                    username, sourceA, sourceB, winner='both_bad'
+                    )
+
+def bothGood():     
+    new_battle_result(st.session_state['db_client'],
+                st.session_state['comparison_id'],
+                st.session_state['convo_id'],
+                username, sourceA, sourceB, winner='tie'
+                )
+    
+def error2db(model):
+    new_completion_error(st.session_state['db_client'],
+                         st.session_state['comparison_id'],
+                         username, model
+                        )
+    
+def error2dbA():
+    error2db(sourceA)
+
+def error2dbA():
+    error2db(sourceB)
+
+with st.sidebar:
+    username = st.text_input("Username", value='ivnban-ctl', max_chars=30)
+            
+comparison = get_non_assesed_comparison(st.session_state["db_client"], username)
+
+with st.sidebar:
+            
+    sbcol1, sbcol2 = st.columns(2)
+    beta = sbcol1.button("A is better", on_click=replaceB, disabled=disable_buttons())
+    betb = sbcol2.button("B is better", on_click=replaceA, disabled=disable_buttons())
+
+    same = sbcol1.button("Tie", on_click=bothGood, disabled=disable_buttons())
+    bbad = sbcol2.button("Both are bad", on_click=regenerateBoth, disabled=disable_buttons())
+
+    errorA = sbcol1.button("Error in A", on_click=error2dbA, disabled=disable_buttons())
+    errorB = sbcol2.button("Error in B", on_click=error2dbA, disabled=disable_buttons())
+
+if len(comparison) > 0:
+
+    st.session_state['comparison_id'] = comparison[0]["_id"]
+    st.session_state['convo_id'] = comparison[0]["convo_id"]
+    st.session_state["disabled_buttons"] = False
+
+    st.sidebar.text_input("Issue", value=comparison[0]['convo_info'][0]['issue'], disabled=True)
+
+    st.title(f"💬 History") 
+
+    for msg in comparison[0]['chat_history'].split("\n"):
+        parts = msg.split(":")
+        if len(parts) > 1:
+            role = "user" if parts[0] == 'helper' else "assistant"
+            st.chat_message(role).write(parts[1])
+
+    col1, col2 = st.columns(2)
+    col1.title(f"💬 Simulator A") 
+    col2.title(f"💬 Simulator B") 
+    
+    selectedA = random.choice(['model_one', 'model_two'])
+    selectedB = "model_two" if selectedA == "model_one" else "model_one"
+    logger.info(f"selected A is {selectedA} and B is {selectedB}")
+    sourceA = comparison[0]['convo_info'][0][selectedA]
+    sourceB = comparison[0]['convo_info'][0][selectedB]
+    col1.chat_message("user").write(comparison[0]["prompt"])
+    col2.chat_message("user").write(comparison[0]["prompt"])
+
+    col1.chat_message("assistant").write(comparison[0][f"compeltion_{selectedA}"])
+    col2.chat_message("assistant").write(comparison[0][f"compeltion_{selectedB}"])
+
+else:
+    st.write("No Comparisons left to Check")

requirements.txt

@@ -1,3 +1,4 @@
 scipy==1.11.1
 openai==0.28.0
-langchain==0.0.281
+langchain==0.0.281
+pymongo==4.5.0