cpc and bad practices features

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[client]
+showSidebarNavigation = false

README.md

@@ -4,8 +4,8 @@ emoji: 💬
 colorFrom: red
 colorTo: red
 sdk: streamlit
-sdk_version: 1.26.0
-app_file: convosim.py
+sdk_version: 1.38.0
+app_file: main.py
 pinned: false
 ---
 

app_config.py

@@ -19,8 +19,11 @@ SOURCES_LAB = {"OA_rolemodel":'OpenAI GPT4o',
 ENDPOINT_NAMES = {
     # "CTL_llama2": "texter_simulator",
     "CTL_llama3": "texter_simulator_llm",
+    # "CTL_llama3": "databricks-meta-llama-3-1-70b-instruct",
     # 'CTL_llama2': "llama2_convo_sim",
-    "CTL_mistral": "convo_sim_mistral"
+    # "CTL_mistral": "convo_sim_mistral",
+    "CPC": "phase_classifier",
+    "BadPractices": "training_adherence_bp"
 }
 
 def source2label(source):
@@ -36,6 +39,8 @@ DB_CONVOS = 'conversations'
 DB_COMPLETIONS = 'comparison_completions'
 DB_BATTLES = 'battles'
 DB_ERRORS = 'completion_errors'
+DB_CPC = "cpc_comparison"
+DB_BP = "bad_practices_comparison"
 
 MAX_MSG_COUNT = 60
 WARN_MSG_COUT = int(MAX_MSG_COUNT*0.8)

main.py

@@ -0,0 +1,14 @@
+import streamlit as st
+from streamlit.logger import get_logger
+
+from utils.app_utils import are_models_alive
+
+logger = get_logger(__name__)
+
+st.set_page_config(page_title="Conversation Simulator")
+
+with st.status("Loading Models Please Wait...(this may take up to 5 min)", expanded=True) as status:
+    if not are_models_alive():
+        st.switch_page("pages/model_loader.py")
+    else: 
+        st.switch_page("pages/convosim.py")

models/databricks/texter_sim_llm.py

@@ -17,14 +17,12 @@ texter:"""
 def get_databricks_chain(source, issue, language, memory, temperature=0.8, texter_name="Kit"):
 
     endpoint_name = ENDPOINT_NAMES.get(source, "texter_simulator")
-    
     PROMPT = PromptTemplate(
         input_variables=['history', 'input'],
         template=_DATABRICKS_TEMPLATE_
     )
     
     llm = CustomDatabricksLLM(
-        # endpoint_url="https://dbc-6dca8e8f-4084.cloud.databricks.com/serving-endpoints/databricks-meta-llama-3-1-70b-instruct/invocations",
         endpoint_url=os.environ['DATABRICKS_URL'].format(endpoint_name=endpoint_name),
         bearer_token=os.environ["DATABRICKS_TOKEN"],
         texter_name=texter_name,
@@ -43,4 +41,17 @@ def get_databricks_chain(source, issue, language, memory, temperature=0.8, texte
     )
 
     logging.debug(f"loaded Databricks model")
-    return llm_chain, None
+    return llm_chain, None
+
+def cpc_is_alive():
+    body_request = {
+        "inputs": [""]
+    }
+    try:
+        # Send request to Serving
+        response = requests.post(url=CPC_URL, headers=HEADERS, json=body_request, timeout=2)
+        if response.status_code == 200:
+            return True
+        else: return False
+    except:
+        return False

models/ta_models/bp_utils.py

@@ -0,0 +1,61 @@
+import streamlit as st
+from streamlit.logger import get_logger
+import requests
+import os
+from .config import model_name_or_path, BP_THRESHOLD
+from transformers import AutoTokenizer
+from utils.mongo_utils import new_bp_comparison
+from app_config import ENDPOINT_NAMES
+
+logger = get_logger(__name__)
+
+tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, truncation_side="left")
+BP_URL = os.environ["DATABRICKS_URL"].format(endpoint_name=ENDPOINT_NAMES["BadPractices"])
+HEADERS = {
+    "Authorization": f"Bearer {os.environ['DATABRICKS_TOKEN']}",
+    "Content-Type": "application/json",
+}
+
+def bp_predict_message(context, input):
+    # context = memory.load_memory_variables({})[memory.memory_key]
+    encoding = tokenizer(
+        context,
+        input,
+        truncation="only_first",
+    )['input_ids']
+    body_request = {
+        "inputs": [tokenizer.decode(encoding)],
+        "params": {
+            "top_k": None
+        }
+    }
+
+    try:
+        # Send request to Serving
+        response = requests.post(url=BP_URL, headers=HEADERS, json=body_request)
+        if response.status_code == 200:
+            response = response.json()['predictions'][0]
+        logger.debug(f"Raw BP prediction is {response}")
+        return [{k:v > BP_THRESHOLD if k=="score" else v for k,v in dict_.items()} for _, dict_ in response.items() ]
+    except:
+        pass
+
+def bp_push2db(manual_confirmation=None):
+    if manual_confirmation is None:
+        if st.session_state.sel_bp == "Advice":
+            manual_confirmation = {"is_advice":True, "is_personal_info":False}
+        elif st.session_state.sel_bp == "Personal Info":
+            manual_confirmation = {"is_advice":False, "is_personal_info":True}
+        elif st.session_state.sel_bp == "Advice & Personal Info":
+            manual_confirmation = {"is_advice":True, "is_personal_info":True}
+        else:
+            manual_confirmation = {"is_advice":False, "is_personal_info":False}
+    new_bp_comparison(**{
+        "client": st.session_state['db_client'],
+        "convo_id": st.session_state['convo_id'],
+        "model": st.session_state['source'],
+        "context": st.session_state["context"],
+        "last_message": st.session_state["last_message"],
+        "ytrue": manual_confirmation,
+        "ypred": {x['label']:x['score'] for x in st.session_state['bp_prediction']},
+    })

models/ta_models/config.py

@@ -0,0 +1,26 @@
+model_name_or_path = "FacebookAI/xlm-roberta-large"
+
+CPC_LABEL2STR = {
+    "0_ActiveEngagement": "Active Engagement",
+    "1_Explore": "Explore",
+    "2_IRA": "Immidiate Risk Assessment",
+    "3_SafetyAssessment": "Safety Assessment",
+    "4_SP&NS": "Safety Planning & Next Steps",
+    "5_EmergencyIntervention": "Emergency Intervention",
+    "6_WrappingUp": "Wrapping Up",
+    "7_Other": "Other",
+}
+
+CPC_LBL_OPTS = list(CPC_LABEL2STR.keys())
+
+def cpc_label2str(phase):
+    return CPC_LABEL2STR[phase]
+
+def phase2int(phase):
+    return int(phase.split("_")[0])
+
+BP_THRESHOLD = 0.7
+BP_LAB2STR = {
+    "is_advice": "Advice",
+    "is_personal_info": "Personal Info Sharing",
+}

models/ta_models/cpc_utils.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from streamlit.logger import get_logger
+import requests
+import os
+from .config import model_name_or_path
+from transformers import AutoTokenizer
+from utils.mongo_utils import new_cpc_comparison
+from app_config import ENDPOINT_NAMES
+
+logger = get_logger(__name__)
+
+tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, truncation_side="left")
+CPC_URL = os.environ["DATABRICKS_URL"].format(endpoint_name=ENDPOINT_NAMES["CPC"])
+HEADERS = {
+    "Authorization": f"Bearer {os.environ['DATABRICKS_TOKEN']}",
+    "Content-Type": "application/json",
+}
+
+def cpc_predict_message(context, input):
+    # context = memory.load_memory_variables({})[memory.memory_key]
+    encoding = tokenizer(
+        context,
+        input,
+        truncation="only_first",
+    )['input_ids']
+    body_request = {
+        "inputs": [tokenizer.decode(encoding)]
+    }
+
+    try:
+        # Send request to Serving
+        response = requests.post(url=CPC_URL, headers=HEADERS, json=body_request)
+        if response.status_code == 200:
+            return response.json()['predictions'][0]["0"]["label"]
+    except:
+        pass
+
+def cpc_push2db(is_same):
+    text_is_same = "SAME" if is_same else "WRONG"
+    logger.debug(f"pushing new {text_is_same} CPC")
+    new_cpc_comparison(**{
+        "client": st.session_state['db_client'],
+        "convo_id": st.session_state['convo_id'],
+        "model": st.session_state['source'],
+        "context": st.session_state["context"],
+        "last_message": st.session_state["last_message"],
+        "ytrue": st.session_state["last_phase"] if is_same else st.session_state["sel_phase"],
+        "ypred": st.session_state["last_phase"],
+    })

pages/convosim.py

@@ -0,0 +1,181 @@
+import os
+import streamlit as st
+from streamlit.logger import get_logger
+from langchain.schema.messages import HumanMessage
+from utils.mongo_utils import get_db_client
+from utils.app_utils import create_memory_add_initial_message, get_random_name,  DEFAULT_NAMES_DF, are_models_alive
+from utils.memory_utils import clear_memory, push_convo2db
+from utils.chain_utils import get_chain, custom_chain_predict
+from app_config import ISSUES, SOURCES, source2label, issue2label, MAX_MSG_COUNT, WARN_MSG_COUT
+from models.ta_models.config import CPC_LBL_OPTS, cpc_label2str, BP_LAB2STR
+from models.ta_models.cpc_utils import cpc_push2db
+from models.ta_models.bp_utils import bp_predict_message, bp_push2db
+
+logger = get_logger(__name__)
+temperature = 0.8
+# username = "barb-chase" #"ivnban-ctl"
+st.set_page_config(page_title="Conversation Simulator")
+
+if "sent_messages" not in st.session_state:
+    st.session_state['sent_messages'] = 0
+    if not are_models_alive():
+        st.switch_page("pages/model_loader.py")
+
+if "total_messages" not in st.session_state:
+    st.session_state['total_messages'] = 0
+if "issue" not in st.session_state:
+    st.session_state['issue'] = ISSUES[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()
+if 'texter_name' not in st.session_state:
+    st.session_state["texter_name"] = get_random_name(names_df=DEFAULT_NAMES_DF)
+    logger.debug(f"texter name is {st.session_state['texter_name']}")
+if "last_phase" not in st.session_state:
+    st.session_state["last_phase"] = CPC_LBL_OPTS[0]
+    # st.session_state["sel_phase"] = CPC_LBL_OPTS[0]
+if "changed_cpc" not in st.session_state:
+    st.session_state["changed_cpc"] = False
+if "changed_bp" not in st.session_state:
+    st.session_state["changed_bp"] = False
+
+# st.session_state["sel_phase"] = st.session_state["last_phase"]
+
+memories = {'memory':{"issue": st.session_state['issue'], "source": st.session_state['previous_source']}}
+
+with st.sidebar:
+    username = st.text_input("Username", value='Dani', max_chars=30)
+    if 'counselor_name' not in st.session_state:
+        st.session_state["counselor_name"] = username #get_random_name(names_df=DEFAULT_NAMES_DF)
+    # temperature = st.slider("Temperature", 0., 1., value=0.8, step=0.1)
+    issue = st.selectbox("Select a Scenario", ISSUES, index=0, format_func=issue2label,
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
+                        )
+    supported_languages = ['en', "es"] if issue == "Anxiety" else ['en']
+    language = st.selectbox("Select a Language", supported_languages, index=0,
+                            format_func=lambda x: "English" if x=="en" else "Spanish",
+                            on_change=clear_memory, kwargs={"memories":memories, "username":username, "language":"English"}
+                        )
+                            
+    source = st.selectbox("Select a source Model A", SOURCES, index=0,
+                          format_func=source2label, key="source"
+                        )
+
+changed_source = any([
+    st.session_state['previous_source'] != source,
+    st.session_state['issue'] != issue,
+    st.session_state['counselor_name'] != username,
+])
+if changed_source:
+    st.session_state["counselor_name"] = username
+    st.session_state["texter_name"] = get_random_name(names_df=DEFAULT_NAMES_DF)
+    logger.debug(f"texter name is {st.session_state['texter_name']}")
+    st.session_state['previous_source'] = source
+    st.session_state['issue'] = issue
+    st.session_state['sent_messages'] = 0
+    st.session_state['total_messages'] = 0
+create_memory_add_initial_message(memories,
+                                  issue, 
+                                  language, 
+                                  changed_source=changed_source, 
+                                  counselor_name=st.session_state["counselor_name"], 
+                                  texter_name=st.session_state["texter_name"])
+st.session_state['previous_source'] = source
+memoryA = st.session_state[list(memories.keys())[0]]
+# issue only without "." marker for model compatibility
+llm_chain, stopper = get_chain(issue, language, source, memoryA, temperature, texter_name=st.session_state["texter_name"])
+
+st.title("💬 Simulator") 
+st.session_state['total_messages'] = len(memoryA.chat_memory.messages)
+for msg in memoryA.buffer_as_messages:
+    role = "user" if type(msg) == HumanMessage else "assistant"
+    st.chat_message(role).write(msg.content)
+
+def sent_request_llm(llm_chain, prompt):
+    st.session_state['sent_messages'] += 1
+    st.chat_message("user").write(prompt)
+    responses = custom_chain_predict(llm_chain, prompt, stopper)
+    for response in responses:
+        st.chat_message("assistant").write(response)
+
+# @st.dialog("Bad Practice Detected")
+# def confirm_bp(bp_prediction, prompt):
+#     bps = [BP_LAB2STR[x['label']] for x in bp_prediction if x['score']]
+#     st.markdown(f"The last message was considered :red[{' and '.join(bps)}]")
+#     "Are you sure you want to send this message?"
+#     newprompt = st.text_input("Change message to:")
+#     "If you do not want to change leave textbox empty"
+#     for bp in BP_LAB2STR.keys():
+#         _ = st.checkbox(f"Original Message was {BP_LAB2STR[bp]}", key=f"chkbx_{bp}", value=BP_LAB2STR[bp] in bps)
+
+#     if st.button("Confirm"):
+#         if newprompt is not None and newprompt != "":
+#             prompt = newprompt
+#         bp_push2db(
+#             {bp:st.session_state[f"chkbx_{bp}"] for bp in BP_LAB2STR.keys()}
+#         )
+#         sent_request_llm(llm_chain, prompt)
+#         st.rerun()
+
+if prompt := st.chat_input(disabled=st.session_state['total_messages'] > MAX_MSG_COUNT - 4): #account for next interaction
+    if 'convo_id' not in st.session_state:
+        push_convo2db(memories, username, language)
+    st.session_state['context'] = llm_chain.memory.load_memory_variables({})[llm_chain.memory.memory_key]
+    st.session_state['last_message'] = prompt
+    if (not st.session_state.changed_cpc) and st.session_state["sent_messages"] > 0:
+        cpc_push2db(True)
+    else: st.session_state.changed_cpc = False
+    if (not st.session_state.changed_bp) and st.session_state["sent_messages"] > 0:
+        bp_push2db({x['label']:x['score'] for x in st.session_state['bp_prediction']})
+    else: st.session_state.changed_bp = False
+
+    context = llm_chain.memory.load_memory_variables({})[llm_chain.memory.memory_key]
+    st.session_state['bp_prediction'] = bp_predict_message(context, prompt)
+    if any([x['score'] for x in st.session_state['bp_prediction']]):
+        for bp in st.session_state['bp_prediction']:
+            if bp["score"]:
+                st.error(f"Detected {BP_LAB2STR[bp['label']]} in the last message!")
+        st.session_state.changed_bp = True
+    else:
+        sent_request_llm(llm_chain, prompt)
+
+with st.sidebar:
+    st.divider()
+    st.markdown(f"### Total Sent Messages: :red[**{st.session_state['sent_messages']}**]")
+    st.markdown(f"### Total Messages: :red[**{st.session_state['total_messages']}**]")
+    # st.markdown()
+    def on_change_cpc():
+        cpc_push2db(False)
+        st.session_state.changed_cpc = True
+    def on_change_bp():
+        bp_push2db()
+        st.session_state.changed_bp = True
+
+    if st.session_state["sent_messages"] > 0:
+        _ = st.selectbox(f"""Last Human Message was considered :blue[**{
+            cpc_label2str(st.session_state['last_phase'])
+        }**]. If not please select from the following options""", 
+
+            CPC_LBL_OPTS, index=None,format_func=cpc_label2str, on_change=on_change_cpc,
+            key="sel_phase",
+        )
+
+        BPs = [BP_LAB2STR[x['label']] for x in st.session_state['bp_prediction'] if x['score']]
+        selecttitle = f"""Last Human Message was considered :blue[**{
+            " and ".join(BPs)
+        }**].""" if len(BPs) > 0 else "Last Human Message was NOT considered Bad Practice."
+        _ = st.selectbox(selecttitle + " If not please select from the following options""", 
+
+            ["None", "Advice", "Personal Info", "Advice & Personal Info"], index=None, on_change=on_change_bp,
+            key="sel_bp"
+        )
+
+st.session_state['total_messages'] = len(memoryA.chat_memory.messages)
+if st.session_state['total_messages'] >= MAX_MSG_COUNT:
+    st.toast(f"Total of {MAX_MSG_COUNT} Messages reached. Conversation Ended", icon=":material/verified:")
+elif st.session_state['total_messages'] >= WARN_MSG_COUT:
+    st.toast(f"The conversation will end at {MAX_MSG_COUNT} Total Messages ", icon=":material/warning:")
+
+if not are_models_alive():
+    st.switch_page("pages/model_loader.py")

