added class

app.py

@@ -13,113 +13,88 @@ from langchain.chains import ConversationalRetrievalChain
 from huggingface_hub import hf_hub_download
 from langchain.llms import LlamaCpp
 from langchain.chains import LLMChain
-
 import time
 import streamlit as st
 
 
 
-loader = TextLoader("Data_blog.txt")
-pages = loader.load()
-
-def split_text(documents: list[Document]):
-    text_splitter = RecursiveCharacterTextSplitter(
-        chunk_size=1000,
-        chunk_overlap=150,
-        length_function=len,
-        add_start_index=True,
-    )
-    chunks = text_splitter.split_documents(documents)
-    print(f"Split {len(documents)} documents into {len(chunks)} chunks.")
-
-    document = chunks[10]
-    print(document.page_content)
-    print(document.metadata)
-
-    return chunks
-
-chunks_text = split_text(pages)
-
-embedding = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2') # machi top
-
-docs_text = [doc.page_content for doc in chunks_text]
-
-
-VectorStore = FAISS.from_texts(docs_text, embedding=embedding)
-
-MODEL_ID = "TheBloke/Mistral-7B-OpenOrca-GGUF"
-MODEL_BASENAME = "mistral-7b-openorca.Q4_K_M.gguf"
+class MyBot:
+    def __init__(self, text_file, model_id, model_basename):
+        self.text_file = text_file
+        self.model_id = model_id
+        self.model_basename = model_basename
+        self.loader = TextLoader(self.text_file)
+        self.pages = self.loader.load()
+        self.chunks_text = self.split_text(self.pages)
+        self.docs_text = [doc.page_content for doc in self.chunks_text]
+        self.embedding = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+        self.VectorStore = FAISS.from_texts(self.docs_text, embedding=self.embedding)
+        self.model_path = self.download_model(self.model_id, self.model_basename)
+        self.callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
+        self.llm = self.init_llm(self.model_path, self.callback_manager)
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True,
+            input_key='question',
+            output_key='answer'
+        )
+        self.qa = self.init_qa(self.llm, self.VectorStore, self.memory)
+
+    def split_text(self, documents):
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=150,
+            length_function=len,
+            add_start_index=True,
+        )
+        chunks = text_splitter.split_documents(documents)
+        return chunks
 
-model_path = hf_hub_download(
-            repo_id=MODEL_ID,
-            filename=MODEL_BASENAME,
+    def download_model(self, model_id, model_basename):
+        model_path = hf_hub_download(
+            repo_id=model_id,
+            filename=model_basename,
             resume_download=True,
         )
+        print("model_path : ", model_path)
+        return model_path
+
+    def init_llm(self, model_path, callback_manager):
+        CONTEXT_WINDOW_SIZE = 1500
+        MAX_NEW_TOKENS = 2000
+        N_BATCH = 512
+        n_gpu_layers = 40
+        kwargs = {
+            "model_path": model_path,
+            "n_ctx": CONTEXT_WINDOW_SIZE,
+            "max_tokens": MAX_NEW_TOKENS,
+            "n_batch": N_BATCH,
+            "n_gpu_layers": n_gpu_layers,
+            "callback_manager": callback_manager,
+            "verbose":True,
+        }
+        llm = LlamaCpp(**kwargs)
+        return llm
+
+    def init_qa(self, llm, VectorStore, memory):
+        qa = ConversationalRetrievalChain.from_llm(
+            llm,
+            chain_type="stuff",
+            retriever=VectorStore.as_retriever(search_kwargs={"k": 5}),
+            memory=memory,
+            return_source_documents=True,
+            verbose=False,
+        )
+        return qa
 
-print("model_path : ", model_path)
-
-callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
-
-CONTEXT_WINDOW_SIZE = 1500
-MAX_NEW_TOKENS = 2000
-N_BATCH = 512
-n_gpu_layers = 40
-kwargs = {
-          "model_path": model_path,
-          "n_ctx": CONTEXT_WINDOW_SIZE,
-          "max_tokens": MAX_NEW_TOKENS,
-          "n_batch": N_BATCH,
-          "n_gpu_layers": n_gpu_layers,
-          "callback_manager": callback_manager,
-          "verbose":True,
-      }
-
-
-# Callbacks support token-wise streaming
-callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
-
-n_gpu_layers = 40  # Change this value based on your model and your GPU VRAM pool.
-n_batch = 512  # Should be between 1 and n_ctx, consider the amount of VRAM in your GPU.
-max_tokens = 2000
-# Make sure the model path is correct for your system!
-llm = LlamaCpp(
-    model_path=model_path,
-    n_gpu_layers=n_gpu_layers,
-
-    n_batch=n_batch,
-    max_tokens= max_tokens,
-    callback_manager=callback_manager,
-    verbose=True,  # Verbose is required to pass to the callback manager
-)
-
-llm = LlamaCpp(**kwargs)
-
-memory = ConversationBufferMemory(
-    memory_key="chat_history",
-    return_messages=True,
-    input_key='question',
-    output_key='answer'
-)
-
-# memory.clear()
-
-qa = ConversationalRetrievalChain.from_llm(
-    llm,
-    chain_type="stuff",
-    retriever=VectorStore.as_retriever(search_kwargs={"k": 5}),
-    memory=memory,
-    return_source_documents=True,
-    verbose=False,
-)
-def translate(text, source="English", target="Moroccan Arabic"):
-    client = Client("https://facebook-seamless-m4t-v2-large.hf.space/--replicas/2bmbx/")
-    result = client.predict(
+    def translate(self, text, source="English", target="Moroccan Arabic"):
+        client = Client("https://facebook-seamless-m4t-v2-large.hf.space/--replicas/2bmbx/")
+        result = client.predict(
         text,
         source,
         target,
         api_name="/t2tt"
-    )
-    return result
+        )
 
 #---------------------------------------------------------
 
@@ -149,31 +124,25 @@ for message in st.session_state.messages:
       with st.chat_message(message["role"], avatar="logo.png"):
           st.write(message["content"])
 
+# Create an instance of LangChain
+lc = LangChain("Data_blog.txt", "TheBloke/Mistral-7B-OpenOrca-GGUF", "mistral-7b-openorca.Q4_K_M.gguf")
+
+# Use the instance methods in your Streamlit application
 def clear_chat_history():
-    memory.clear()
-    qa = ConversationalRetrievalChain.from_llm(
-        llm,
-        chain_type="stuff",
-        retriever=VectorStore.as_retriever(search_kwargs={"k": 5}),
-        memory=memory,
-        return_source_documents=True,
-        verbose=False,
-    )
+    lc.memory.clear()
+    lc.qa = lc.init_qa(lc.llm, lc.VectorStore, lc.memory)
     st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]
 
-st.sidebar.button('Clear Chat History', on_click=clear_chat_history)
-selected_language = st.sidebar.selectbox("Select Language", ["English", "Darija"], index=0)  # English is the default
-
-# Function for generating LLaMA2 response
 def generate_llm_response(prompt_input):
-    res = qa(f'''{prompt_input}''')
+    res = lc.qa(f'''{prompt_input}''')
 
     if selected_language == "Darija":
-        translated_response = translate(res['answer'])
+        translated_response = lc.translate(res['answer'])
         return translated_response
     else:
         return res['answer']
 
+
 # User-provided prompt
 if prompt := st.chat_input("What is up?"):
     if selected_language == "Darija":