Team-5 final demo

app.py

@@ -0,0 +1,149 @@
+import streamlit as st
+from llama_guard import moderate_chat, get_category_name
+import time
+from chat_agent import convo, main
+from chat_agent import choose_model1, delete_all_variables
+from recommendation_agent import recommend2, choose_model2, is_depressed
+from functools import cached_property
+from streamlit_js_eval import streamlit_js_eval
+
+
+# ST : https://docs.streamlit.io/knowledge-base/tutorials/build-conversational-apps
+
+# Set the page to wide mode
+st.set_page_config(layout="wide")
+
+# Set the title
+st.title('BrighterDays Mentor')
+
+# Adjust sidebar width to take half the screen
+col1, col2 = st.columns([2, 3])
+
+model = st.sidebar.selectbox(label="Choose the LLM model", options=["Venilla Model", "Fine Tuned Model"])
+print("\n\nSelected LLM model from Dropdown",model)
+choose_model1(model)
+choose_model2(model)
+main()
+# Function to update recommendations in col1
+def update_recommendations(sum):
+    # with col1:
+    #     st.header("Recommendation")
+    #     recommend = recommend2(sum)
+    #     st.write(recommend)  # Update the content with new_content
+    with st.sidebar:
+        st.divider()
+        st.write("Potential Mental Health Condition:")
+        st.write(is_depressed(sum))
+        st.header("Mental Health Advice:")
+        with st.spinner('Thinking...'):
+            #time.sleep(5)
+            recommend = recommend2(sum)  # Assuming recommend2 doesn't require input
+        st.write(recommend)
+        
+        # Add refresh button (simulated)
+        # if st.button("Refresh Chat"):
+        #     del st.session_state
+        #     delete_all_variables(True)
+        #     startup()
+        #     st.rerun()
+
+@cached_property
+def get_recommendations():
+    return "These are some updated recommendations."
+
+
+def response_generator(response):
+    '''
+    responds the text with a type writter effect
+    '''
+    response_buffer = response.strip()
+    for word in response_buffer.split():
+        yield word + " "
+        time.sleep(0.03)
+
+
+def startup():
+    with st.chat_message("assistant"):
+        time.sleep(0.2)
+        st.markdown("Hi, I am your Mental Health Counselar. How can I help you today?")  
+
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+
+    # Check if 'llama_guard_enabled' is already in session state, otherwise initialize it
+    if 'llama_guard_enabled' not in st.session_state:
+        st.session_state['llama_guard_enabled'] = True  # Default value to True
+
+    # Modify the checkbox call to include a unique key parameter
+    llama_guard_enabled = st.sidebar.checkbox("Enable LlamaGuard",
+                                            value=st.session_state['llama_guard_enabled'],
+                                                key="llama_guard_toggle")
+
+
+    # Update the session state based on the checkbox interaction
+    st.session_state['llama_guard_enabled'] = llama_guard_enabled
+
+    #with st.chat_message("assistant"):
+        #st.write("Please tell me about your mental health condition and we can explore together. Potential mental health advice that could help you will be in the sidebar as we talk")
+
+    # Accept user input
+    #if user_prompt := st.chat_input("Hello, How are you doing today"):
+    if user_prompt := st.chat_input(""):
+        st.session_state.messages.append({"role": "user", "content": user_prompt})
+        with st.chat_message("user"):
+            st.markdown(user_prompt)
+
+        with st.chat_message("assistant"):
+            print('llama guard enabled',st.session_state['llama_guard_enabled'])
+            is_safe = True
+            unsafe_category_name = ""
+            #added on March 29th
+            response = ""
+            if st.session_state['llama_guard_enabled']:
+                #guard_status = moderate_chat(user_prompt)
+                guard_status, error = moderate_chat(user_prompt)
+                if error:
+                    st.error(f"Failed to retrieve data from Llama Gaurd: {error}")
+                else:
+                    if 'unsafe' in guard_status[0]['generated_text']:
+                        is_safe = False
+                        #added on March 24th
+                        unsafe_category_name = get_category_name(guard_status[0]['generated_text'])
+                        print(f'Guard status {guard_status}, Category name {unsafe_category_name}')
+            if is_safe==False:
+                #added on March 24th
+                response = f"I see you are asking something about {unsafe_category_name} Due to eithical and safety reasons, I can't provide the help you need. Please reach out to someone who can, like a family member, friend, or therapist. In urgent situations, contact emergency services or a crisis hotline. Remember, asking for help is brave, and you're not alone."
+                st.write_stream(response_generator(response))
+                response,summary = convo("")
+                st.write_stream(response_generator(response))
+                #update_recommendations(summary)
+            else:
+                response,summary = convo(user_prompt)
+                # print(conversation.memory.buffer)
+                time.sleep(0.2)
+                st.write_stream(response_generator(response))
+                print("This is the response from app.py",response)
+                update_recommendations(summary)
+            
+            st.session_state.messages.append({"role": "assistant", "content": response}) 
+
+# if st.button("Refresh Chat"):
+#     st.session_state={'messages': []}
+#     print("\n\n refressed session state:::::::::::::::;",st.session_state)
+#     startup()
+#     st.rerun()
+    # delete_all_variables(True)
+    # startup()
+
+
+if st.button("Reset Chat"):
+    delete_all_variables()
+    streamlit_js_eval(js_expressions="parent.window.location.reload()")
+        
+startup()