pages/model_loader.py

@@ -0,0 +1,53 @@
+import time
+import streamlit as st
+from streamlit.logger import get_logger
+from utils.app_utils import is_model_alive
+from app_config import ENDPOINT_NAMES
+
+logger = get_logger(__name__)
+
+st.set_page_config(page_title="Conversation Simulator")
+
+models_alive = False
+start = time.time()
+
+MODELS2LOAD = {
+    "CPC": {"model_name": "Phase Classifier", "loaded":False,},
+    "CTL_llama3": {"model_name": "Texter Simulator", "loaded":False,},
+    "BadPractices": {"model_name": "Advice Identificator", "loaded":False},
+}
+
+def write_model_status(writer, model_name, loaded, fail=False):
+    if loaded:
+        writer.write(f"✅ - {model_name} Loaded")
+    else:
+        if fail:
+            writer.write(f"❌ - {model_name} Failed to Load")
+        else:
+            writer.write(f"🔄 - {model_name} Loading")
+
+with st.status("Loading Models Please Wait...(this may take up to 5 min)", expanded=True) as status:
+
+    for k in MODELS2LOAD.keys():
+        MODELS2LOAD[k]["writer"] = st.empty()
+
+    while not models_alive:
+        time.sleep(2)
+        for name, config in MODELS2LOAD.items():
+            config["loaded"] = is_model_alive(ENDPOINT_NAMES[name])
+
+        models_alive = all([x['loaded'] for x in MODELS2LOAD.values()])
+        
+        for _, config in MODELS2LOAD.items():
+            write_model_status(**config)
+        
+        if int(time.time()-start) > 30:
+            status.update(
+                label="Models took too long to load. Please Refresh Page in a couple of minutes", state="error", expanded=True
+            )
+            for _, config in MODELS2LOAD.items():
+                write_model_status(**config, fail=True)
+            break
+
+if models_alive:
+    st.switch_page("pages/convosim.py")

