working mem

.gitattributes

@@ -17,6 +17,7 @@
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
 *.pickle filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,8 @@
+wandb/
+.env
+__pycache__/data/qdrant/*
+*.sqlite
+__pycache__/*
+data/.lock
+data/qdrant
+__pycache__

.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "chainlit",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "chainlit",
+            "args": [
+                "run",
+                "/Users/pmui/SynologyDrive/projects/llmops/aie2/homework/midterm/meta-analysis/app.py",
+                "-w"
+            ],
+            "jinja": true
+        }
+    ]
+}

app.py

@@ -1,17 +1,76 @@
 import chainlit as cl
+import logging
+import sys
 
-@cl.on_chat_start
-async def start():
-    await cl.Message(
-        content=f"Hello",
-    ).send()
+_logger = logging.getLogger("lang-chat")
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.vectorstores import VectorStore
+from langchain_core.runnables.base import RunnableSequence
 
+from globals import (
+    DEFAULT_QUESTION1,
+    DEFAULT_QUESTION2,
+    gpt35_model,
+    gpt4_model
+)
+
+from semantic import (
+    SemanticRAGChainFactory
+)
+
+_semantic_rag_chain: RunnableSequence = None
 
 @cl.on_message
 async def main(message: cl.Message):
+    
+    content = ""
+    try:
+        response = _semantic_rag_chain.invoke({"question": message.content})
+        content += response["response"].content
+    except Exception as e:
+        print(f"chat error: {e}: {vars(_semantic_rag_chain)}")
 
-    content = message.content
-
+    # Send a response back to the user
     await cl.Message(
         content=f"{content}",
-    ).send()
+    ).send()
+
+@cl.on_chat_start
+async def start():
+
+    print("==> starting ...")
+    global _semantic_rag_chain
+    _semantic_rag_chain = SemanticRAGChainFactory.get_semantic_rag_chain()
+
+    # await cl.Avatar(
+    #     name="Chatbot",
+    #     url="https://cdn-icons-png.flaticon.com/512/8649/8649595.png"
+    # ).send()
+    # await cl.Avatar(
+    #     name="User",
+    #     url="https://media.architecturaldigest.com/photos/5f241de2c850b2a36b415024/master/w_1600%2Cc_limit/Luke-logo.png"
+    # ).send()
+
+    print("\tsending message back: ready!!!")
+
+    content = ""
+    # if _semantic_rag_chain is not None:
+    #     try:
+    #         response1 = _semantic_rag_chain.invoke({"question": DEFAULT_QUESTION1})    
+    #         response2 = _semantic_rag_chain.invoke({"question": DEFAULT_QUESTION2})    
+
+    #         content = (
+    #             f"**Question**: {DEFAULT_QUESTION1}\n\n"
+    #             f"{response1['response'].content}\n\n"
+    #             f"**Question**: {DEFAULT_QUESTION2}\n\n"
+    #             f"{response2['response'].content}\n\n"
+    #         )
+    #     except Exception as e:
+    #         _logger.error(f"init error: {e}")
+    
+    cl.user_session.set("message_history", [{"role": "system", "content": "You are a helpful assistant. "}])
+    await cl.Message(
+        content=content + "\nHow can I help you with Meta's 2023 10K?"
+    ).send()
+    print(f"{20 * '*'}")

data/meta-10k-2023.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8fadc2448e4f99ad0ec2dc2e41d13b864204955238cf1f7cd9c96839f274a6c
+size 2481466

data/meta-1pager.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d6a1929035e18d38e69392a5b36e366efd8dba736fab2dcaae464326212083e
+size 96532

globals.py

@@ -0,0 +1,22 @@
+from dotenv import find_dotenv, load_dotenv
+load_dotenv(find_dotenv())
+
+from langchain_openai import ChatOpenAI
+from langchain_openai import OpenAIEmbeddings
+
+GPT4_MODEL_NAME = "gpt-4-turbo-2024-04-09"
+GPT35_MODEL_NAME = "gpt-3.5-turbo-1106"
+
+gpt35_model = ChatOpenAI(model=GPT35_MODEL_NAME, temperature=0.0)
+gpt4_model  = ChatOpenAI(model=GPT4_MODEL_NAME, temperature=0.0)
+embeddings  = OpenAIEmbeddings(model="text-embedding-3-small")
+
+DEFAULT_QUESTION1 = "What was the total value of 'Cash and cash equivalents' as of December 31, 2023?"
+DEFAULT_QUESTION2 = "Who are 'Directors' (i.e., members of the Board of Directors) for Meta?"
+
+ROOT_PATH = "."
+VECTOR_STORE_PATH = f"{ROOT_PATH}/data/qdrant"
+# META_10K_FILE_PATH = f"{ROOT_PATH}/data/meta-10k-2023.pdf"
+META_10K_FILE_PATH = f"{ROOT_PATH}/data/meta-1pager.pdf"
+META_SEMANTIC_COLLECTION = "meta10k-semantic"
+

semantic.py

@@ -0,0 +1,174 @@
+import logging
+from pathlib import Path
+
+_logger = logging.getLogger("semantic")
+
+from operator import itemgetter
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables.base import RunnableSequence
+from langchain_core.vectorstores import VectorStore
+from langchain.retrievers.multi_query import MultiQueryRetriever
+from langchain_community.vectorstores import Qdrant
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain_experimental.text_splitter import SemanticChunker
+
+from globals import (
+    embeddings,
+    gpt35_model,
+    gpt4_model,
+    META_10K_FILE_PATH,
+    META_SEMANTIC_COLLECTION,
+    VECTOR_STORE_PATH
+)
+
+
+USE_MEMORY = True
+from qdrant_client import QdrantClient
+
+qclient: QdrantClient
+if USE_MEMORY == True:
+    qclient = QdrantClient(":memory:")
+else:
+    qclient = QdrantClient(path=VECTOR_STORE_PATH)
+
+
+RAG_PROMPT = """
+Reply the user's query thoughtfully and clearly.
+You should only respond to user's query if the context is related to the query.  
+If you are not sure how to answer, please reply "I don't know".
+Respond with structure in markdown.
+
+CONTEXT:
+{context}
+
+QUERY:
+{question}
+
+YOUR REPLY: """
+
+rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT)
+
+
+class SemanticStoreFactory:
+    _semantic_vectorstore: VectorStore = None
+
+    @classmethod
+    def __load_semantic_store(
+        cls
+    ) -> VectorStore:
+        path = Path(VECTOR_STORE_PATH)
+        store = None
+        # check if path exists and if it is not empty
+        if path.exists() and path.is_dir() and any(path.iterdir()):
+            _logger.info(f"\tQdrant loading ...")
+            store = Qdrant(
+                client=qclient, 
+                embeddings=embeddings, 
+                collection_name=META_SEMANTIC_COLLECTION,
+            )
+        else:
+            _logger.info(f"\tQdrant creating ...")
+            store = cls.__create_semantic_store()
+        return store
+
+    @classmethod
+    def __create_semantic_store(
+        cls
+    ) -> VectorStore:
+        
+        if USE_MEMORY == True:
+            _logger.info(f"creating semantic vector store: {USE_MEMORY}")
+        else:
+            _logger.info(f"creating semantic vector store: {VECTOR_STORE_PATH}")
+            path = Path(VECTOR_STORE_PATH)
+            if not path.exists():
+                path.mkdir(parents=True, exist_ok=True)
+                _logger.info(f"Directory '{path}' created.")
+
+        documents = PyMuPDFLoader(META_10K_FILE_PATH).load()
+        semantic_chunker = SemanticChunker(
+            embeddings=embeddings,
+            breakpoint_threshold_type="percentile"
+        ) 
+        semantic_chunks = semantic_chunker.create_documents(
+            [d.page_content for d in documents]
+        )
+        _logger.info(f"created semantic_chunks: {len(semantic_chunks)}")
+        if USE_MEMORY == True:
+            _logger.info(f"\t==> creating memory vectorstore ...")
+            semantic_chunk_vectorstore = Qdrant.from_documents(
+                semantic_chunks,
+                embeddings,
+                location=":memory:",
+                collection_name=META_SEMANTIC_COLLECTION,
+                force_recreate=True
+            )
+            _logger.info(f"\t==> finished constructing vectorstore")
+        else:
+            semantic_chunk_vectorstore = Qdrant.from_documents(
+                semantic_chunks,
+                embeddings,
+                path=VECTOR_STORE_PATH,
+                collection_name=META_SEMANTIC_COLLECTION,
+                force_recreate=True
+            )
+        _logger.info(f"\t==> return vectorstore {META_SEMANTIC_COLLECTION}")
+
+        return semantic_chunk_vectorstore
+
+    @classmethod
+    def get_semantic_store(
+        cls
+    ) -> VectorStore:
+        _logger.info(f"get_semantic_store")
+        if cls._semantic_vectorstore is None:
+            if USE_MEMORY == True:
+                cls._semantic_vectorstore = cls.__create_semantic_store()
+                _logger.info(f"received semantic_vectorstore")
+            else:
+                print(f"Loading semantic vectorstore {META_SEMANTIC_COLLECTION} from: {VECTOR_STORE_PATH}")
+                try:
+                    # first try to load the store
+                    cls._semantic_vectorstore = cls.__load_semantic_store()
+                except Exception as e:
+                    _logger.warning(f"cannot load: {e}")
+                    cls._semantic_vectorstore = cls.__create_semantic_store()
+
+        _logger.info(f"RETURNING get_semantic_store")
+        return cls._semantic_vectorstore 
+
+class SemanticRAGChainFactory:
+    _chain: RunnableSequence = None
+
+    @classmethod
+    def get_semantic_rag_chain(
+        cls
+    ) -> RunnableSequence:
+        if cls._chain is None:
+            _logger.info(f"creating SemanticRAGChainFactory")
+            semantic_store = SemanticStoreFactory.get_semantic_store()
+            if semantic_store is not None:
+                semantic_chunk_retriever = semantic_store.as_retriever()
+                semantic_mquery_retriever = MultiQueryRetriever.from_llm(
+                    retriever=semantic_chunk_retriever, 
+                    llm=gpt4_model
+                )
+                cls._chain =  (
+                    # INVOKE CHAIN WITH: {"question" : "<<SOME USER QUESTION>>"}
+                    # "question" : populated by getting the value of the "question" key
+                    # "context"  : populated by getting the value of the "question" key and chaining it into the base_retriever
+                    {"context": itemgetter("question") | semantic_mquery_retriever, "question": itemgetter("question")}
+                    # "context"  : is assigned to a RunnablePassthrough object (will not be called or considered in the next step)
+                    #              by getting the value of the "context" key from the previous step
+                    | RunnablePassthrough.assign(context=itemgetter("context"))
+                    # "response" : the "context" and "question" values are used to format our prompt object and then piped
+                    #              into the LLM and stored in a key called "response"
+                    # "context"  : populated by getting the value of the "context" key from the previous step
+                    | {"response": rag_prompt | gpt4_model, "context": itemgetter("context")}
+                )
+                _logger.info(f"\t_chain constructed")
+
+        return cls._chain