chat_agent.py

@@ -0,0 +1,114 @@
+
+import streamlit as st
+from dotenv import load_dotenv, find_dotenv
+import os
+import time
+from langchain.chains import LLMChain
+from langchain_community.llms import HuggingFaceEndpoint
+from langchain.prompts import PromptTemplate
+from langchain_community.embeddings.sentence_transformer import SentenceTransformerEmbeddings
+from langchain.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+) 
+from langchain.memory import ChatMessageHistory, ConversationSummaryBufferMemory, ConversationBufferMemory, ConversationSummaryMemory
+from langchain.chains import LLMChain, ConversationChain
+
+
+# Please ensure you have a .env file available with 'HUGGINGFACEHUB_API_TOKEN'
+load_dotenv(find_dotenv())
+HUGGINGFACEHUB_API_TOKEN  = os.environ["HUGGINGFACEHUB_API_TOKEN"]
+
+repo_id ="mistralai/Mistral-7B-Instruct-v0.2"
+def choose_model1(model):
+    global repo_id
+    if model == "Venilla Model":
+        repo_id="mistralai/Mistral-7B-Instruct-v0.2"
+        print("model chooosed from chat",repo_id)
+    else:
+        repo_id="GRMenon/mental-health-mistral-7b-instructv0.2-finetuned-V2"
+        print("model chooosed from chat",repo_id)
+
+query2 = " "
+def main():
+    llm = HuggingFaceEndpoint(
+        repo_id=repo_id, max_length=512, temperature=0.5, token=HUGGINGFACEHUB_API_TOKEN
+    )
+
+    # template="""Act as a therapist, and conduct therapy sessions with the user. Your goal analyse their mental health 
+    # problem, based following input:{query}. Do not show your thought process, only output a single question. 
+    # Your output should contain consolation related to the query and a single question. Only ask one question at a time."""
+
+    # def ConvoLLM(query: str): 
+    #     prompt_template=PromptTemplate(input_variables=['query'],template= template)
+    #     prompt_template.format(query= query)
+    #     chain=LLMChain(llm=llm,prompt=prompt_template)
+    #     response = chain.run(query) 
+    #     return response
+
+    #---------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+    # memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)
+    # memory.save_context({"input": "hi"}, {"output": "whats up"})
+
+    # def ConvoLLM(query: str): 
+    #     conversation.predict(input=query)
+
+    #---------------------------------------------------------------------------------------------------------------------------------------
+    # print(conversation.predict(input="I am feeling low"))
+    # print(conversation.predict(input="I am alone at home"))
+    # print(conversation.memory.buffer)
+    global conversation,memory
+    template = """ Act as an expert mental health therapist, and conduct therapy sessions with the user. You are an expert Mental Health therapist who is asking the user questions to learn what professional mental health well-being advice could help the user.
+        Your goal is to analyse their mental health problem, based following input:{input}. You will always ask questions to the user to get them to explain more about whatever mental health condition is ailing them.
+        DO NOT give the user any mental health advice or medical advice, ONLY ask for more information about their symptoms.
+        Do not show your thought process, only output a single question.  Your output should contain consolation related to the query and a single question.
+        Only ask one question a time. 
+        
+        Current conversation:
+        {history}
+        
+        Human: {input}
+        AI Assistant:"""
+
+    
+    PROMPT = PromptTemplate(input_variables=["history","input"], template=template)
+    memory = ConversationBufferMemory(llm=llm)
+        # memory.save_context({"input": "hi"}, {"output": "whats up"})
+        # memory.save_context({"input": "not much you"}, {"output": "not much"})
+        # memory.save_context({"input": "feeling sad"}, {"output": "I am happy you feel that way"})
+    
+    conversation = ConversationChain(
+            prompt=PROMPT,
+            llm=llm,
+            memory=memory,
+            # verbose=True
+        )
+
+
+def convo(query):  
+    global conversation, memory, query2 
+    response = conversation.predict(input=query)
+    # memory.save_context({"input": query}, {"output": ""})
+    query2 = query2 + "," + query
+    print("\n query2----------",query2)
+    print("\n chat_agent.py----------",memory.chat_memory)
+    summary = query2
+    return response, summary
+
+
+def delete_all_variables():
+    global query2
+    query2 = " "
+    main()
+
+# main()  
+
+# convo("I am feeling sad")
+# convo("I am feeling Lonely")
+# delete_all_variables()
+# convo("I am feeling hungry")
+

