Upload 4 files

app.py

@@ -0,0 +1,175 @@
+from langchain.chat_models import ChatOpenAI
+import streamlit as st
+from gtts import gTTS
+from io import BytesIO
+from langchain.chains import RetrievalQA
+from langchain.chains.conversation.memory import ConversationBufferWindowMemory
+from streamlit_mic_recorder import speech_to_text
+from langchain.prompts import (
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+    ChatPromptTemplate,
+    MessagesPlaceholder
+)
+from langchain_community.llms.huggingface_hub import HuggingFaceHub
+from streamlit_chat import message
+
+
+with st.sidebar:
+    if "name" not in st.session_state:
+        st.session_state["name"] =""
+
+    name= st.text_input("Enter name", st.session_state["name"])
+
+    if "age" not in st.session_state:
+        st.session_state["age"] =""
+    age= st.text_input("Enter age", st.session_state["age"])
+    submit = st.button("Submit")
+
+    if submit:
+        st.session_state["name"] = name
+        st.session_state["age"] = age
+        st.write("name and age submitted")
+
+st.title("Mental Health Bot :heartpulse:")
+st.subheader("Here to help")
+
+if 'responses' not in st.session_state:
+    st.session_state['responses'] = ["How can I assist you?"]
+
+if 'requests' not in st.session_state:
+    st.session_state['requests'] = []
+    
+access_token = HUGGING_FACE_API
+hf_repo_id = 'mistralai/Mistral-7B-Instruct-v0.1'
+
+
+llm =HuggingFaceHub(
+            repo_id=hf_repo_id,
+            model_kwargs={"temperature": 0.2, "max_length": 32000}, huggingfacehub_api_token = access_token
+        )
+
+
+if 'buffer_memory' not in st.session_state:
+            st.session_state.buffer_memory=ConversationBufferWindowMemory(k=3,return_messages=True)
+
+
+system_msg_template = SystemMessagePromptTemplate.from_template(template="""Answer the question as truthfully as possible using the provided context, 
+and if the answer is not contained within the text below, say 'I don't know'""")
+
+
+human_msg_template = HumanMessagePromptTemplate.from_template(template="{input}")
+
+prompt_template = ChatPromptTemplate.from_messages([system_msg_template, MessagesPlaceholder(variable_name="history"), human_msg_template])
+
+#conversation = ConversationChain.from_template(memory=st.session_state.buffer_memory,
+                               #  prompt = prompt_template, llm=llm, verbose = True)
+
+import re
+from langchain.memory import ConversationBufferMemory
+
+# Define the extract_helpful_answer function
+def extract_helpful_answer(text):
+    match = re.search(r'Helpful Answer:(.*)', text)
+    if match:
+        return match.group(1).strip()
+    else:
+        return None
+
+# Initialize the conversation buffer memory
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+from utils import retriever
+# Create the RetrievalQA instance
+qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, memory=memory)
+
+# Function to process LLM response and extract helpful answer
+def process_llm_response(llm_response):
+    if 'result' in llm_response:
+        helpful_answer = extract_helpful_answer(llm_response['result'])
+        if helpful_answer:
+            return helpful_answer
+        else:
+            return "No helpful answer found."
+
+#container for chat history
+response_container = st.container()
+#container for text box
+textcontainer = st.container()
+
+#from utils import find_match
+def speech_recognition_callback():
+    # Ensure that speech output is available
+    if st.session_state.my_stt_output is None:
+        st.session_state.p01_error_message = "Please record your response again."
+        return
+    
+    # Clear any previous error messages
+    st.session_state.p01_error_message = None
+        
+    # Store the speech output in the session state
+    st.session_state.speech_input = st.session_state.my_stt_output
+
+def text_to_speech(text):
+    # Use gTTS to convert text to speech
+    tts = gTTS(text=text, lang='en')
+    # Save the speech as bytes in memory
+    fp = BytesIO()
+    tts.write_to_fp(fp)
+    return fp
+
+# Add a text input field for both speech and text queries
+# Add a text input field for both speech and text queries
+with textcontainer:
+    # Use the speech_to_text function to capture speech input
+    speech_input = speech_to_text(
+        key='my_stt', 
+        callback=speech_recognition_callback
+    )
+
+    # Check if speech input is available
+    if 'speech_input' in st.session_state and st.session_state.speech_input:
+        # Display the speech input
+        st.text(f"Speech Input: {st.session_state.speech_input}")
+        
+        # Process the speech input as a query
+        query = st.session_state.speech_input
+        with st.spinner("processing....."):
+            response = qa(query)
+            helpful_answer = process_llm_response(response)
+            # Append the query and response to session state
+            st.session_state.requests.append(query)
+            st.session_state.responses.append(helpful_answer)
+            
+            # Convert the response to speech
+            speech_fp = text_to_speech(helpful_answer)
+            # Play the speech
+            st.audio(speech_fp, format='audio/mp3')
+
+    # Add a text input field for query
+    query = st.text_input("Query: ", key="input")
+
+    # Process the query if it's not empty
+    if query:
+        with st.spinner("typing....."):
+            response = qa(query)
+            helpful_answer = process_llm_response(response)
+            # Append the query and response to session state
+            st.session_state.requests.append(query)
+            st.session_state.responses.append(helpful_answer)
+            
+            # Convert the response to speech
+            speech_fp = text_to_speech(helpful_answer)
+            # Play the speech
+            st.audio(speech_fp, format='audio/mp3')
+
+
+
+# Display the chat history and response
+with response_container:
+    if st.session_state['responses']:
+
+        for i in range(len(st.session_state['responses'])):
+            message(st.session_state['responses'][i],key=str(i))
+            if i < len(st.session_state['requests']):
+                message(st.session_state["requests"][i], is_user=True,key=str(i)+ '_user')

