Deploying Agentic RAG

AgenticRAG/.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"

AgenticRAG/.gitattributes

@@ -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

AgenticRAG/.gitignore

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

AgenticRAG/Agentic RAG.ipynb

@@ -0,0 +1,428 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "^C\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "grpcio-tools 1.66.1 requires protobuf<6.0dev,>=5.26.1, but you have protobuf 4.25.5 which is incompatible.\n",
+      "langchain-chroma 0.1.3 requires langchain-core<0.3,>=0.1.40, but you have langchain-core 0.3.5 which is incompatible.\n",
+      "langchain-huggingface 0.0.3 requires langchain-core<0.3,>=0.1.52, but you have langchain-core 0.3.5 which is incompatible.\n",
+      "ragas 0.1.20 requires langchain-core<0.3, but you have langchain-core 0.3.5 which is incompatible.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -qU langchain-community tiktoken langchain-openai langchainhub langchain langgraph langchain-text-splitters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install qdrant-client"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders import PyMuPDFLoader\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_community.vectorstores import Qdrant\n",
+    "\n",
+    "pdfs = [\n",
+    "    \"C:/Users/andre/OneDrive/Documents/AIE4/AIE4/Midterm/Blueprint-for-an-AI-Bill-of-Rights.pdf\",\n",
+    "    \"C:/Users/andre/OneDrive/Documents/AIE4/AIE4/Midterm/NIST_report.pdf\",\n",
+    "]\n",
+    "\n",
+    "docs = [PyMuPDFLoader(pdf).load() for pdf in pdfs]\n",
+    "\n",
+    "docs_list = [item for sublist in docs for item in sublist]\n",
+    "\n",
+    "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n",
+    "    chunk_size=500, chunk_overlap=50\n",
+    ")\n",
+    "\n",
+    "doc_splits = text_splitter.split_documents(docs_list)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings(model=\"text-embedding-3-small\")\n",
+    "\n",
+    "vectorstore = Qdrant.from_documents(\n",
+    "    documents=doc_splits,\n",
+    "    embedding=embeddings,\n",
+    "    location=\":memory:\",\n",
+    "    collection_name=\"rag-agentic\"\n",
+    ")\n",
+    "\n",
+    "retriever = vectorstore.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.retriever import create_retriever_tool\n",
+    "\n",
+    "retriever_tool = create_retriever_tool(\n",
+    "    retriever,\n",
+    "    \"retrieve_blog_posts\",\n",
+    "    \"Search and return information about the responsible and ethical use of AI along with the development of policies and practices to protect civil rights and promote democratic values in the building, deployment, and government of automated systems.\",\n",
+    ")\n",
+    "\n",
+    "tools = [retriever_tool]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Annotated, Sequence, TypedDict\n",
+    "\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "\n",
+    "from langgraph.graph.message import add_messages\n",
+    "\n",
+    "\n",
+    "class AgentState(TypedDict):\n",
+    "    # The add_messages function defines how an update should be processed\n",
+    "    # Default is to replace. add_messages says \"append\"\n",
+    "    messages: Annotated[Sequence[BaseMessage], add_messages]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Annotated, Literal, Sequence, TypedDict\n",
+    "\n",
+    "from langchain import hub\n",
+    "from langchain_core.messages import BaseMessage, HumanMessage\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "# NOTE: you must use langchain-core >= 0.3 with Pydantic v2\n",
+    "from pydantic import BaseModel, Field\n",
+    "from langgraph.prebuilt import tools_condition\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "### Edges\n",
+    "\n",
+    "\n",
+    "def grade_documents(state) -> Literal[\"generate\", \"rewrite\"]:\n",
+    "    \"\"\"\n",
+    "    Determines whether the retrieved documents are relevant to the question.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        str: A decision for whether the documents are relevant or not\n",
+    "    \"\"\"\n",
+    "\n",
+    "    print(\"---CHECK RELEVANCE---\")\n",
+    "\n",
+    "    # Data model\n",
+    "    class grade(BaseModel):\n",
+    "        \"\"\"Binary score for relevance check.\"\"\"\n",
+    "\n",
+    "        binary_score: str = Field(description=\"Relevance score 'yes' or 'no'\")\n",
+    "\n",
+    "    # LLM\n",
+    "    model = ChatOpenAI(temperature=0, model=\"gpt-4o-mini\", streaming=True)\n",
+    "\n",
+    "    # LLM with tool and validation\n",
+    "    llm_with_tool = model.with_structured_output(grade)\n",
+    "\n",
+    "    # Prompt\n",
+    "    prompt = PromptTemplate(\n",
+    "        template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n",
+    "        Here is the retrieved document: \\n\\n {context} \\n\\n\n",
+    "        Here is the user question: {question} \\n\n",
+    "        If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n",
+    "        Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\",\n",
+    "        input_variables=[\"context\", \"question\"],\n",
+    "    )\n",
+    "\n",
+    "    # Chain\n",
+    "    chain = prompt | llm_with_tool\n",
+    "\n",
+    "    messages = state[\"messages\"]\n",
+    "    last_message = messages[-1]\n",
+    "\n",
+    "    question = messages[0].content\n",
+    "    docs = last_message.content\n",
+    "\n",
+    "    scored_result = chain.invoke({\"question\": question, \"context\": docs})\n",
+    "\n",
+    "    score = scored_result.binary_score\n",
+    "\n",
+    "    if score == \"yes\":\n",
+    "        print(\"---DECISION: DOCS RELEVANT---\")\n",
+    "        return \"generate\"\n",
+    "\n",
+    "    else:\n",
+    "        print(\"---DECISION: DOCS NOT RELEVANT---\")\n",
+    "        print(score)\n",
+    "        return \"rewrite\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass(\"LangChain API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Nodes\n",
+    "\n",
+    "\n",
+    "def agent(state):\n",
+    "    \"\"\"\n",
+    "    Invokes the agent model to generate a response based on the current state. Given\n",
+    "    the question, it will decide to retrieve using the retriever tool, or simply end.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: The updated state with the agent response appended to messages\n",
+    "    \"\"\"\n",
+    "    print(\"---CALL AGENT---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4o-mini\")\n",
+    "    model = model.bind_tools(tools)\n",
+    "    response = model.invoke(messages)\n",
+    "    # We return a list, because this will get added to the existing list\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "def rewrite(state):\n",
+    "    \"\"\"\n",
+    "    Transform the query to produce a better question.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: The updated state with re-phrased question\n",
+    "    \"\"\"\n",
+    "\n",
+    "    print(\"---TRANSFORM QUERY---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    question = messages[0].content\n",
+    "\n",
+    "    msg = [\n",
+    "        HumanMessage(\n",
+    "            content=f\"\"\" \\n \n",
+    "    Look at the input and try to reason about the underlying semantic intent / meaning. \\n \n",
+    "    Here is the initial question:\n",
+    "    \\n ------- \\n\n",
+    "    {question} \n",
+    "    \\n ------- \\n\n",
+    "    Formulate an improved question: \"\"\",\n",
+    "        )\n",
+    "    ]\n",
+    "\n",
+    "    # Grader\n",
+    "    model = ChatOpenAI(temperature=0, model=\"gpt-4o-mini\", streaming=True)\n",
+    "    response = model.invoke(msg)\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "def generate(state):\n",
+    "    \"\"\"\n",
+    "    Generate answer\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "         dict: The updated state with re-phrased question\n",
+    "    \"\"\"\n",
+    "    print(\"---GENERATE---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    question = messages[0].content\n",
+    "    last_message = messages[-1]\n",
+    "\n",
+    "    docs = last_message.content\n",
+    "\n",
+    "    # Prompt\n",
+    "    prompt = hub.pull(\"rlm/rag-prompt\")\n",
+    "\n",
+    "    # LLM\n",
+    "    llm = ChatOpenAI(model_name=\"gpt-4o-mini\", temperature=0, streaming=True)\n",
+    "\n",
+    "    # Post-processing\n",
+    "    def format_docs(docs):\n",
+    "        return \"\\n\\n\".join(doc.page_content for doc in docs)\n",
+    "\n",
+    "    # Chain\n",
+    "    rag_chain = prompt | llm | StrOutputParser()\n",
+    "\n",
+    "    # Run\n",
+    "    response = rag_chain.invoke({\"context\": docs, \"question\": question})\n",
+    "    return {\"messages\": [response]}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import END, StateGraph, START\n",
+    "from langgraph.prebuilt import ToolNode\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(AgentState)\n",
+    "\n",
+    "# Define the nodes we will cycle between\n",
+    "workflow.add_node(\"agent\", agent)  # agent\n",
+    "retrieve = ToolNode([retriever_tool])\n",
+    "workflow.add_node(\"retrieve\", retrieve)  # retrieval\n",
+    "workflow.add_node(\"rewrite\", rewrite)  # Re-writing the question\n",
+    "workflow.add_node(\n",
+    "    \"generate\", generate\n",
+    ")  # Generating a response after we know the documents are relevant\n",
+    "# Call agent node to decide to retrieve or not\n",
+    "workflow.add_edge(START, \"agent\")\n",
+    "\n",
+    "# Decide whether to retrieve\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"agent\",\n",
+    "    # Assess agent decision\n",
+    "    tools_condition,\n",
+    "    {\n",
+    "        # Translate the condition outputs to nodes in our graph\n",
+    "        \"tools\": \"retrieve\",\n",
+    "        END: END,\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "# Edges taken after the `action` node is called.\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"retrieve\",\n",
+    "    # Assess agent decision\n",
+    "    grade_documents,\n",
+    ")\n",
+    "workflow.add_edge(\"generate\", END)\n",
+    "workflow.add_edge(\"rewrite\", \"agent\")\n",
+    "\n",
+    "# Compile\n",
+    "graph = workflow.compile()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---CALL AGENT---\n",
+      "\"Output from node 'agent':\"\n",
+      "'---'\n",
+      "('Some problems with AI include biases in algorithms that can lead to unfair '\n",
+      " 'treatment of individuals and the potential for job displacement as '\n",
+      " 'automation increases. Additionally, concerns about privacy, security, and '\n",
+      " 'the ethical implications of decision-making by AI systems pose significant '\n",
+      " 'challenges.')\n",
+      "'\\n---\\n'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pprint\n",
+    "\n",
+    "inputs = {\n",
+    "    \"messages\": [\n",
+    "        (\"user\", \"What are some problems with AI? Give me a response in two sentences or less\"),\n",
+    "    ]\n",
+    "}\n",
+    "\n",
+    "\n",
+    "for output in graph.stream(inputs):\n",
+    "    for key, value in output.items():\n",
+    "        pprint.pprint(f\"Output from node '{key}':\")\n",
+    "        pprint.pprint(\"---\")\n",
+    "        pprint.pprint(value['messages'][0].content, indent=2, width=80, depth=None)\n",
+    "    pprint.pprint(\"\\n---\\n\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llm-ops",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