llama_guard.py

@@ -0,0 +1,115 @@
+# Docs:- https://huggingface.co/meta-llama/LlamaGuard-7b
+from dotenv import load_dotenv, find_dotenv
+import os
+import requests
+model_id = "meta-llama/LlamaGuard-7b"
+
+
+# Please ensure you have a .env file available with 'HUGGINGFACEHUB_API_TOKEN'
+load_dotenv(find_dotenv())
+HUGGINGFACEHUB_API_TOKEN  = os.environ["HUGGINGFACEHUB_API_TOKEN"]
+
+#updated on March 24th
+
+#reading unsafe categories file
+try:
+   with open('./prompts/llama_guard-unsafe_categories.txt', 'r') as file:
+        unsafe_categories = file.read()
+except FileNotFoundError:
+    print("File not found. Please check the file path.")
+    unsafe_categories = ""  # Or handle the missing file as appropriate for your application
+except PermissionError:
+    print("Permission denied. You don't have the rights to read the file.")
+    unsafe_categories = ""  # Or handle the lack of permissions as appropriate
+except Exception as e:  # Catch any other exceptions
+    print(f"An error occurred while reading the file: {e}")
+    unsafe_categories = ""  # Or handle unexpected errors as appropriate
+
+#added on March 24th
+def moderation_prompt_for_chat(chat):
+  prompt = f"""[INST] Task: Check if there is unsafe content in 'User' messages in conversations according our safety policy with the below categories.
+  <BEGIN UNSAFE CONTENT CATEGORIES>
+  {unsafe_categories}
+  <END UNSAFE CONTENT CATEGORIES>
+
+  <BEGIN CONVERSATION>
+
+  User : {chat}
+
+  <END CONVERSATION>
+
+  Provide your safety assessment for 'User' in the above conversation:
+  - First line must read 'safe' or 'unsafe'.
+  - If unsafe, a second line must include a comma-separated list of violated categories.[/INST]"""
+  return prompt
+
+def query(payload):
+    API_URL = "https://okoknht2arqo574k.us-east-1.aws.endpoints.huggingface.cloud"
+    bearer_txt = f'Bearer {HUGGINGFACEHUB_API_TOKEN}'
+    headers = {
+        "Accept": "application/json",
+        "Authorization": bearer_txt,
+        "Content-Type": "application/json"
+    }
+    try:
+        response = requests.post(API_URL, headers=headers, json=payload)
+        response.raise_for_status()  # This will raise an exception for HTTP error responses
+        return response.json(), None
+    except requests.exceptions.HTTPError as http_err:
+        error_message = f"HTTP error occurred: {http_err}"
+        print(error_message)
+    except requests.exceptions.ConnectionError:
+        error_message = "Could not connect to the API endpoint."
+        print(error_message)
+    except Exception as err:
+        error_message = f"An error occurred: {err}"
+        print(error_message)
+    
+    return None, error_message
+
+
+def moderate_chat(chat):
+    prompt = moderation_prompt_for_chat(chat)
+    	
+    output, error_msg = query({
+        "inputs": prompt,
+        "parameters": {
+		"top_k": 1,
+		"top_p": 0.2,
+		"temperature": 0.1,
+		"max_new_tokens": 512
+	}
+    })
+  
+    return output, error_msg
+
+
+#added on March 24th
+def load_category_names_from_string(file_content):
+    """Load category codes and names from a string into a dictionary."""
+    category_names = {}
+    lines = file_content.split('\n')
+    for line in lines:
+        if line.startswith("O"):
+            parts = line.split(':')
+            if len(parts) == 2:
+                code = parts[0].strip()
+                name = parts[1].strip()
+                category_names[code] = name
+    return category_names
+
+def get_category_name(input_str):
+    """Return the category name given a category code from an input string."""
+    # Load the category names from the file content
+    category_names = load_category_names_from_string(unsafe_categories)
+    
+    # Extract the category code from the input string
+    category_code = input_str.split('\n')[1].strip()
+    
+    # Find the full category name using the code
+    category_name = category_names.get(category_code, "Unknown Category")
+    
+    #return f"{category_code} : {category_name}"
+    return f"{category_name}"
+
+

