initial commit

app.py

@@ -0,0 +1,99 @@
+import streamlit as st
+from streamlit_lottie import st_lottie
+import fitz  # PyMuPDF
+import requests
+import os, shutil
+import sidebar
+import llm_model
+
+@st.cache_data(experimental_allow_widgets=True)
+def index_document(uploaded_file):
+
+    if uploaded_file is not None:
+        # Specify the folder path where you want to store the uploaded file in the 'assets' folder
+        assets_folder = "assets/uploaded_files"
+        if not os.path.exists(assets_folder):
+            os.makedirs(assets_folder)
+
+        # Save the uploaded file to the specified folder
+        file_path = os.path.join(assets_folder, uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getvalue())
+
+        file_name = os.path.join(assets_folder, uploaded_file.name)
+        st.success(f"File '{file_name}' uploaded !")
+
+        with st.spinner("Indexing document... This is a free CPU version and may take a while⏳"):
+            llm_model.create_vector_db(file_name, instructor_embeddings)
+
+        return file_name
+    else:
+        return None
+
+
+def load_lottieurl(url: str):
+    r = requests.get(url)
+    if r.status_code != 200:
+        return None
+    return r.json()
+
+
+def is_query_valid(query: str) -> bool:
+    if not query:
+        st.error("Please enter a question!")
+        return False
+    return True
+
+
+# Function to load model parameters
+@st.cache_resource()
+def load_model():
+    return llm_model.load_model_params()
+
+st.set_page_config(page_title="Document QA Bot")
+lottie_book = load_lottieurl("https://assets4.lottiefiles.com/temp/lf20_aKAfIn.json")
+st_lottie(lottie_book, speed=1, height=200, key="initial")
+# Place the title below the Lottie animation
+st.title("PDF Q&A Bot 🤖")
+
+# Left Sidebar
+sidebar.sidebar()
+# st.sidebar.header("Upload PDF")
+
+# load model parameters
+llm, instructor_embeddings = load_model()
+# Upload file through Streamlit
+uploaded_file = st.file_uploader("Upload a file", type=["pdf", "doc", "docx", "txt"])
+
+filename = index_document(uploaded_file)
+print(filename)
+
+if not filename:
+    st.stop()
+
+
+with st.form(key="qa_form"):
+    query = st.text_area("Ask a question about the document")
+    submit = st.form_submit_button("Submit")
+
+if submit:
+    if not is_query_valid(query):
+        st.stop()
+
+    # Output Columns
+    answer_col, sources_col = st.columns(2)
+
+    qa_chain = llm_model.document_parser(instructor_embeddings, llm)
+    result = qa_chain(query)
+
+    with answer_col:
+        st.markdown("#### Answer")
+        st.markdown(result["result"])
+
+    with sources_col:
+        st.markdown("#### Sources")
+        if not ("i don't know" in result["result"].lower()):
+            for source in result["source_documents"]:
+                st.markdown(source.page_content)
+                st.markdown(source.metadata["source"])
+                st.markdown("--------------------------")

llm_model.py

