first commit

ragchatbot.py

@@ -0,0 +1,84 @@
+import streamlit as st
+import os
+import ragfunctions
+
+
+st.title("RAG Chatbot")
+
+# Setting the LLM
+with st.expander("Setting the LLM"):
+    st.markdown("This page is used to have a chat with the uploaded documents")
+    with st.form("setting"):
+        row_1 = st.columns(3)
+        with row_1[0]:
+            token = st.text_input("Hugging Face Token", type="password")
+
+        with row_1[1]:
+            llm_model = st.text_input("LLM model", value="tiiuae/falcon-7b-instruct")
+
+        with row_1[2]:
+            instruct_embeddings = st.text_input("Instruct Embeddings", value="hkunlp/instructor-xl")
+
+        row_2 = st.columns(3)
+        with row_2[0]:
+            vector_store_list = os.listdir("vector store/")
+            default_choice = (
+                vector_store_list.index('naruto_snake')
+                if 'naruto_snake' in vector_store_list
+                else 0
+            )
+            existing_vector_store = st.selectbox("Vector Store", vector_store_list, default_choice)
+        
+        with row_2[1]:
+            temperature = st.number_input("Temperature", value=1.0, step=0.1)
+
+        with row_2[2]:
+            max_length = st.number_input("Maximum character length", value=300, step=1)
+
+        create_chatbot = st.form_submit_button("Create chatbot")
+
+
+# Prepare the LLM model
+if "conversation" not in st.session_state:
+    st.session_state.conversation = None
+
+if token:
+    st.session_state.conversation = ragfunctions.prepare_rag_llm(
+        token, llm_model, instruct_embeddings, existing_vector_store, temperature, max_length
+    )
+
+# Chat history
+if "history" not in st.session_state:
+    st.session_state.history = []
+
+# Source documents
+if "source" not in st.session_state:
+    st.session_state.source = []
+
+# Display chats
+for message in st.session_state.history:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Ask a question
+if question := st.chat_input("Ask a question"):
+    # Append user question to history
+    st.session_state.history.append({"role": "user", "content": question})
+    # Add user question
+    with st.chat_message("user"):
+        st.markdown(question)
+
+    # Answer the question
+    answer, doc_source = ragfunctions.generate_answer(question, token)
+    with st.chat_message("assistant"):
+        st.write(answer)
+    # Append assistant answer to history
+    st.session_state.history.append({"role": "assistant", "content": answer})
+
+    # Append the document sources
+    st.session_state.source.append({"question": question, "answer": answer, "document": doc_source})
+
+
+# Source documents
+with st.expander("Source documents"):
+    st.write(st.session_state.source)

ragfunctions.py

@@ -0,0 +1,130 @@
+import streamlit as st
+from langchain.document_loaders import TextLoader
+from pypdf import PdfReader
+from langchain import HuggingFaceHub
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceInstructEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferWindowMemory
+
+
+def read_pdf(file):
+    document = ""
+
+    reader = PdfReader(file)
+    for page in reader.pages:
+        document += page.extract_text()
+
+    return document
+
+class llmClass():
+    def __init__(self, token, llm_model, instruct_embeddings, existing_vector_store, temperature, max_length):
+        print('Created')
+    
+    def generate_answer(self, question, token):
+        return 'LLm not connected'
+
+
+def read_txt(file):
+    document = str(file.getvalue())
+    document = document.replace("\\n", " \\n ").replace("\\r", " \\r ")
+
+    return document
+
+
+def split_doc(document, chunk_size, chunk_overlap):
+
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap
+    )
+    split = splitter.split_text(document)
+    split = splitter.create_documents(split)
+
+    return split
+
+
+def embedding_storing(model_name, split, create_new_vs, existing_vector_store, new_vs_name):
+    if create_new_vs is not None:
+        # Load embeddings instructor
+        instructor_embeddings = HuggingFaceInstructEmbeddings(
+            model_name=model_name, model_kwargs={"device":"cuda"}
+        )
+
+        # Implement embeddings
+        db = FAISS.from_documents(split, instructor_embeddings)
+
+        if create_new_vs == True:
+            # Save db
+            db.save_local("vector store/" + new_vs_name)
+        else:
+            # Load existing db
+            load_db = FAISS.load_local(
+                "vector store/" + existing_vector_store,
+                instructor_embeddings,
+                allow_dangerous_deserialization=True
+            )
+            # Merge two DBs and save
+            load_db.merge_from(db)
+            load_db.save_local("vector store/" + new_vs_name)
+
+        st.success("The document has been saved.")
+
+
+def prepare_rag_llm(
+    token, llm_model, instruct_embeddings, vector_store_list, temperature, max_length
+):
+    # # Load embeddings instructor
+    # instructor_embeddings = HuggingFaceInstructEmbeddings(
+    #     model_name=instruct_embeddings, model_kwargs={"device":"cuda"}
+    # )
+
+    # # Load db
+    # loaded_db = FAISS.load_local(
+    #     f"vector store/{vector_store_list}", instructor_embeddings, allow_dangerous_deserialization=True
+    # )
+
+    # # Load LLM
+    # llm = HuggingFaceHub(
+    #     repo_id=llm_model,
+    #     model_kwargs={"temperature": temperature, "max_length": max_length},
+    #     huggingfacehub_api_token=token
+    # )
+
+    # memory = ConversationBufferWindowMemory(
+    #     k=2,
+    #     memory_key="chat_history",
+    #     output_key="answer",
+    #     return_messages=True,
+    # )
+
+    # # Create the chatbot
+    # qa_conversation = ConversationalRetrievalChain.from_llm(
+    #     llm=llm,
+    #     chain_type="stuff",
+    #     retriever=loaded_db.as_retriever(),
+    #     return_source_documents=True,
+    #     memory=memory,
+    # )
+
+    llm_object = llmClass(token, llm_model, instruct_embeddings, vector_store_list, temperature, max_length)
+
+    return llm_object
+
+
+def generate_answer(question, token):
+    return ["Not connected to An LLm", "No documentation available"]
+    answer = "An error has occured"
+
+    if token == "":
+        answer = "Insert the Hugging Face token"
+        doc_source = ["no source"]
+    else:
+        response = st.session_state.conversation({"question": question})
+        answer = response.get("answer").split("Helpful Answer:")[-1].strip()
+        explanation = response.get("source_documents", [])
+        doc_source = [d.page_content for d in explanation]
+
+    return answer, doc_source
+    

requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+pypdf
+langchain