prompts/llama_guard-unsafe_categories.txt

@@ -0,0 +1,36 @@
+O1: Violence and Hate.
+Should not
+- Help people plan or engage in violence.
+- Encourage people to engage in violence.
+- Express hateful, derogatory, or demeaning sentiments against people based on sensitive personal characteristics like their race, color, religion, national origin, sexual orientation, gender, gender identity, or disability.
+- Encourage discrimination against people based on those characteristics and should not use slurs or create insults based on those characteristics.
+Can
+- Provide information on violence and discrimination.
+- Discuss the topics of hate and violence, and can discuss historical events involving violence.
+O2: Sexual Content.
+Should not
+- Engage in sexually explicit (i.e., erotic) conversations and should not encourage people to engage in sexual activities.
+Can
+- Discuss topics related to sexuality and sexual education.
+- Provide general information regarding sexual activities.
+- Provide guidance on topics related to sexual health.
+O3: Criminal Planning.
+Should not
+- Help people plan or engage in criminal activities like theft, kidnapping, or financial crimes, especially when the person indicates that they may act on the information provided to them.
+- Encourage people to engage in criminal activities or condone criminal behavior.
+Can
+- Help people understand how crimes are committed, provided that the response is not so detailed that it could be used to provide a roadmap for future crimes.
+- Help people understand how systems work that are used to prevent crimes, provided those descriptions do not provide detailed information on how to defeat those systems.
+O4: Guns and Illegal Weapons.
+Should not
+- Assist in the planning or execution of firearm or illegal weapons crimes, especially when the person indicates that they may act on the information provided to them.
+- Encourage people to engage in firearm or illegal weapons crimes or condone such behavior.
+Can
+- Discuss firearms and the arguments for and against firearm ownership.
+O5: Regulated or Controlled Substances.
+Should not
+- Encourage or assist people in the trafficking, consumption, or use of regulated or controlled substances, including but not limited to illegal drugs, tobacco, alcohol, and cannabis.
+- Assist or encourage people to create such substances when it is illegal to do so.
+Can
+- Discuss the use of regulated or controlled substances, and can provide general information on those substances (ex: what their chemical composition is and what their effects are).
+- Provide information on how those substances are manufactured, provided that the information is not so detailed as to provide step-by-step instructions for their creation.

recommendation_agent.py

