Building a chatbot using Azure OpenAI and langchain

!pip install streamlit_chat==0.1.1
!pip install streamlit==1.20.0
!pip install langchain==0.0.268
!pip install openai==0.27.8
!pip install hnswlib
!pip install chromadb==0.4.6
!pip install holidays==0.29
!pip install typing-inspect==0.9.0
!pip install typing_extensions==4.6.3
!pip install tiktoken==0.4.0
!pip install sentence_transformers==2.2.2
!pip install Wave
!pip install moviepy
!pip install SpeechRecognition

import os
import wave, math, contextlib
import speech_recognition as sr
from moviepy.editor import AudioFileClip

zoom_video_file_name = "./raw_data/Product_Demo_Recording.mp4"
transcribed_audio_file_name = "./raw_data/Product_Demo_Recording.wav"
transcribed_txt_file_name = "./cleaned_data/Product_Demo_Recording.txt"

file_name = os.path.basename(zoom_video_file_name)
file_name = os.path.splitext(file_name)[0]

audioclip = AudioFileClip(zoom_video_file_name)
audioclip.write_audiofile(transcribed_audio_file_name)
with contextlib.closing(wave.open(transcribed_audio_file_name,'r')) as f:
    frames = f.getnframes()
    rate = f.getframerate()
    duration = frames / float(rate)
total_duration = math.ceil(duration / 60)

print("Converting audio to speech...")
r = sr.Recognizer()
for i in range(0, total_duration):
    with sr.AudioFile(transcribed_audio_file_name) as source:
        audio = r.record(source, offset=i*60, duration=60)
    f = open(transcribed_txt_file_name, "a")
    f.write(r.recognize_google(audio, language = 'en-IN'))
    f.write(" ")
f.close()

import pytesseract
from PIL import Image
img = Image.open("./raw_data/work_schedule.png")
txt = pytesseract.image_to_string(img, lang='eng', config=r' --oem 1 --psm 1 -c preserve_interword_spaces=1')
f = open('./cleaned_data/work_schedule.txt', 'w')
f.write(txt)
f.close()

from langchain.document_loaders import DirectoryLoader
txt_loader = DirectoryLoader(path = "./cleaned_docs/", glob = '*.txt')
docs = txt_loader.load()
# if you have pdf docs use below as well
pdf_loader = DirectoryLoader(path = "./cleaned_docs/", glob = '*.pdf')
docs += pdf_loader.load()

from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size = 1000, #can be adjusted as per your need
    chunk_overlap = 150 #can be adjusted as per your need
)
splits = text_splitter.split_documents(docs)

from langchain.embeddings import HuggingFaceEmbeddings
embedding = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

from langchain.vectorstores import Chroma
persist_directory = './return_exchange_policy/' #save the data to the disk at this location
vectordb = Chroma.from_documents(
    documents=splits,
    embedding=embedding,
    persist_directory=persist_directory
)
vectordb.persist() #to save it to the disk

from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

# lets say this tool answer questions related to return policy
vectordb = Chroma(
    persist_directory=persist_directory, #read from the database
    embedding_function=embedding
)

retriever = vectordb.as_retriever(search_type="similarity", search_kwargs={"k":3})
# K can be increased if you need very detailed response for a question
# retriever_from_llm = MultiQueryRetriever.from_llm(
#    retriever=vectordb.as_retriever(k=3), llm=llm
# )

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever # use one of the above retriever or retriever_from_llm
)
qa_chain.run(question)

import pandas as pd
from langchain.tools.python.tool import PythonAstREPLTool

# python operations tool
# load product data in a dataframe
df = pd.read_csv("product_details.csv")
df_columns = df.columns()
product_tool = PythonAstREPLTool(locals={"df": df}) # provide python_repl tool access to the dataframe

all_tools = [
        Tool(
        name = "QA Chain", # can provide any name here
        func=qa_chain.run,
        description="""
        Useful for when you need to answer question related to return or exchange policy.\.
        Answer based on the Observation and return only what you know. \
        If you can not find the answer say you don't have the answer. \
        Do not include any information which is not provided to you.

        """
        ),
        Tool(
        name = "Product Info",
        func=product_tool.run,
        description = f"""
        Useful for when you need to answer questions about product information
        stored in pandas dataframe 'df'.\
        Run python pandas operations on 'df' to help you get the right answer.\
        'df' has the following columns: {df_columns}\
        
        <user>: What is the config of Kapple kiphone 22 pro?
        <assistant>: df[df['product_name'] == 'Kapple kiphone 22 pro']['configuration']
        <assistant>: Kapple kiphone 22 pro has following configuration.
        ...
        """
    ),

from langchain.chat_models import AzureChatOpenAI
llm = AzureChatOpenAI(deployment_name=OPENAI_DEPLOYMENT,
    openai_api_key=OPENAI_API_KEY,
    openai_api_base = OPENAI_API_BASE,
    openai_api_type = OPENAI_API_TYPE,
    openai_api_version = OPENAI_API_VERSION,
    model_name=OPENAI_MODEL_NAME,
    temperature=0.0 # can be increased upto 1 and tested
    )
# if you are using openai open platform model
# from langchain.chat_models import ChatOpenAI
# llm = ChatOpenAI(    
#     openai_api_key=openai_api_key, 
#     model_name=model_name, # "gpt-3.5-turbo", 
#     temperature=0.0
#     )

agent_kwargs = {'prefix': f'You are a friendly assistant. You are tasked to assist the user on questions related to return/exchange policy, \
                or Product information. You have access to the following tools:'}

# optional, will increase the cost but will be effective to memorize the context
# memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

agent = initialize_agent(all_tools, 
                         llm, 
                         agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, #'chat-copnversational-react-description' #try which is better
                         verbose=True,
                        #  memory=memory,
                         early_stopping_method="generate",
                         max_iterations= len(all_tools),
                         agent_kwargs=agent_kwargs
                         )

agent.run(user_query) # will provide the answer

import streamlit as st
import random
from streamlit_chat import message
from my_agent import agent

st.subheader("Dear customer. I am your customer officer bot.")
st.markdown("I can answer questions related to any product information, configuration, return and exchange policy.")

if "past" not in st.session_state:
    st.session_state["past"] = []
if "generated" not in st.session_state:
    st.session_state["generated"] = []
if "input_message_key" not in st.session_state:
    st.session_state["input_message_key"] = str(random.random())

chat_container = st.container()
user_query = st.text_input("Type your query and press <Send> button.", key=st.session_state["input_message_key"])

if st.button("Send"):
    response = agent.run(user_query)
    st.session_state["past"].append(user_query)
    st.session_state["generated"].append(response)
    st.session_state["input_message_key"] = str(random.random())
    # print('input mess key', st.session_state["input_message_key"])
    st.experimental_rerun()

if st.session_state["generated"]:
    with chat_container:
        for i in range(len(st.session_state["generated"])):
            message(st.session_state["past"][i], is_user=True, key=str(i) + "_user")
            message(st.session_state["generated"][i], key=str(i))