main.py

@@ -0,0 +1,16 @@
+# This is a sample Python script.
+
+# Press Shift+F10 to execute it or replace it with your code.
+# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
+
+
+def print_hi(name):
+    # Use a breakpoint in the code line below to debug your script.
+    print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.
+
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+    print_hi('PyCharm')
+
+# See PyCharm help at https://www.jetbrains.com/help/pycharm/

requirments.txt

@@ -0,0 +1,8 @@
+sentence_transformers
+langchain_community
+streamlit
+gtts
+io
+streamlit_mic_recorder
+streamlit_chat
+langchain

utils.py

@@ -0,0 +1,72 @@
+from sentence_transformers import SentenceTransformer
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.llms import HuggingFaceHub
+import openai
+import streamlit as st
+import re
+
+#openai_api_key = "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"
+model = SentenceTransformer('sentence-transformers/multi-qa-MiniLM-L6-cos-v1')
+# Define the embedding function using HuggingFaceEmbeddings
+embeddings = HuggingFaceEmbeddings(model_name = 'sentence-transformers/multi-qa-MiniLM-L6-cos-v1')
+
+vectordb = Chroma(persist_directory= r"C:\Users\Lakshita\PycharmProjects\trial_bot\vector db", #enter chroma directory
+                  embedding_function=embeddings)
+#index = pinecone.Index('langchain-chatbot')
+
+# Create a retriever from the Chroma object
+retriever = vectordb.as_retriever()
+
+def find_match(input_text):
+    # Retrieve relevant documents based on the input query
+    docs = retriever.get_relevant_documents(input_text)
+    
+    match_texts = [doc.page_content for doc in docs]
+    
+    # Return the concatenated texts of the relevant documents
+    return "\n".join(match_texts)
+
+
+from transformers import pipeline
+
+# Load the text generation pipeline from Hugging Face
+text_generator = pipeline("text-generation", model="gpt2")
+
+def query_refiner(conversation, query):
+    # Formulate the prompt for the model
+    prompt = f"Given the following user query and conversation log, formulate a question that would be the most relevant to provide the user with an answer from a knowledge base.\n\nCONVERSATION LOG: \n{conversation}\n\nQuery: {query}\n\nRefined Query:"
+    
+    # Generate the response using the Hugging Face model
+    response = text_generator(prompt, max_length=256, temperature=0.7, top_p=1.0, pad_token_id=text_generator.tokenizer.eos_token_id)
+    
+    # Extract the refined query from the response
+    refined_query = response[0]['generated_text'].split('Refined Query:')[-1].strip()
+    
+    return refined_query
+
+
+def get_conversation_string():
+    conversation_string = ""
+    for i in range(len(st.session_state['responses'])-1):
+        
+        conversation_string += "Human: "+st.session_state['requests'][i] + "\n"
+        conversation_string += "Bot: "+ st.session_state['responses'][i+1] + "\n"
+    return conversation_string
+
+
+"""  
+from openai import OpenAI
+from audio_recorder_streamlit import audio_recorder
+
+client=OpenAI(api_key="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")
+
+def speech_to_text(audio_data):
+     with open(audio_data, "rb") as audio_file:
+         transcript = client.audio.transcriptions.create(
+            model="whisper-1",
+            response_format="text",
+            file=audio_file
+         )
+    return transcript
+"""