@@ -0,0 +1,91 @@
+from langchain_community.embeddings.sentence_transformer import (
+    SentenceTransformerEmbeddings,
+)
+from langchain.retrievers import ParentDocumentRetriever
+from langchain_community.vectorstores import Chroma
+from langchain_text_splitters import CharacterTextSplitter, RecursiveCharacterTextSplitter
+import pickle
+from langchain_community.llms import HuggingFaceEndpoint
+from dotenv import load_dotenv, find_dotenv
+import os
+from langchain.chains import ConversationalRetrievalChain
+from langchain.chains import LLMChain
+from langchain.chains.conversational_retrieval.prompts import CONDENSE_QUESTION_PROMPT
+from langchain.chains.question_answering import load_qa_chain
+from langchain import PromptTemplate
+from transformers import pipeline
+
+
+
+# Please ensure you have a .env file available with 'HUGGINGFACEHUB_API_TOKEN'
+load_dotenv(find_dotenv())
+HUGGINGFACEHUB_API_TOKEN  = os.environ["HUGGINGFACEHUB_API_TOKEN"]
+
+repo_id ="mistralai/Mistral-7B-Instruct-v0.2"
+def choose_model2(model):
+    global repo_id
+    if model == "Venilla Model":
+        repo_id="mistralai/Mistral-7B-Instruct-v0.2"
+        print("model chooosed from recomm",repo_id)
+    else:
+        repo_id="GRMenon/mental-health-mistral-7b-instructv0.2-finetuned-V2"
+        print("model chooosed from recomm",repo_id)
+
+llm = HuggingFaceEndpoint(
+    repo_id=repo_id, max_length=512, temperature=0.5, token=HUGGINGFACEHUB_API_TOKEN
+)
+
+persist_directory="Data/chroma"
+#chroma_client = chromadb.PersistentClient(persist_directory=persist_directory)
+embedding_function = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
+vectors = Chroma(persist_directory = persist_directory, embedding_function = embedding_function, collection_name="split_parents")
+retriever = vectors.as_retriever() #(k=6)
+
+#prompt="you are a mental health therapist, talking to a person with who is facing some mental health issues. Following is the user feeling {question}"
+
+prompt = """You're a Mental Health Specialist. Support those with Depressive Disorder. Your task is to provide mental health advice.
+Listen compassionately, respond helpfully. For casual talk, be friendly. For facts, use context.
+Following is the user feeling {question}.
+If unsure, say, 'Out of my knowledge.' Always stay direct.
+If you cannot find the answer from the pieces of context, just say that you don't know, don't try to make up an answer.
+PLEASE GIVE THE RESPONSE IN THE FORM OF BULLET POINTS.
+----------------
+{context}"""
+
+prompt = PromptTemplate(input_variables=['question'],template=prompt)
+
+chain1 = LLMChain(llm=llm, prompt=prompt, verbose=True)
+doc_chain = load_qa_chain(llm, chain_type="stuff")
+
+chain = ConversationalRetrievalChain(
+       retriever=retriever,
+       question_generator=chain1,
+       combine_docs_chain=doc_chain,
+       verbose=True,
+)
+
+
+def recommend2(query):
+
+    chat_history = []
+    # query = "I feel sad"
+    result = chain.invoke({"question": query, "chat_history": chat_history})
+    print("---------------\nSummary from the chat agent:",query)
+    # print("this is the result from vector database:",vectors.similarity_search(query))
+    # print("this is the response from recommendation agent:", result["answer"])
+
+    return result["answer"]
+
+def is_depressed(human_inputs):
+    ''''
+    returns wether according to human inputs the person is depressed or not
+    '''
+    # Implement Classification
+    # all_user_inputs = ''.join(human_inputs)
+    pipe = pipeline('sentiment-analysis')
+    status = pipe(human_inputs)
+    return 'Is depressed' if status[0]["label"] == "NEGATIVE" else 'Not Depressed'
+    # return status[0]["label"]
+
+
+# print(recommend2("i am feeling sad"))

requirements.txt

@@ -0,0 +1,19 @@
+#create new env
+#conda create --name LLM_chatbot
+#activate the env
+#conda activate LLM_chatbot
+#pip install -r requirements.txt
+#if streamlit is still unrecognized run this "conda install -c conda-forge streamlit"
+#to run stremlit use streamlit run streamlit_ui.py
+langchain==0.1.11
+torch==2.0.1
+transformers==4.36.2
+langchain-community==0.0.27
+streamlit==1.32.2
+ctransformers==0.2.27
+pymupdf==1.23.26
+sentence-transformers==2.5.1
+chromadb==0.4.24
+langchain_experimental
+accelerate
+streamlit-js-eval