updates to chainlit app - 2 vector stores

Dockerfile

@@ -8,4 +8,4 @@ COPY --chown=user . $HOME/app
 COPY ./requirements.txt ~/app/requirements.txt
 RUN pip install -r requirements.txt
 COPY . .
-CMD ["chainlit", "run", "solution_app.py", "--port", "7860"]
+CMD ["chainlit", "run", "app.py", "--port", "7860"]

app.py

@@ -2,15 +2,15 @@ import os
 import chainlit as cl
 from dotenv import load_dotenv
 from operator import itemgetter
-from langchain_huggingface import HuggingFaceEndpoint
+
 from langchain_community.document_loaders import TextLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
-from langchain_huggingface import HuggingFaceEndpointEmbeddings
 from langchain_core.prompts import PromptTemplate
 from langchain.schema.output_parser import StrOutputParser
 from langchain.schema.runnable import RunnablePassthrough
 from langchain.schema.runnable.config import RunnableConfig
+from utilities.utilities import process_documents
 
 # GLOBAL SCOPE - ENTIRE APPLICATION HAS ACCESS TO VALUES SET IN THIS SCOPE #
 # ---- ENV VARIABLES ---- # 
@@ -19,77 +19,20 @@ This function will load our environment file (.env) if it is present.
 
 NOTE: Make sure that .env is in your .gitignore file - it is by default, but please ensure it remains there.
 """
-load_dotenv()
 
-"""
-We will load our environment variables here.
-"""
-HF_LLM_ENDPOINT = os.environ["HF_LLM_ENDPOINT"]
-HF_EMBED_ENDPOINT = os.environ["HF_EMBED_ENDPOINT"]
-HF_TOKEN = os.environ["HF_TOKEN"]
-
-# ---- GLOBAL DECLARATIONS ---- #
-
-# -- RETRIEVAL -- #
-"""
-1. Load Documents from Text File
-2. Split Documents into Chunks
-3. Load HuggingFace Embeddings (remember to use the URL we set above)
-4. Index Files if they do not exist, otherwise load the vectorstore
-"""
-### 1. CREATE TEXT LOADER AND LOAD DOCUMENTS
-### NOTE: PAY ATTENTION TO THE PATH THEY ARE IN. 
-text_loader = 
-documents = 
-
-### 2. CREATE TEXT SPLITTER AND SPLIT DOCUMENTS
-text_splitter = 
-split_documents = 
-
-### 3. LOAD HUGGINGFACE EMBEDDINGS
-hf_embeddings = 
-
-if os.path.exists("./data/vectorstore"):
-    vectorstore = FAISS.load_local(
-        "./data/vectorstore", 
-        hf_embeddings, 
-        allow_dangerous_deserialization=True # this is necessary to load the vectorstore from disk as it's stored as a `.pkl` file.
-    )
-    hf_retriever = vectorstore.as_retriever()
-    print("Loaded Vectorstore")
-else:
-    print("Indexing Files")
-    os.makedirs("./data/vectorstore", exist_ok=True)
-    ### 4. INDEX FILES
-    ### NOTE: REMEMBER TO BATCH THE DOCUMENTS WITH MAXIMUM BATCH SIZE = 32
+load_dotenv()
 
-hf_retriever = vectorstore.as_retriever()
+use_document = True
+use_qdrant = False
 
-# -- AUGMENTED -- #
-"""
-1. Define a String Template
-2. Create a Prompt Template from the String Template
-"""
-### 1. DEFINE STRING TEMPLATE
-RAG_PROMPT_TEMPLATE = 
+lcel_rag_chain= None
 
-### 2. CREATE PROMPT TEMPLATE
-rag_prompt =
+if use_document:
+    lcel_rag_chain = process_documents(use_qdrant)
 
-# -- GENERATION -- #
-"""
-1. Create a HuggingFaceEndpoint for the LLM
-"""
-### 1. CREATE HUGGINGFACE ENDPOINT FOR LLM
-hf_llm = 
 
 @cl.author_rename
 def rename(original_author: str):
-    """
-    This function can be used to rename the 'author' of a message. 
-
-    In this case, we're overriding the 'Assistant' author to be 'Paul Graham Essay Bot'.
-    """
     rename_dict = {
         "Assistant" : "Paul Graham Essay Bot"
     }
@@ -97,36 +40,22 @@ def rename(original_author: str):
 
 @cl.on_chat_start
 async def start_chat():
-    """
-    This function will be called at the start of every user session. 
-
-    We will build our LCEL RAG chain here, and store it in the user session. 
-
-    The user session is a dictionary that is unique to each user session, and is stored in the memory of the server.
-    """
-
-    ### BUILD LCEL RAG CHAIN THAT ONLY RETURNS TEXT
-    lcel_rag_chain = 
-
     cl.user_session.set("lcel_rag_chain", lcel_rag_chain)
 
 @cl.on_message  
 async def main(message: cl.Message):
-    """
-    This function will be called every time a message is recieved from a session.
-
-    We will use the LCEL RAG chain to generate a response to the user query.
-
-    The LCEL RAG chain is stored in the user session, and is unique to each user session - this is why we can access it here.
-    """
     lcel_rag_chain = cl.user_session.get("lcel_rag_chain")
-
     msg = cl.Message(content="")
 
-    async for chunk in lcel_rag_chain.astream(
-        {"query": message.content},
-        config=RunnableConfig(callbacks=[cl.LangchainCallbackHandler()]),
-    ):
-        await msg.stream_token(chunk)
+    if lcel_rag_chain:
+
+        async for chunk in lcel_rag_chain.astream(
+            {"query": message.content},
+            config=RunnableConfig(callbacks=[cl.LangchainCallbackHandler()]),
+        ):
+            await msg.stream_token(chunk)
+
+        await msg.send()
+    else:
 
-    await msg.send()
+        await cl.Message(content=f"You entered: {message}").send()

chainlit.md

@@ -1 +1,11 @@
-# FILL OUT YOUR CHAINLIT MD HERE WITH A DESCRIPTION OF YOUR APPLICATION
+# AI Engineering Bootcamp Cohort 4
+
+This chatbot uses 2 opensource models:
+- LLM - NousResearch/Meta-Llama-3.1-8B-
+- Embeddings - Snowflake/snowflake-arctic-embed-m
+
+The models are housed on Hugging Face
+
+The document is from the Paul Graham Essays
+
+Please ask questions about the document

public/custom_styles.css

@@ -0,0 +1,8 @@
+.message {
+    background-color: #E3F2FD !important;  /* Light Blue background */
+    color: #1A237E !important;  /* Dark Indigo text */
+}
+
+.MuiToolbar-root {
+    background-color: #b7dcf1 !important;  /* Medium Blue background */
+}

requirements.txt

@@ -41,14 +41,14 @@ jiter==0.5.0
 joblib==1.4.2
 jsonpatch==1.33
 jsonpointer==3.0.0
-langchain==0.3.0
-langchain-community==0.3.0
-langchain-core==0.3.1
+langchain==0.3.2
+langchain-community==0.3.1
+langchain-core==0.3.8
 langchain-huggingface==0.1.0
 langchain-openai==0.2.0
 langchain-qdrant==0.1.4
 langchain-text-splitters==0.3.0
-langsmith==0.1.121
+# langsmith==0.1.121
 Lazify==0.4.0
 MarkupSafe==2.1.5
 marshmallow==3.22.0

test_chainlit.py

@@ -0,0 +1,5 @@
+import chainlit as cl
+
+@cl.on_message
+def main(message: str):
+    return cl.Message(content=f"You said: {message}")

utilities/utilities.py

@@ -0,0 +1,119 @@
+import numpy as np
+import os
+from langchain_core.prompts import PromptTemplate
+from langchain_huggingface.embeddings import HuggingFaceEndpointEmbeddings
+from langchain_community.document_loaders import TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from operator import itemgetter
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+from langchain_huggingface import HuggingFaceEndpoint
+from uuid import uuid4
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from langchain_qdrant import QdrantVectorStore
+
+from numpy.linalg import norm
+
+def get_rag_prompt():
+    rp = """\
+        <|start_header_id|>system<|end_header_id|>
+        You are a helpful assistant. You answer user questions based on provided context. If you can't answer the question with the provided context, say you don't know.<|eot_id|>
+
+        <|start_header_id|>user<|end_header_id|>
+        User Query:
+        {query}
+
+        Context:
+        {context}<|eot_id|>
+
+        <|start_header_id|>assistant<|end_header_id|>
+        """
+
+    rag_prompt = PromptTemplate.from_template(rp)
+    return rag_prompt
+
+def process_documents(use_qdrant=False):
+    HF_LLM_ENDPOINT= os.environ["HF_LLM_ENDPOINT"]
+    HF_EMBED_ENDPOINT = os.environ["HF_EMBED_ENDPOINT"]
+    HF_TOKEN = os.environ["HF_TOKEN"]
+
+    rag_prompt = get_rag_prompt()
+    document_loader = TextLoader("./data/paul_graham_essays.txt")
+    documents = document_loader.load()
+    
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=30)
+    split_documents = text_splitter.split_documents(documents)
+
+    hf_llm = HuggingFaceEndpoint(
+        endpoint_url=HF_LLM_ENDPOINT,
+        max_new_tokens=512,
+        top_k=10,
+        top_p=0.95,
+        typical_p=0.95,
+        temperature=0.01,
+        repetition_penalty=1.03,
+        huggingfacehub_api_token=HF_TOKEN
+    )
+
+    hf_embeddings = HuggingFaceEndpointEmbeddings(
+        model=HF_EMBED_ENDPOINT,
+        task="feature-extraction",
+        huggingfacehub_api_token=os.environ["HF_TOKEN"],
+    )
+    if use_qdrant:
+        collection_name = f"pdf_to_parse_{uuid4()}"
+        client = QdrantClient(":memory:")
+        client.create_collection(
+            collection_name=collection_name,
+            vectors_config=VectorParams(size=768, distance=Distance.COSINE),
+        )
+
+        vectorstore = QdrantVectorStore(
+            client=client,
+            collection_name=collection_name,
+            embedding=hf_embeddings)
+        
+        print(f"Number of batches: {len(split_documents)/32}")
+        
+        for i in range(0, len(split_documents), 32):
+            print(f"processing batch {i/32}")
+            if i == 0:
+                vectorstore.add_documents(split_documents[i:i+32])
+                continue
+            vectorstore.add_documents(split_documents[i:i+32])
+            
+        # vectorstore.add_documents(split_documents)
+        print("Loaded Vectorstore using Qdrant")
+        hf_retriever = vectorstore.as_retriever(search_type="mmr", search_kwargs={"k": 3})
+    else:
+        vectorstore_path = "./data/vectorstore"
+        if os.path.exists(vectorstore_path) and os.listdir(vectorstore_path):
+            print(f"Reading Faiss vector store from disk - {vectorstore_path}")
+            vectorstore = FAISS.load_local(
+                vectorstore_path, 
+                hf_embeddings, 
+                allow_dangerous_deserialization=True # this is necessary to load the vectorstore from disk as it's stored as a `.pkl` file.
+            )
+            hf_retriever = vectorstore.as_retriever()
+            print("Loaded Vectorstore using Faiss")
+        else:
+            print("Indexing Files")
+            os.makedirs(vectorstore_path, exist_ok=True)
+            print(f"Number of batches: {len(split_documents)/32}")
+            for i in range(0, len(split_documents), 32):
+                print(f"processing batch {i/32}")
+                if i == 0:
+                    vectorstore = FAISS.from_documents(split_documents[i:i+32], hf_embeddings)
+                    continue
+                vectorstore.add_documents(split_documents[i:i+32])
+            vectorstore.save_local(vectorstore_path)
+            print(f"Faiss vector store saved to disk - {vectorstore_path}")
+
+        hf_retriever = vectorstore.as_retriever()
+    
+    lcel_rag_chain = {"context": itemgetter("query") | hf_retriever, "query": itemgetter("query")}| rag_prompt | hf_llm
+    return lcel_rag_chain
+
+