Upload 3 files

Added the app files

app.py

@@ -0,0 +1,94 @@
+import langchain
+import streamlit as st
+from streamlit_chat import message
+from utils import *
+
+from PyPDF2 import PdfReader
+from dotenv import load_dotenv
+
+import os
+import google.generativeai as genai
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.chains.question_answering import load_qa_chain
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains.conversation.memory import ConversationBufferWindowMemory
+from langchain.chains import ConversationChain
+from langchain.chains import ConversationalRetrievalChain
+from langchain.prompts import ChatPromptTemplate
+from langchain.prompts import (
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+    ChatPromptTemplate,
+    MessagesPlaceholder
+)
+
+with st.sidebar:
+    st.title("Menu:")
+    pdf_docs = st.file_uploader("Upload your PDF Files and Click on the Submit & Process Button", accept_multiple_files=True)
+    if st.button("Submit & Process"):
+        with st.spinner("Processing..."):
+            raw_text = get_pdf_text(pdf_docs)
+            text_chunks = get_text_chunks(raw_text)
+            get_vector_store(text_chunks)
+            st.success("Done")
+st.subheader("Conversation Chatbot with Langchain, Gemini Pro LLM, Pinecone and Streamlit")
+
+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'] = []
+    
+
+load_dotenv()
+genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+llm = ChatGoogleGenerativeAI(model="gemini-pro",temperature=0,convert_system_message_to_human=True)
+from langchain import HuggingFaceHub
+
+
+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(memory=st.session_state.buffer_memory, prompt=prompt_template, llm=llm, verbose=True)
+
+
+
+
+# container for chat history
+response_container = st.container()
+# container for text box
+textcontainer = st.container()
+
+
+with textcontainer:
+    query = st.text_input("Query: ", key="input")
+    if query:
+        with st.spinner("typing..."):
+            conversation_string = get_conversation_string()
+            # st.code(conversation_string)
+            refined_query = query_refiner(conversation_string, query)
+            st.subheader("Refined Query:")
+            st.write(refined_query)
+            context = find_match(refined_query)
+            # print(context)  
+            response = conversation.predict(input=f"Context:\n {context} \n\n Query:\n{query}")
+        st.session_state.requests.append(query)
+        st.session_state.responses.append(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')
+

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+streamlit_chat
+google-generativeai
+python-dotenv
+langchain
+PyPDF2
+langchain_google_genai
+sentence-transformers==2.2.2
+pinecone-client==2.2.4
+unstructured
+unstructured[local-inference]
+tiktoken

utils.py

@@ -0,0 +1,99 @@
+from sentence_transformers import SentenceTransformer
+import pinecone
+import google.generativeai as genai
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from PyPDF2 import PdfReader
+
+# Parsing the uploaded documents and creating a single text blob
+def get_pdf_text(pdf_docs):
+    text=""
+    for pdf in pdf_docs:
+        pdf_reader= PdfReader(pdf)
+        for page in pdf_reader.pages:
+            text+= page.extract_text()
+    return  text
+
+# creating chunks of the text blob
+def get_text_chunks(text):
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+from langchain.embeddings import HuggingFaceEmbeddings
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Load environment variables to get Pinecone API Key and env
+load_dotenv()
+# Access the value of PINECONE_API_KEY
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+PINECONE_API_ENV = os.getenv("PINECONE_API_ENV")
+
+# initialize pinecone
+import pinecone
+# initialize pinecone
+pinecone.init(
+    api_key=PINECONE_API_KEY,  # find at app.pinecone.io
+    environment=PINECONE_API_ENV  # next to api key in console
+)
+index_name = "rag-chatbot" # put in the name of your pinecone index here
+
+
+#  Function that indexes documents into Pinecone
+from langchain.vectorstores import Pinecone
+
+# Load the data into pinecone database
+def get_vector_store(text_chunks):
+   #docsearch = Pinecone.from_texts(chunked_data, embeddings, index_name=index_name)
+   index = Pinecone.from_texts([t for t in text_chunks], embeddings, index_name=index_name)
+   return index
+
+index = pinecone.Index('langchain-chatbot')
+
+encoder = SentenceTransformer('all-MiniLM-L6-v2')
+
+
+
+
+def find_match(input):
+    # input_em = encoder.encode(input).tolist()
+    # result = index.query(input_em, top_k=2, includeMetadata=True)
+    # return result['matches'][0]['metadata']['text']+"\n"+result['matches'][1]['metadata']['text']
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+    # Pinecone search using the loaded embeddings
+    docsearch = Pinecone.from_existing_index(index_name, embeddings)
+    docs = docsearch.similarity_search(input)
+    return docs
+
+# def query_refiner(conversation, query):
+
+#     response = openai.Completion.create(
+#     model="text-davinci-003",
+#     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:",
+#     temperature=0.7,
+#     max_tokens=256,
+#     top_p=1,
+#     frequency_penalty=0,
+#     presence_penalty=0
+#     )
+#     return response['choices'][0]['text']
+
+genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+model = genai.GenerativeModel('gemini-pro')
+
+def query_refiner(conversation, query):
+    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:"
+    response = model.generate_content(prompt)
+    return response.text
+
+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