requirements.txt

@@ -4,4 +4,5 @@ mlflow==2.9.0
 langchain==0.3.0
 langchain-openai==0.2.0
 langchain-community==0.3.0
-streamlit==1.38.0
+streamlit==1.38.0
+transformers==4.43.0

utils/app_utils.py

@@ -1,19 +1,22 @@
 import pandas as pd
 import streamlit as st
 from streamlit.logger import get_logger
-import langchain
+import os
+import requests
 
-
-from app_config import ENVIRON
+from app_config import ENDPOINT_NAMES
 from utils.memory_utils import change_memories
 from models.model_seeds import seeds
 
-langchain.verbose = ENVIRON =="dev"
 logger = get_logger(__name__)
 
 # TODO: Include more variable and representative names
 DEFAULT_NAMES = ["Olivia", "Kit", "Abby", "Tom", "Carolyne", "Jessiny"]
 DEFAULT_NAMES_DF = pd.read_csv("./utils/names.csv")
+HEADERS = {
+    "Authorization": f"Bearer {os.environ['DATABRICKS_TOKEN']}",
+    "Content-Type": "application/json",
+}
 
 def get_random_name(gender="Neutral", ethnical_group="Neutral", names_df=None):
         if names_df is None:
@@ -61,4 +64,33 @@ def create_memory_add_initial_message(memories, issue, language, changed_source=
         if len(st.session_state[memory].buffer_as_messages) < 1:
             add_initial_message(issue, language, st.session_state[memory], texter_name=texter_name, counselor_name=counselor_name)
 
-    
+def is_model_alive(endpoint_name, timeout=2, model_type="databricks"):
+    if model_type=="databricks":
+        endpoint_url=os.environ['DATABRICKS_URL'].format(endpoint_name=endpoint_name)
+        headers = HEADERS
+        try:
+            # Send request to Serving
+            body_request = {
+                "inputs": [""]
+            }
+            _ = requests.post(url=endpoint_url, headers=HEADERS, json=body_request, timeout=timeout)
+            return True
+        except:
+            return False
+    elif model_type=="openai":
+        endpoint_url="https://api.openai.com/v1/models"
+        headers = {"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",}
+        try:
+            _ = requests.get(url=endpoint_url, headers=headers, timeout=1)
+            return True
+        except:
+            return False 
+    else:
+        raise Exception(f"Model Type {model_type} not supported") 
+
+def are_models_alive():
+    models_alive = []
+    for ename in ENDPOINT_NAMES.values():
+        models_alive.append(is_model_alive(ename))
+    openai = is_model_alive("openai", model_type="openai")
+    return all(models_alive + [openai])

utils/chain_utils.py

@@ -1,9 +1,11 @@
+import streamlit as st
 from streamlit.logger import get_logger
-from models.model_seeds import seeds
+from langchain_core.messages import HumanMessage
 from models.openai.finetuned_models import finetuned_models, get_finetuned_chain
 from models.openai.role_models import get_role_chain, get_template_role_models
 from models.databricks.scenario_sim_biz import get_databricks_biz_chain
 from models.databricks.texter_sim_llm import get_databricks_chain
+from models.ta_models.cpc_utils import cpc_predict_message
 
 logger = get_logger(__name__)
 
@@ -32,7 +34,12 @@ def custom_chain_predict(llm_chain, input, stop):
     llm_chain._validate_inputs(inputs)
     outputs = llm_chain._call(inputs)
     llm_chain._validate_outputs(outputs)
-    llm_chain.memory.chat_memory.add_user_message(inputs['input'])
+    phase = cpc_predict_message(st.session_state['context'], st.session_state['last_message'])
+    st.session_state['last_phase'] = phase
+    logger.debug(phase)
+    llm_chain.memory.chat_memory.add_user_message(
+        HumanMessage(inputs['input'], response_metadata={"phase":phase})
+    )
     for out in outputs[llm_chain.output_key]:
         llm_chain.memory.chat_memory.add_ai_message(out)
     return outputs[llm_chain.output_key]

utils/memory_utils.py

@@ -30,7 +30,6 @@ def change_memories(memories, language, changed_source=False):
     
     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():

utils/mongo_utils.py

@@ -4,7 +4,7 @@ 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
+from app_config import DB_SCHEMA, DB_COMPLETIONS, DB_CONVOS, DB_BATTLES, DB_ERRORS, DB_CPC, DB_BP
 
 DB_URL = os.environ['MONGO_URL']
 DB_USR = os.environ['MONGO_USR']
@@ -99,6 +99,42 @@ def new_completion_error(client, comparison_id, username, model):
     error_id = errors.insert_one(error).inserted_id
     logger.info(f"DBUTILS: new error id is {error_id}")
 
+def new_cpc_comparison(client, convo_id, model, context, last_message, ytrue, ypred):
+    # context = memory.load_memory_variables({})[memory.memory_key]
+    comp = {
+        "error_timestamp": dt.datetime.now(tz=dt.timezone.utc),
+        "conversation_id": convo_id,
+        "model": model,    
+        "context": context,
+        "last_message": last_message,
+        "predicted_phase": ypred,
+        "manual_phase": ytrue,
+    }
+
+    db = client[DB_SCHEMA]
+    cpc_comps = db[DB_CPC]
+    comarison_id = cpc_comps.insert_one(comp).inserted_id
+    # logger.info(f"DBUTILS: new error id is {error_id}")
+
+def new_bp_comparison(client, convo_id, model, context, last_message, ytrue, ypred):
+    # context = memory.load_memory_variables({})[memory.memory_key]
+    comp = {
+        "error_timestamp": dt.datetime.now(tz=dt.timezone.utc),
+        "conversation_id": convo_id,
+        "model": model,    
+        "context": context,
+        "last_message": last_message,
+        "is_advice": ypred["is_advice"],
+        "manual_is_advice": ytrue["is_advice"],
+        "is_pi": ypred["is_personal_info"],
+        "manual_is_pi": ytrue["is_personal_info"],
+    }
+
+    db = client[DB_SCHEMA]
+    bp_comps = db[DB_BP]
+    comarison_id = bp_comps.insert_one(comp).inserted_id
+    logger.info(f"DBUTILS: new BP id is {comarison_id}")
+
 def get_non_assesed_comparison(client, username):
     from bson.son import SON
     pipeline = [