Midterm Prototype

.chainlit/config.toml

@@ -0,0 +1,84 @@
+[project]
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+# List of environment variables to be provided by each user to use the app.
+user_env = []
+
+# Duration (in seconds) during which the session is saved when the connection is lost
+session_timeout = 3600
+
+# Enable third parties caching (e.g LangChain cache)
+cache = false
+
+# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
+follow_symlink = true
+
+[features]
+# Show the prompt playground
+prompt_playground = true
+
+# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
+unsafe_allow_html = false
+
+# Process and display mathematical expressions. This can clash with "$" characters in messages.
+latex = false
+
+# Authorize users to upload files with messages
+multi_modal = true
+
+# Allows user to use speech to text
+[features.speech_to_text]
+    enabled = false
+    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
+    # language = "en-US"
+
+[UI]
+# Name of the app and chatbot.
+name = "Chatbot"
+
+# Show the readme while the conversation is empty.
+show_readme_as_default = true
+
+# Description of the app and chatbot. This is used for HTML tags.
+# description = ""
+
+# Large size content are by default collapsed for a cleaner ui
+default_collapse_content = true
+
+# The default value for the expand messages settings.
+default_expand_messages = false
+
+# Hide the chain of thought details from the user in the UI.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI's header.
+# github = ""
+
+# Specify a CSS file that can be used to customize the user interface.
+# The CSS file can be served from the public directory or via an external link.
+# custom_css = "/public/test.css"
+
+# Override default MUI light theme. (Check theme.ts)
+[UI.theme.light]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.light.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+# Override default MUI dark theme. (Check theme.ts)
+[UI.theme.dark]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.dark.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+
+[meta]
+generated_by = "0.7.700"

.env

@@ -0,0 +1,9 @@
+OPENAI_API_KEY = "sk-proj-VlBPJdI2pTDAj1ZuTR1CT3BlbkFJdPixzv6JsSYgSdeU6iUL"
+ANTRHOPIC_API_KEY = "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"
+SERPER_API_KEY = "e1433dbffb60ed98eb675bf110a3af71075787f7"
+PINECONE_API_KEY = "02477b08-f824-4cda-accc-1104bd9c2268"
+LANGCHAIN_API_KEY = "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"
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_ENDPOINT='https://api.smith.langchain.com'
+TAVILY_API_KEY="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"
+ZIPCODE_API_KEY="myBqK3rhFoNaVN2TKYWUdLplkZzOwh8uwA1GNqc35LocxwJEU10QohlJMCDbZkIx"

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb 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
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+__pycache__/

BuildingAChainlitApp.md

