Upload app.py

app.py

@@ -0,0 +1,291 @@
+import subprocess
+
+import streamlit as st
+from dotenv import load_dotenv
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores import FAISS
+from langchain.embeddings import FastEmbedEmbeddings  # General embeddings from HuggingFace models.
+from langchain.memory import ConversationBufferMemory
+from langchain.callbacks.manager import CallbackManager
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+from htmlTemplates import css, bot_template, user_template
+from langchain.llms import LlamaCpp  # For loading transformer models.
+from langchain.document_loaders import PyPDFLoader, TextLoader, CSVLoader
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from langchain import hub
+import os
+import glob
+import shutil
+
+os.environ['FAISS_NO_AVX2'] = '1'
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+def load_document_text():
+    """
+    input : path to the document
+    output: list of loaded document
+    """
+
+    documents = []
+
+    for dox in os.listdir(path= "./documents/"):
+        dir = os.path.join("./documents/", dox)
+
+        if dox.endswith(".pdf"):
+            documents.extend( PyPDFLoader(dir).load() )
+
+        elif dox.endswith(".txt"):
+            documents.extend( TextLoader(dir).load() )
+
+        elif dox.endswith(".csv"):
+            documents.extend( CSVLoader(dir).load() )
+
+    return documents
+
+def get_text_chunks(documents):
+    """
+    For the compute purpose we will split the document into multiple smaller chunks. 
+
+    IMPORTANT :  If the chunks too small we will miss the context and if its too large we will have longer compute time 
+    """
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1024,  
+        chunk_overlap=100,  
+    )
+
+    st.session_state.text_chunks = text_splitter.split_documents(documents)  
+
+
+def get_vectorstore():
+    """
+    given the chunks, we will embed them into vector stores 
+    """
+
+    if len(glob.glob("./vectordb/*.faiss")) == 0:
+        st.session_state.vectorstore = FAISS.from_documents(documents= st.session_state.text_chunks, 
+                                            embedding= st.session_state.embeddings)
+        # save the file 
+        st.session_state.vectorstore.save_local("./vectordb")
+    else:
+        st.session_state.vectorstore = FAISS.load_local("./vectordb/", 
+                                                        st.session_state.embeddings)
+
+
+def get_conversation_chain():
+    """
+    This is a langchain model where we will be binding the runner to infer data from LLM
+    """
+    model_path = st.session_state.model
+    callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
+
+    llm = LlamaCpp(model_path= model_path, 
+                   n_ctx=4000, 
+                   max_tokens= 4000,
+                   fp = 50, 
+                   n_batch = 512,
+                   callback_manager = callback_manager,
+                   verbose=True)
+    
+    memory = ConversationBufferMemory(
+        memory_key='chat_history', return_messages=False)
+
+
+    prompt_template = """You are a personal HR Bot assistant for answering any questions about Companies policies
+    You are given a question and a set of documents.
+    If the user's question requires you to provide specific information from the documents, give your answer based only on the examples provided below. DON'T generate an answer that is NOT written in the provided examples.
+    If you don't find the answer to the user's question with the examples provided to you below, answer that you didn't find the answer in the documentation and propose him to rephrase his query with more details.
+    Use bullet points if you have to make a list, only if necessary.
+
+    QUESTION: {question}
+
+    DOCUMENTS:
+    =========
+    {context}
+    =========
+    Finish by proposing your help for anything else.
+    """
+
+    rag_prompt_custom = PromptTemplate.from_template(prompt_template)
+
+    prompt = hub.pull("rlm/rag-prompt")
+    
+    conversation_chain = RetrievalQA.from_chain_type(
+        llm,
+        retriever= st.session_state.vectorstore.as_retriever(),
+        chain_type_kwargs={"prompt": prompt},
+    )
+    conversation_chain.callback_manager = callback_manager
+    conversation_chain.memory = ConversationBufferMemory()
+
+    return conversation_chain
+
+
+def handle_userinput():
+
+    clear = False
+
+    # Add clear chat button
+    if st.button("Clear Chat history"):
+        clear = True
+        st.session_state.messages = []
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = [{"role": "assistant", "content": "How can I help you?"}]
+
+    for msg in st.session_state.messages:
+        st.chat_message(msg["role"]).write(msg["content"])
+
+    if prompt := st.chat_input():
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        st.chat_message("user").write(prompt)
+        if clear:
+            st.session_state.conversation.clean()
+
+        msg = st.session_state.conversation.run(prompt)
+        print(msg)
+        st.session_state.messages.append({"role": "assistant", "content": msg})
+        st.chat_message("assistant").write(msg)
+
+        
+
+# Function to apply rounded edges using CSS
+def add_rounded_edges(image_path="./randstad_featuredimage.png", radius=30):
+    st.markdown(
+        f'<style>.rounded-img{{border-radius: {radius}px; overflow: hidden;}}</style>',
+        unsafe_allow_html=True,)
+    st.image(image_path, use_column_width=True, output_format='auto')
+
+
+# Delete our vector DB 
+def delete_db(directory_path = './vectordb/'):
+    
+    # Check if the directory exists
+    if os.path.exists(directory_path) and len(os.listdir(directory_path)) > 0:
+        # Iterate over all files in the directory and remove them
+        for filename in os.listdir(directory_path):
+            file_path = os.path.join(directory_path, filename)
+            try:
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            except Exception as e:
+                print(f"Error deleting {file_path}: {e}")
+    else:
+        print(f"The directory {directory_path} does not exist.")
+
+
+
+def save_uploaded_file(uploaded_file):
+    save_directory = "./documents/"
+    file_path = os.path.join(save_directory, uploaded_file.name)
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getvalue())
+    return file_path
+
+
+def load_dependencies():
+    # append documents to a list
+    doc_list = load_document_text()
+
+    # get the text chunks
+    get_text_chunks(doc_list)
+
+    # create vector store
+    get_vectorstore()
+
+    # create conversation chain
+    st.session_state.conversation = get_conversation_chain()
+
+
+def main():
+    load_dotenv()
+    st.set_page_config(page_title="Chat with multiple Files",
+                       page_icon=":books:")
+    st.write(css, unsafe_allow_html=True)
+
+
+    if "conversation" not in st.session_state:
+        st.session_state.conversation = None
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = None
+
+    st.title("💬 Randstad HR Chatbot")
+    st.subheader("🚀 A HR powered by Generative AI")
+
+    # default model 
+    st.session_state.model = "./models/mistral-7b-instruct-v0.2.Q5_K_M.gguf"
+
+
+    # Embedding Model
+    st.session_state.embeddings = FastEmbedEmbeddings( model_name= "BAAI/bge-small-en-v1.5", 
+                                                                    cache_dir="./embedding_model/")
+
+    with st.sidebar:
+
+        # calling a 
+        add_rounded_edges()
+
+        st.subheader("Select Your Embedding Model Model")
+        st.session_state.model = st.selectbox( 'Models', tuple( glob.glob('./models/*.gguf') ) )
+
+
+        st.subheader("Your documents")
+
+        # Space to Upload a Document
+        docs = st.file_uploader(
+            "Upload File (pdf,text,csv...) and click 'Process'", accept_multiple_files=True)
+
+        # Define a process button
+        if st.button("Process"):
+
+            # delete the old embeddings 
+            delete_db()
+
+            # then Embedd new documents
+            with st.spinner("Processing"):
+                
+
+                # iterate over updated files and save them to the local directory (i.e. "Documents") using a helper function
+                for file in docs:
+                    save_uploaded_file(file)
+                
+                """
+                using the helper function below lets load our dependencies
+                Step 1 : Load the documents 
+                Step 2 : Break them into Chunks
+                Step 3 : Create Embeddings and save them to Vector DB 
+                Step 4 : Get our conversation chain 
+                """
+                load_dependencies()
+
+    # Load our model 
+    if len(glob.glob("./vectordb/*.faiss")) == 0:
+        load_dependencies()
+        get_vectorstore()
+    else:
+        get_vectorstore()
+        st.session_state.conversation = get_conversation_chain()
+
+    handle_userinput()
+    
+    # # load dependencies -> chaunks of documents ->  Embeddings -> Inference 
+    # load_dependencies()
+
+
+
+if __name__ == '__main__':
+
+    command = 'CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip install llama-cpp-python --no-cache-dir'
+    
+    # Run the command using subprocess
+    try:
+        subprocess.run(command, shell=True, check=True)
+        print("Command executed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error: {e}")
+    
+    # Run the apps
+    main()