AgenticRAG/BuildingAChainlitApp.md

@@ -0,0 +1,214 @@
+# 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!
+
+Now, we're going to create a helper function for processing uploaded text files.
+
+First, we'll instantiate a shared `CharacterTextSplitter`.
+
+```python
+text_splitter = CharacterTextSplitter()
+```
+
+Now we can define our helper.
+
+```python
+def process_text_file(file: AskFileResponse):
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as temp_file:
+        temp_file_path = temp_file.name
+
+    with open(temp_file_path, "wb") as f:
+        f.write(file.content)
+
+    text_loader = TextFileLoader(temp_file_path)
+    documents = text_loader.load_documents()
+    texts = text_splitter.split_texts(documents)
+    return texts
+```
+
+Simply put, this downloads the file as a temp file, we load it in with `TextFileLoader` and then split it with our `TextSplitter`, and returns that list of strings!
+
+#### QUESTION #1:
+
+Why do we want to support streaming? What about streaming is important, or useful?
+
+## On Chat Start:
+
+The next scope is where "the magic happens". On Chat Start is when a user begins a chat session. This will happen whenever a user opens a new chat window, or refreshes an existing chat window.
+
+You'll see that our code is set-up to immediately show the user a chat box requesting them to upload a file. 
+
+```python
+while files == None:
+        files = await cl.AskFileMessage(
+            content="Please upload a Text File file to begin!",
+            accept=["text/plain"],
+            max_size_mb=2,
+            timeout=180,
+        ).send()
+```
+
+Once we've obtained the text file - we'll use our processing helper function to process our text!
+
+After we have processed our text file - we'll need to create a `VectorDatabase` and populate it with our processed chunks and their related embeddings!
+
+```python
+vector_db = VectorDatabase()
+vector_db = await vector_db.abuild_from_list(texts)
+```
+
+Once we have that piece completed - we can create the chain we'll be using to respond to user queries!
+
+```python
+retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+        vector_db_retriever=vector_db,
+        llm=chat_openai
+    )
+```
+
+Now, we'll save that into our user session!
+
+> NOTE: Chainlit has some great documentation about [User Session](https://docs.chainlit.io/concepts/user-session). 
+
+### QUESTION #2: 
+
+Why are we using User Session here? What about Python makes us need to use this? Why not just store everything in a global variable?
+
+## On Message
+
+First, we load our chain from the user session:
+
+```python
+chain = cl.user_session.get("chain")
+```
+
+Then, we run the chain on the content of the message - and stream it to the front end - that's it!
+
+```python
+msg = cl.Message(content="")
+result = await chain.arun_pipeline(message.content)
+
+async for stream_resp in result["response"]:
+    await msg.stream_token(stream_resp)
+```
+
+## 🎉
+
+With that - you've created a Chainlit application that moves our Pythonic RAG notebook to a Chainlit application!
+
+## 🚧 CHALLENGE MODE 🚧
+
+For an extra challenge - modify the behaviour of your applciation by integrating changes you made to your Pythonic RAG notebook (using new retrieval methods, etc.)
+
+If you're still looking for a challenge, or didn't make any modifications to your Pythonic RAG notebook:
+
+1) Allow users to upload PDFs (this will require you to build a PDF parser as well)
+2) Modify the VectorStore to leverage [Qdrant](https://python-client.qdrant.tech/)
+
+> NOTE: The motivation for these challenges is simple - the beginning of the course is extremely information dense, and people come from all kinds of different technical backgrounds. In order to ensure that all learners are able to engage with the content confidently and comfortably, we want to focus on the basic units of technical competency required. This leads to a situation where some learners, who came in with more robust technical skills, find the introductory material to be too simple - and these open-ended challenges help us do this! 
+
+
+
+
+

AgenticRAG/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"]

AgenticRAG/README.md

@@ -0,0 +1,118 @@
+---
+title: MidtermTask2
+emoji: 📉
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+# Deploying Pythonic Chat With Your Text File Application
+
+In today's breakout rooms, we will be following the processed that you saw during the challenge - for reference, the instructions for that are available [here](https://github.com/AI-Maker-Space/Beyond-ChatGPT/tree/main).
+
+Today, we will repeat the same process - but powered by our Pythonic RAG implementation we created last week. 
+
+You'll notice a few differences in the `app.py` logic - as well as a few changes to the `aimakerspace` package to get things working smoothly with Chainlit.
+
+## Reference Diagram (It's Busy, but it works)
+
+![image](https://i.imgur.com/IaEVZG2.png)
+
+## Deploying the Application to Hugging Face Space
+
+Due to the way the repository is created - it should be straightforward to deploy this to a Hugging Face Space!
+
+> NOTE: If you wish to go through the local deployments using `chainlit run app.py` and Docker - please feel free to do so!
+
+<details>
+    <summary>Creating a Hugging Face Space</summary>
+
+1.  Navigate to the `Spaces` tab.
+
+![image](https://i.imgur.com/aSMlX2T.png)
+
+2. Click on `Create new Space`
+
+![image](https://i.imgur.com/YaSSy5p.png)
+
+3. Create the Space by providing values in the form. Make sure you've selected "Docker" as your Space SDK.
+
+![image](https://i.imgur.com/6h9CgH6.png)
+
+</details>
+
+<details>
+    <summary>Adding this Repository to the Newly Created Space</summary>
+
+1. Collect the SSH address from the newly created Space. 
+
+![image](https://i.imgur.com/Oag0m8E.png)
+
+> NOTE: The address is the component that starts with `git@hf.co:spaces/`.
+
+2. Use the command:
+
+```bash
+git remote add hf HF_SPACE_SSH_ADDRESS_HERE
+```
+
+3. Use the command:
+
+```bash
+git pull hf main --no-rebase --allow-unrelated-histories -X ours
+```
+
+4. Use the command: 
+
+```bash 
+git add .
+```
+
+5. Use the command:
+
+```bash
+git commit -m "Deploying Pythonic RAG"
+```
+
+6. Use the command: 
+
+```bash
+git push hf main
+```
+
+7. The Space should automatically build as soon as the push is completed!
+
+> NOTE: The build will fail before you complete the following steps!
+
+</details>
+
+<details>
+    <summary>Adding OpenAI Secrets to the Space</summary>
+
+1. Navigate to your Space settings.
+
+![image](https://i.imgur.com/zh0a2By.png)
+
+2. Navigate to `Variables and secrets` on the Settings page and click `New secret`: 
+
+![image](https://i.imgur.com/g2KlZdz.png)
+
+3. In the `Name` field - input `OPENAI_API_KEY` in the `Value (private)` field, put your OpenAI API Key.
+
+![image](https://i.imgur.com/eFcZ8U3.png)
+
+4. The Space will begin rebuilding!
+
+</details>
+
+## 🎉
+
+You just deployed Pythonic RAG!
+
+Try uploading a text file and asking some questions!
+
+## 🚧CHALLENGE MODE 🚧
+
+For more of a challenge, please reference [Building a Chainlit App](./BuildingAChainlitApp.md)!

AgenticRAG/aimakerspace/openai_utils/chatmodel.py

@@ -0,0 +1,45 @@
+from openai import OpenAI, AsyncOpenAI
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+
+class ChatOpenAI:
+    def __init__(self, model_name: str = "gpt-4o-mini"):
+        self.model_name = model_name
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if self.openai_api_key is None:
+            raise ValueError("OPENAI_API_KEY is not set")
+
+    def run(self, messages, text_only: bool = True, **kwargs):
+        if not isinstance(messages, list):
+            raise ValueError("messages must be a list")
+
+        client = OpenAI()
+        response = client.chat.completions.create(
+            model=self.model_name, messages=messages, **kwargs
+        )
+
+        if text_only:
+            return response.choices[0].message.content
+
+        return response
+    
+    async def astream(self, messages, **kwargs):
+        if not isinstance(messages, list):
+            raise ValueError("messages must be a list")
+        
+        client = AsyncOpenAI()
+
+        stream = await client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            stream=True,
+            **kwargs
+        )
+
+        async for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content is not None:
+                yield content

AgenticRAG/aimakerspace/openai_utils/embedding.py

@@ -0,0 +1,59 @@
+from dotenv import load_dotenv
+from openai import AsyncOpenAI, OpenAI
+import openai
+from typing import List
+import os
+import asyncio
+
+
+class EmbeddingModel:
+    def __init__(self, embeddings_model_name: str = "text-embedding-3-small"):
+        load_dotenv()
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.async_client = AsyncOpenAI()
+        self.client = OpenAI()
+
+        if self.openai_api_key is None:
+            raise ValueError(
+                "OPENAI_API_KEY environment variable is not set. Please set it to your OpenAI API key."
+            )
+        openai.api_key = self.openai_api_key
+        self.embeddings_model_name = embeddings_model_name
+
+    async def async_get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
+        embedding_response = await self.async_client.embeddings.create(
+            input=list_of_text, model=self.embeddings_model_name
+        )
+
+        return [embeddings.embedding for embeddings in embedding_response.data]
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        embedding = await self.async_client.embeddings.create(
+            input=text, model=self.embeddings_model_name
+        )
+
+        return embedding.data[0].embedding
+
+    def get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
+        embedding_response = self.client.embeddings.create(
+            input=list_of_text, model=self.embeddings_model_name
+        )
+
+        return [embeddings.embedding for embeddings in embedding_response.data]
+
+    def get_embedding(self, text: str) -> List[float]:
+        embedding = self.client.embeddings.create(
+            input=text, model=self.embeddings_model_name
+        )
+
+        return embedding.data[0].embedding
+
+
+if __name__ == "__main__":
+    embedding_model = EmbeddingModel()
+    print(asyncio.run(embedding_model.async_get_embedding("Hello, world!")))
+    print(
+        asyncio.run(
+            embedding_model.async_get_embeddings(["Hello, world!", "Goodbye, world!"])
+        )
+    )

AgenticRAG/aimakerspace/openai_utils/prompts.py

@@ -0,0 +1,78 @@
+import re
+
+
+class BasePrompt:
+    def __init__(self, prompt):
+        """
+        Initializes the BasePrompt object with a prompt template.
+
+        :param prompt: A string that can contain placeholders within curly braces
+        """
+        self.prompt = prompt
+        self._pattern = re.compile(r"\{([^}]+)\}")
+
+    def format_prompt(self, **kwargs):
+        """
+        Formats the prompt string using the keyword arguments provided.
+
+        :param kwargs: The values to substitute into the prompt string
+        :return: The formatted prompt string
+        """
+        matches = self._pattern.findall(self.prompt)
+        return self.prompt.format(**{match: kwargs.get(match, "") for match in matches})
+
+    def get_input_variables(self):
+        """
+        Gets the list of input variable names from the prompt string.
+
+        :return: List of input variable names
+        """
+        return self._pattern.findall(self.prompt)
+
+
+class RolePrompt(BasePrompt):
+    def __init__(self, prompt, role: str):
+        """
+        Initializes the RolePrompt object with a prompt template and a role.
+
+        :param prompt: A string that can contain placeholders within curly braces
+        :param role: The role for the message ('system', 'user', or 'assistant')
+        """
+        super().__init__(prompt)
+        self.role = role
+
+    def create_message(self, format=True, **kwargs):
+        """
+        Creates a message dictionary with a role and a formatted message.
+
+        :param kwargs: The values to substitute into the prompt string
+        :return: Dictionary containing the role and the formatted message
+        """
+        if format:
+            return {"role": self.role, "content": self.format_prompt(**kwargs)}
+        
+        return {"role": self.role, "content": self.prompt}
+
+
+class SystemRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "system")
+
+
+class UserRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "user")
+
+
+class AssistantRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "assistant")
+
+
+if __name__ == "__main__":
+    prompt = BasePrompt("Hello {name}, you are {age} years old")
+    print(prompt.format_prompt(name="John", age=30))
+
+    prompt = SystemRolePrompt("Hello {name}, you are {age} years old")
+    print(prompt.create_message(name="John", age=30))
+    print(prompt.get_input_variables())

AgenticRAG/aimakerspace/text_utils.py

@@ -0,0 +1,77 @@
+import os
+from typing import List
+
+
+class TextFileLoader:
+    def __init__(self, path: str, encoding: str = "utf-8"):
+        self.documents = []
+        self.path = path
+        self.encoding = encoding
+
+    def load(self):
+        if os.path.isdir(self.path):
+            self.load_directory()
+        elif os.path.isfile(self.path) and self.path.endswith(".txt"):
+            self.load_file()
+        else:
+            raise ValueError(
+                "Provided path is neither a valid directory nor a .txt file."
+            )
+
+    def load_file(self):
+        with open(self.path, "r", encoding=self.encoding) as f:
+            self.documents.append(f.read())
+
+    def load_directory(self):
+        for root, _, files in os.walk(self.path):
+            for file in files:
+                if file.endswith(".txt"):
+                    with open(
+                        os.path.join(root, file), "r", encoding=self.encoding
+                    ) as f:
+                        self.documents.append(f.read())
+
+    def load_documents(self):
+        self.load()
+        return self.documents
+
+
+class CharacterTextSplitter:
+    def __init__(
+        self,
+        chunk_size: int = 1000,
+        chunk_overlap: int = 200,
+    ):
+        assert (
+            chunk_size > chunk_overlap
+        ), "Chunk size must be greater than chunk overlap"
+
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def split(self, text: str) -> List[str]:
+        chunks = []
+        for i in range(0, len(text), self.chunk_size - self.chunk_overlap):
+            chunks.append(text[i : i + self.chunk_size])
+        return chunks
+
+    def split_texts(self, texts: List[str]) -> List[str]:
+        chunks = []
+        for text in texts:
+            chunks.extend(self.split(text))
+        return chunks
+
+
+if __name__ == "__main__":
+    loader = TextFileLoader("data/KingLear.txt")
+    loader.load()
+    splitter = CharacterTextSplitter()
+    chunks = splitter.split_texts(loader.documents)
+    print(len(chunks))
+    print(chunks[0])
+    print("--------")
+    print(chunks[1])
+    print("--------")
+    print(chunks[-2])
+    print("--------")
+    print(chunks[-1])

AgenticRAG/aimakerspace/vectordatabase.py

@@ -0,0 +1,81 @@
+import numpy as np
+from collections import defaultdict
+from typing import List, Tuple, Callable
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+import asyncio
+
+
+def cosine_similarity(vector_a: np.array, vector_b: np.array) -> float:
+    """Computes the cosine similarity between two vectors."""
+    dot_product = np.dot(vector_a, vector_b)
+    norm_a = np.linalg.norm(vector_a)
+    norm_b = np.linalg.norm(vector_b)
+    return dot_product / (norm_a * norm_b)
+
+
+class VectorDatabase:
+    def __init__(self, embedding_model: EmbeddingModel = None):
+        self.vectors = defaultdict(np.array)
+        self.embedding_model = embedding_model or EmbeddingModel()
+
+    def insert(self, key: str, vector: np.array) -> None:
+        self.vectors[key] = vector
+
+    def search(
+        self,
+        query_vector: np.array,
+        k: int,
+        distance_measure: Callable = cosine_similarity,
+    ) -> List[Tuple[str, float]]:
+        scores = [
+            (key, distance_measure(query_vector, vector))
+            for key, vector in self.vectors.items()
+        ]
+        return sorted(scores, key=lambda x: x[1], reverse=True)[:k]
+
+    def search_by_text(
+        self,
+        query_text: str,
+        k: int,
+        distance_measure: Callable = cosine_similarity,
+        return_as_text: bool = False,
+    ) -> List[Tuple[str, float]]:
+        query_vector = self.embedding_model.get_embedding(query_text)
+        results = self.search(query_vector, k, distance_measure)
+        return [result[0] for result in results] if return_as_text else results
+
+    def retrieve_from_key(self, key: str) -> np.array:
+        return self.vectors.get(key, None)
+
+    async def abuild_from_list(self, list_of_text: List[str]) -> "VectorDatabase":
+        embeddings = await self.embedding_model.async_get_embeddings(list_of_text)
+        for text, embedding in zip(list_of_text, embeddings):
+            self.insert(text, np.array(embedding))
+        return self
+
+
+if __name__ == "__main__":
+    list_of_text = [
+        "I like to eat broccoli and bananas.",
+        "I ate a banana and spinach smoothie for breakfast.",
+        "Chinchillas and kittens are cute.",
+        "My sister adopted a kitten yesterday.",
+        "Look at this cute hamster munching on a piece of broccoli.",
+    ]
+
+    vector_db = VectorDatabase()
+    vector_db = asyncio.run(vector_db.abuild_from_list(list_of_text))
+    k = 2
+
+    searched_vector = vector_db.search_by_text("I think fruit is awesome!", k=k)
+    print(f"Closest {k} vector(s):", searched_vector)
+
+    retrieved_vector = vector_db.retrieve_from_key(
+        "I like to eat broccoli and bananas."
+    )
+    print("Retrieved vector:", retrieved_vector)
+
+    relevant_texts = vector_db.search_by_text(
+        "I think fruit is awesome!", k=k, return_as_text=True
+    )
+    print(f"Closest {k} text(s):", relevant_texts)

AgenticRAG/app.py

@@ -0,0 +1,137 @@
+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
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+# from langchain_experimental.text_splitter import SemanticChunker
+# from langchain_openai.embeddings import OpenAIEmbeddings
+
+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)
+
+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):
+        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"
+
+        formatted_system_prompt = system_role_prompt.create_message()
+
+        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+
+        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}
+
+text_splitter = RecursiveCharacterTextSplitter()
+# try:
+#     api_key = os.environ["OPENAI_API_KEY"]
+# except KeyError:
+#     print("Environment variable OPENAI_API_KEY not found")
+# text_splitter = SemanticChunker(OpenAIEmbeddings(api_key=api_key), breakpoint_threshold_type="standard_deviation")
+
+def process_text_file(file: AskFileResponse):
+    import tempfile
+    from langchain_community.document_loaders.pdf import PyPDFLoader
+
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=file.name) as temp_file:
+        temp_file_path = temp_file.name
+
+    with open(temp_file_path, "wb") as f:
+        f.write(file.content)
+
+    if file.type == 'text/plain':
+        text_loader = TextFileLoader(temp_file_path)
+        documents = text_loader.load_documents()
+    elif file.type == 'application/pdf':
+        pdf_loader = PyPDFLoader(temp_file_path)
+        documents = pdf_loader.load()
+    else:
+        raise ValueError("Provide a .txt or .pdf file")
+    texts = [x.page_content for x in text_splitter.transform_documents(documents)]
+    # texts = [x.page_content for x in text_splitter.split_documents(documents)]
+    return texts
+
+
+
+@cl.on_chat_start
+async def on_chat_start():
+    files = None
+
+    # Wait for the user to upload a file
+    while files == None:
+        files = await cl.AskFileMessage(
+            content="Please upload a Text file or a PDF to begin!",
+            accept=["text/plain", "application/pdf"],
+            max_size_mb=12,
+            timeout=180,
+        ).send()
+
+    file = files[0]
+
+    msg = cl.Message(
+        content=f"Processing `{file.name}`...", disable_human_feedback=True
+    )
+    await msg.send()
+
+    # load the file
+    texts = process_text_file(file)
+
+    print(f"Processing {len(texts)} text chunks")
+
+    # Create a dict vector store
+    vector_db = VectorDatabase()
+    vector_db = await vector_db.abuild_from_list(texts)
+    
+    chat_openai = ChatOpenAI()
+
+    # Create a chain
+    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+        vector_db_retriever=vector_db,
+        llm=chat_openai
+    )
+    
+    # Let the user know that the system is ready
+    msg.content = f"Processing `{file.name}` 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)
+
+    async for stream_resp in result["response"]:
+        await msg.stream_token(stream_resp)
+
+    await msg.send()

AgenticRAG/chainlit.md

@@ -0,0 +1,3 @@
+# Welcome to Chat with Your Text File
+
+With this application, you can chat with an uploaded text file that is smaller than 2MB!

AgenticRAG/requirements.txt

@@ -0,0 +1,7 @@
+numpy
+chainlit==0.7.700
+openai
+langchain_community
+langchain_experimental
+langchain_openai
+pypdf

AgenticRAG/runtime.txt

@@ -0,0 +1 @@
+python-3.11.9