@@ -0,0 +1,111 @@
+# Building a Chainlit App
+
+What if we want to take our Week 1 Day 2 assignment - [Pythonic RAG](https://github.com/AI-Maker-Space/AIE4/tree/main/Week%201/Day%202) - and bring it out of the notebook?
+
+Well - we'll cover exactly that here!
+
+## Anatomy of a Chainlit Application
+
+[Chainlit](https://docs.chainlit.io/get-started/overview) is a Python package similar to Streamlit that lets users write a backend and a front end in a single (or multiple) Python file(s). It is mainly used for prototyping LLM-based Chat Style Applications - though it is used in production in some settings with 1,000,000s of MAUs (Monthly Active Users).
+
+The primary method of customizing and interacting with the Chainlit UI is through a few critical [decorators](https://blog.hubspot.com/website/decorators-in-python).
+
+> NOTE: Simply put, the decorators (in Chainlit) are just ways we can "plug-in" to the functionality in Chainlit. 
+
+We'll be concerning ourselves with three main scopes:
+
+1. On application start - when we start the Chainlit application with a command like `chainlit run app.py`
+2. On chat start - when a chat session starts (a user opens the web browser to the address hosting the application)
+3. On message - when the users sends a message through the input text box in the Chainlit UI
+
+Let's dig into each scope and see what we're doing!
+
+## On Application Start:
+
+The first thing you'll notice is that we have the traditional "wall of imports" this is to ensure we have everything we need to run our application. 
+
+```python
+import os
+from typing import List
+from chainlit.types import AskFileResponse
+from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader
+from aimakerspace.openai_utils.prompts import (
+    UserRolePrompt,
+    SystemRolePrompt,
+    AssistantRolePrompt,
+)
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+from aimakerspace.vectordatabase import VectorDatabase
+from aimakerspace.openai_utils.chatmodel import ChatOpenAI
+import chainlit as cl
+```
+
+Next up, we have some prompt templates. As all sessions will use the same prompt templates without modification, and we don't need these templates to be specific per template - we can set them up here - at the application scope. 
+
+```python
+system_template = """\
+Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
+system_role_prompt = SystemRolePrompt(system_template)
+
+user_prompt_template = """\
+Context:
+{context}
+
+Question:
+{question}
+"""
+user_role_prompt = UserRolePrompt(user_prompt_template)
+```
+
+> NOTE: You'll notice that these are the exact same prompt templates we used from the Pythonic RAG Notebook in Week 1 Day 2!
+
+Following that - we can create the Python Class definition for our RAG pipeline - or *chain*, as we'll refer to it in the rest of this walkthrough. 
+
+Let's look at the definition first:
+
+```python
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
+        self.llm = llm
+        self.vector_db_retriever = vector_db_retriever
+
+    async def arun_pipeline(self, user_query: str):
+        ### RETRIEVAL
+        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
+
+        context_prompt = ""
+        for context in context_list:
+            context_prompt += context[0] + "\n"
+
+        ### AUGMENTED
+        formatted_system_prompt = system_role_prompt.create_message()
+
+        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+
+
+        ### GENERATION
+        async def generate_response():
+            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
+                yield chunk
+
+        return {"response": generate_response(), "context": context_list}
+```
+
+Notice a few things:
+
+1. We have modified this `RetrievalAugmentedQAPipeline` from the initial notebook to support streaming. 
+2. In essence, our pipeline is *chaining* a few events together:
+    1. We take our user query, and chain it into our Vector Database to collect related chunks
+    2. We take those contexts and our user's questions and chain them into the prompt templates
+    3. We take that prompt template and chain it into our LLM call
+    4. We chain the response of the LLM call to the user
+3. We are using a lot of `async` again!
+
+#### QUESTION #1:
+
+Why do we want to support streaming? What about streaming is important, or useful?
+
+
+
+
+

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["chainlit", "run", "app.py", "--port", "7860"]

app.py

@@ -0,0 +1,153 @@
+from langchain.prompts import ChatPromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyMuPDFLoader
+import chainlit as cl
+import os
+from langchain_qdrant import QdrantVectorStore
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from langchain_openai.chat_models import ChatOpenAI
+from operator import itemgetter
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+from uuid import uuid4
+
+from dotenv import load_dotenv, find_dotenv
+
+load_dotenv(find_dotenv())
+
+base_rag_prompt_template = """\
+Only answer questions that are related to the context provided. DO NOT answer a question if it is unrelated to the context provided. If you do not know the answer, say "I do not know the answer".
+
+Context:
+{context}
+
+Question:
+{question}
+"""
+
+base_rag_prompt = ChatPromptTemplate.from_template(base_rag_prompt_template)
+
+recursiveChunker = RecursiveCharacterTextSplitter(
+    chunk_size = 600,
+    chunk_overlap = 60,
+    length_function = len
+)
+
+LOCATION = ":memory:"
+COLLECTION_NAME = "Ethical AI RAG"
+VECTOR_SIZE = 384
+
+model_name = "sentence-transformers/all-MiniLM-L6-v2"
+untrained_embeddings = HuggingFaceEmbeddings(model_name=model_name)
+
+rag_llm = ChatOpenAI(model="gpt-4o-mini")
+
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: QdrantVectorStore) -> None:
+        self.chain = (
+            {"context": itemgetter("question") | vector_db_retriever, "question": itemgetter("question")}
+            | RunnablePassthrough.assign(context=itemgetter("context"))
+            | {"response": base_rag_prompt | llm, "context": itemgetter("context")}
+        )
+
+    async def arun_pipeline(self, user_query: str):
+        # Invoke the chain synchronously and get the result (assumed to be a dict)
+        result = self.chain.invoke({"question": user_query})
+
+        # Async generator to yield only the content part of the tuples, and ignore others
+        async def generate_response():
+            if isinstance(result, dict) and 'response' in result:
+                for chunk in result['response']:
+                    # If the chunk is a tuple with a "content" field, yield the content
+                    if isinstance(chunk, tuple) and len(chunk) == 2:
+                        label, content = chunk
+                        if label == "content":
+                            yield content
+                        else:
+                            # Ignore tuples that don't have 'content' as the label
+                            continue
+                    elif isinstance(chunk, str):
+                        # If it's already a string, just yield it (edge case)
+                        yield chunk
+                    else:
+                        # Ignore any non-string, non-tuple chunks
+                        continue
+            else:
+                # If result does not contain the expected structure, just do nothing
+                return
+
+        # Return the async generator
+        return generate_response()
+    
+@cl.on_chat_start
+async def on_chat_start():
+    all_documents = []
+    pdf_urls = [
+        'https://www.whitehouse.gov/wp-content/uploads/2022/10/Blueprint-for-an-AI-Bill-of-Rights.pdf',
+        'https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf'
+    ]
+
+    msg = cl.Message(
+        content=f"Loading documents...", disable_human_feedback=True
+    )
+    await msg.send()
+
+    for url in pdf_urls:
+        # Create a PyMuPDFLoader on that PDF
+        loader = PyMuPDFLoader(file_path=url)
+        # Load it into a document
+        documents = loader.load()
+        
+        # Append each document to the all_documents list
+        all_documents.extend(documents)
+
+    print(f"Processing documents...")
+    split_docs = recursiveChunker.split_documents(all_documents)
+
+    # Create a dict vector store
+    qdrant_client = QdrantClient(LOCATION)
+
+    qdrant_client.create_collection(
+        collection_name=COLLECTION_NAME,
+        vectors_config=VectorParams(size=VECTOR_SIZE, distance=Distance.COSINE),
+    )
+
+    qdrant_vector_store = QdrantVectorStore(
+        client=qdrant_client,
+        collection_name=COLLECTION_NAME,
+        embedding=untrained_embeddings,
+    )
+
+    uuids = [str(uuid4()) for _ in range(len(split_docs))]
+
+    qdrant_vector_store.add_documents(documents=split_docs, ids=uuids)
+
+    retriever = qdrant_vector_store.as_retriever()
+
+    # Create a chain
+    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+        vector_db_retriever=retriever,
+        llm=rag_llm
+    )
+    
+    # Let the user know that the system is ready
+    msg.content = f"Processing done. You can now ask questions!"
+    await msg.update()
+
+    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
+
+
+@cl.on_message
+async def main(message):
+    chain = cl.user_session.get("chain")
+
+    msg = cl.Message(content="")
+    result = await chain.arun_pipeline(message.content)  # Returns the async generator
+
+    # Streaming each token in the response to the user
+    async for stream_resp in result:  # Iterating over the async generator directly
+        await msg.stream_token(stream_resp)
+
+    await msg.send()

chainlit.md

@@ -0,0 +1,5 @@
+# Welcome to the AI Q+A App (Prototype)
+
+With this application, you can ask questions about the following docuemnts:
+1. 2022: [Blueprint for an AI Bill of Rights: Making Automated Systems Work for the American People](https://www.whitehouse.gov/wp-content/uploads/2022/10/Blueprint-for-an-AI-Bill-of-Rights.pdf) (PDF)
+2. 2024: [National Institute of Standards and Technology (NIST) Artificial Intelligent Risk Management Framework](https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf) (PDF)

requirements.txt

@@ -0,0 +1,9 @@
+chainlit==0.7.700
+langchain
+langchain_huggingface
+langchain_community
+langchain_openai
+qdrant-client
+chainlit
+python-dotenv
+PyMuPDF