@@ -0,0 +1,92 @@
+from langchain.vectorstores import FAISS
+from langchain.llms import GooglePalm
+from langchain.document_loaders import PyPDFLoader
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import Docx2txtLoader
+from langchain.embeddings import HuggingFaceInstructEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain.chains import RetrievalQA
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import os
+from dotenv import load_dotenv
+
+vector_index_path = "assets/vectordb/faiss_index"
+
+
+def load_env_variables():
+    load_dotenv()  # take environment variables from .env
+
+
+def create_vector_db(filename, instructor_embeddings):
+
+    if filename.endswith(".pdf"):    
+        loader = PyPDFLoader(file_path=filename)
+    elif filename.endswith(".doc") or filename.endswith(".docx"):
+        loader = Docx2txtLoader(filename)
+    elif filename.endswith("txt") or filename.endswith("TXT"):
+        loader = TextLoader(filename)
+
+    # Split documents
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=10)
+    splits = text_splitter.split_documents(loader.load())
+
+    # data = loader.load()
+
+    # Create a FAISS instance for vector database from 'data'
+    vectordb = FAISS.from_documents(documents=splits,
+                                    embedding=instructor_embeddings)
+
+    # Save vector database locally
+    vectordb.save_local(vector_index_path)
+
+
+def get_qa_chain(instructor_embeddings, llm):
+
+    # Load the vector database from the local folder
+    vectordb = FAISS.load_local(vector_index_path, instructor_embeddings)
+
+    # Create a retriever for querying the vector database
+    retriever = vectordb.as_retriever(search_type="similarity")
+
+    prompt_template = """
+    You are a question answer agent and you must strictly follow below prompt template.
+    Given the following context and a question, generate an answer based on this context only.
+    In the answer try to provide as much text as possible from "response" section in the source document context without making much changes.
+    Keep answers brief and well-structured. Do not give one word answers.
+    If the answer is not found in the context, kindly state "I don't know." Don't try to make up an answer.
+
+    CONTEXT: {context}
+
+    QUESTION: {question}"""
+
+    PROMPT = PromptTemplate(
+        template=prompt_template, input_variables=["context", "question"]
+    )
+
+    chain = RetrievalQA.from_chain_type(llm=llm,
+                                        chain_type="stuff",  # or map-reduce
+                                        retriever=retriever,
+                                        input_key="query",
+                                        return_source_documents=True,  # return source document from the vector db
+                                        chain_type_kwargs={"prompt": PROMPT},
+                                        verbose=True)
+
+    return chain
+
+
+def load_model_params():
+
+    load_env_variables()
+    # Create Google Palm LLM model
+    llm = GooglePalm(google_api_key=os.environ["GOOGLE_API_KEY"], temperature=0.1)
+    # # Initialize instructor embeddings using the Hugging Face model
+    instructor_embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-large")
+
+    return llm, instructor_embeddings
+
+
+def document_parser(instructor_embeddings, llm):
+
+    chain = get_qa_chain(instructor_embeddings=instructor_embeddings, llm=llm)
+
+    return chain

requirements.txt

@@ -0,0 +1,13 @@
+langchain==0.0.284
+python-dotenv==1.0.0
+tiktoken==0.4.0
+faiss-cpu==1.7.4
+protobuf~=3.19.0
+pypdf
+google-generativeai
+InstructorEmbedding
+sentence-transformers
+streamlit
+frontend
+tools
+docx2txt

sidebar.py

@@ -0,0 +1,60 @@
+import streamlit as st
+from streamlit_lottie import st_lottie
+
+
+def faq():
+    st.markdown(
+        """
+# FAQ
+## How does Document Q&A Bot work?
+When you upload a document (in Pdf, word, csv or txt format), it will be divided into smaller chunks 
+and stored in a special type of database called a vector index 
+that allows for semantic search and retrieval.
+
+When you ask a question, our Q&A bot will first look through the document chunks and find the
+most relevant ones using the vector index. Then, it will use open-source LLM model named Google Palm
+and will provide the final answer.
+
+## Is my data safe?
+Yes, your data is safe. Our bot does not store your documents or
+questions. All uploaded data is deleted after you close the browser tab.
+
+## Why does it take so long to index my document?
+Since, this is a sample QA bot project that uses open-source model
+and doesn't have much resource capabilities like GPU, it may take time 
+to index your document based on the size of the document.
+
+## Are the answers 100% accurate?
+No, the answers are not 100% accurate. 
+But for most use cases, our QA bot is very accurate and can answer
+most questions. Always check with the sources to make sure that the answers
+are correct.
+"""
+    )
+
+
+def sidebar():
+    with st.sidebar:
+        st.markdown("## Google Palm")
+        
+        st.success('API key already provided!', icon='✅')
+        
+        st.markdown(
+            "## How to use QA bot\n"
+            "1. Upload a pdf, docx, or a txt file📄\n"
+            "2. Ask questions about the document💬\n"
+        )
+
+        # st.session_state["OPENAI_API_KEY"] = api_key_input
+
+        st.markdown("---")
+        st.markdown("# About")
+        st.markdown(
+            "🤖 QA bot allows you to ask questions about your "
+            "documents and get accurate answers with citations. "
+        )
+
+        st.markdown("Created by [Krishna Kumar](https://www.linkedin.com/in/krishna-kumar-yadav-726831105/)")
+        st.markdown("---")
+
+        faq()