{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "75924aae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "from openai import OpenAI\n",
    "from sentence_transformers import SentenceTransformer\n",
    "from chromadb import PersistentClient\n",
    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
    "from dotenv import load_dotenv\n",
    "from groq import Groq\n",
    "from pydantic import BaseModel, Field\n",
    "from sentence_transformers import CrossEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bfe2785",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Chunk(BaseModel):\n",
    "    page_content: str\n",
    "    metadata: dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "2d34b559",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30447b9f464e4b69aad5c9fe204f7a9f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading weights:   0%|          | 0/103 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc8087ba0bae4657a22bf58ab29903db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "config.json:   0%|          | 0.00/794 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a394afb268e4067a3879f02b0d46ea6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "model.safetensors:   0%|          | 0.00/90.9M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "811e16065c8a41ee8de19c877df8f53a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading weights:   0%|          | 0/105 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "55e86a8bc3fc43bfbb17dfb7e072bedf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "tokenizer_config.json: 0.00B [00:00, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fe2b797f7ec144e2a5e27e16148dbb3f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "vocab.txt: 0.00B [00:00, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ce939d387ac14ea6ac86f84c90500e9f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "tokenizer.json: 0.00B [00:00, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1a56a76219484dc2b5eda962c64f6297",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "special_tokens_map.json:   0%|          | 0.00/132 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "load_dotenv(override=True)\n",
    "\n",
    "# embedder = \"text-embedding-3-small\"\n",
    "\n",
    "embedder = SentenceTransformer(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
    "chroma = PersistentClient(path=\"./chroma_db\")\n",
    "cross_encoder = CrossEncoder(\"cross-encoder/ms-marco-MiniLM-L-6-v2\")\n",
    "try:\n",
    "    chroma.delete_collection(\"transcripts\")\n",
    "except:\n",
    "    pass\n",
    "collection = chroma.get_or_create_collection(\"transcripts\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9f0d68c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded: transcripts/week1/day1.txt (26223 characters)\n",
      "Loaded: transcripts/week1/day2.txt (58501 characters)\n",
      "Loaded: transcripts/week1/day3.txt (60638 characters)\n",
      "Loaded: transcripts/week1/day4.txt (63771 characters)\n",
      "Loaded: transcripts/week1/day5.txt (49341 characters)\n",
      "Loaded: transcripts/week2/day1.txt (56984 characters)\n",
      "Loaded: transcripts/week2/day2.txt (48278 characters)\n",
      "Loaded: transcripts/week2/day3.txt (24669 characters)\n",
      "Loaded: transcripts/week2/day4.txt (43010 characters)\n",
      "Loaded: transcripts/week2/day5.txt (41925 characters)\n",
      "Loaded: transcripts/week3/day1.txt (57773 characters)\n",
      "Loaded: transcripts/week3/day2.txt (37510 characters)\n",
      "Loaded: transcripts/week3/day3.txt (31971 characters)\n",
      "Loaded: transcripts/week3/day4.txt (49713 characters)\n",
      "Loaded: transcripts/week3/day5.txt (34825 characters)\n",
      "Loaded: transcripts/week4/day1.txt (40530 characters)\n",
      "Loaded: transcripts/week4/day2.txt (41132 characters)\n",
      "Loaded: transcripts/week4/day3.txt (37400 characters)\n",
      "Loaded: transcripts/week4/day4.txt (21672 characters)\n",
      "Loaded: transcripts/week4/day5.txt (40557 characters)\n",
      "Loaded: transcripts/week5/day1.txt (54101 characters)\n",
      "Loaded: transcripts/week5/day2.txt (50818 characters)\n",
      "Loaded: transcripts/week5/day3.txt (52672 characters)\n",
      "Loaded: transcripts/week5/day4.txt (69188 characters)\n",
      "Loaded: transcripts/week5/day5.txt (95059 characters)\n",
      "Loaded: transcripts/week6/day1.txt (67664 characters)\n",
      "Loaded: transcripts/week6/day2.txt (52172 characters)\n",
      "Loaded: transcripts/week6/day3.txt (48991 characters)\n",
      "Loaded: transcripts/week6/day4.txt (50317 characters)\n",
      "Loaded: transcripts/week6/day5.txt (59310 characters)\n",
      "Loaded: transcripts/week7/day1.txt (60465 characters)\n",
      "Loaded: transcripts/week7/day2.txt (44176 characters)\n",
      "Loaded: transcripts/week7/day3.txt (54756 characters)\n",
      "Loaded: transcripts/week7/day4.txt (45257 characters)\n",
      "Loaded: transcripts/week7/day5.txt (30862 characters)\n",
      "Loaded: transcripts/week8/day1.txt (62718 characters)\n",
      "Loaded: transcripts/week8/day2.txt (42491 characters)\n",
      "Loaded: transcripts/week8/day3.txt (27031 characters)\n",
      "Loaded: transcripts/week8/day4.txt (27832 characters)\n",
      "Loaded: transcripts/week8/day5.txt (16995 characters)\n",
      "\n",
      "Total documents loaded: 40\n"
     ]
    }
   ],
   "source": [
    "def load_documents(base_path=\"transcripts\"):\n",
    "    \"\"\"\n",
    "    Loops through the folders from the base_path and reads the txt files inside them\n",
    "    Reads each transcript and stores text + metadata in a list of dicts\n",
    "    Returns one dict(documents) per file with text, week, day, source\n",
    "    \"\"\"\n",
    "    documents = [] #List of dicts\n",
    "    base = Path(base_path) #Converts base_path into a Path object to use .glob and .iterdir\n",
    "    \n",
    "\n",
    "# Load documents from the transcripts folder\n",
    "# If its not a folder, continue\n",
    "# If it is a folder, iterate through all files in the folder\n",
    "    for week_folder in sorted(base.iterdir()):\n",
    "        if not week_folder.is_dir():\n",
    "            continue\n",
    "    # Iterate through all files in the week folder using .glob\n",
    "        for file in sorted(week_folder.glob(\"*.txt\")):\n",
    "            text = file.read_text(encoding=\"utf-8\")\n",
    "            # Create a dictionary for each document and add it to the list\n",
    "            documents.append({\n",
    "                \"text\": text, # text of the transcript\n",
    "                \"week\": week_folder.name, # name of the week folder\n",
    "                \"day\": file.stem, # name of the file\n",
    "                \"source\": str(file) # path of the file. file is a Path object and its converted to a string\n",
    "            })\n",
    "            print(f\"Loaded: {file} ({len(text)} characters)\")\n",
    "\n",
    "    print(f\"\\nTotal documents loaded: {len(documents)}\")\n",
    "    return documents\n",
    "\n",
    "documents = load_documents() #documents is the result of load_documents()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a8635738",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chunk_documents(documents):\n",
    "    \"\"\"\n",
    "    Creates chunks and converts them into pydantic objects with metadata\n",
    "    \"\"\"\n",
    "    # Creates the chunks using Langchains RecursiveCharacterTextSplitter\n",
    "    splitter = RecursiveCharacterTextSplitter(\n",
    "        chunk_size=500,\n",
    "        chunk_overlap=50,\n",
    "        separators=[\"--- Lecture\", \"\\n\\n\", \"\\n\", \" \"]\n",
    "    ) \n",
    "     # Loops on the documents list which is a list of dicts from the cell above  \n",
    "    chunks = []\n",
    "    for doc in documents:\n",
    "        pieces = splitter.split_text(doc[\"text\"]) # split_text splits documents into chunks based on the parameters from RecursiveCharacterTextSplitter.\n",
    "        # Puts in pydantic structure for structured outputs and dot notation access\n",
    "        for piece in pieces:\n",
    "            chunks.append(Chunk(\n",
    "                page_content=piece, # full text of the chunk\n",
    "                metadata={\"week\": doc[\"week\"], \"day\": doc[\"day\"], \"source\": doc[\"source\"]}\n",
    "            ))\n",
    "    print(f\"Total chunks created: {len(chunks)}\")\n",
    "    print(f\"\\n--- Sample chunk ---\\n\")\n",
    "    print(chunks[0].page_content)\n",
    "    return chunks # A list of Chunk pydantic objects that include text, week, day, and source"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cd7eb8cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total chunks created: 4287\n",
      "\n",
      "--- Sample chunk ---\n",
      "\n",
      "--- Lecture 1 ---\n",
      "Okay, so now you scroll to this first box right here which says imports.\n",
      "And the way that you run this bit of code known as a cell is you hold down the shift button and you\n",
      "press return.\n",
      "While you've clicked anywhere in this box, I press this and it runs.\n",
      "Now, if you have any errors running this, if you get an import error or something like that, or if\n",
      "it just doesn't seem to run, it just sits there.\n",
      "It means your kernel isn't set right.\n",
      "Look on the top right there.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "522d1d0dd17147f5abe0d2bce4c958f9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Batches:   0%|          | 0/134 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 4287 chunks in Chroma.\n"
     ]
    }
   ],
   "source": [
    "def embed_and_store(chunks):\n",
    "    \"\"\"\n",
    "    Create page_content, metadata, and ids and stores it in variables\n",
    "    Encodes the texts into vectors\n",
    "    Adds the vector into the chroma database\n",
    "    \"\"\"\n",
    "    texts = [chunk.page_content for chunk in chunks] # A list of all the text in chunks using dot notation\n",
    "    metadatas = [chunk.metadata for chunk in chunks] # Creates metadata for the week, day, and the source using dot notation\n",
    "    ids = [f\"{chunk.metadata['source']}_{i}\" for i, chunk in enumerate(chunks)] # Names each chunk with the file name and an index\n",
    "\n",
    "    # Turns the chunks into vectors through .encode\n",
    "    embeddings = embedder.encode(texts, show_progress_bar=True).tolist()\n",
    "    \n",
    "    # Adds the vectors into the chroma database with the following data\n",
    "    collection.add(\n",
    "        documents=texts,\n",
    "        embeddings=embeddings,\n",
    "        metadatas=metadatas,\n",
    "        ids=ids\n",
    "    )\n",
    "    print(f\"Stored {len(chunks)} chunks in Chroma.\")\n",
    "\n",
    "chunks = chunk_documents(documents)\n",
    "embed_and_store(chunks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b96b503b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b252ca2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# client = OpenAI()\n",
    "client = Groq()\n",
    "model = \"openai/gpt-oss-120b\"\n",
    "\n",
    "def generate_answer(query, chunks, history=[]):\n",
    "    context = \"\\n\\n\".join(chunk.page_content for chunk in chunks)\n",
    "    response = client.chat.completions.create(\n",
    "        model=model,\n",
    "        messages=[\n",
    "            {\"role\": \"system\", \"content\": f\"\"\"You are a helpful study assistant for an LLM engineering course. Answer the user's question using only the context provided. If the answer isn't in the context, say so. Context: {context}\"\"\"},\n",
    "      ] + history + [\n",
    "          {\"role\": \"user\", \"content\": query}\n",
    "        ]\n",
    "    )   \n",
    "    return response.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dab7da78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: Whats there to love about rag and whats not to love?\n",
      "Rewritten: pros and cons of Retrieval Augmented Generation (RAG)\n"
     ]
    }
   ],
   "source": [
    "def rewrite_query(query, history=[]):\n",
    "    \"\"\"\n",
    "    Calls the LLM to rewrite the query in a more clear and concise way\n",
    "    \"\"\"\n",
    "    response = client.chat.completions.create(\n",
    "        model=model,\n",
    "        messages=[\n",
    "            {\"role\": \"system\", \"content\": f\"\"\"You are a search query optimizer for a knowledge base of LLM engineering course transcripts.\n",
    "            Rewrite the user's question into a short, precise search query most likely to surface relevant content.\n",
    "            \n",
    "            This is the conversation history so far: {history}\n",
    "            \n",
    "            Respond ONLY with the rewritten query, nothing else.\"\"\"},\n",
    "            {\"role\": \"user\", \"content\": query}\n",
    "        ]\n",
    "    )   \n",
    "    return response.choices[0].message.content\n",
    "\n",
    "rewritten = rewrite_query(\"Whats there to love about rag and whats not to love?\")\n",
    "print(f\"Original: Whats there to love about rag and whats not to love?\")\n",
    "print(f\"Rewritten: {rewritten}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0824721e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_chunks(chunks1, chunks2):\n",
    "    merged = chunks1[:] # Everything from chunks1 which is a list of Chunk object\n",
    "    existing = [chunk.page_content for chunk in chunks1] # Put the page_content of each object into a list\n",
    "    \n",
    "    # Checks if any chunk from chunk2 exists within the existing chunks\n",
    "    for chunk in chunks2:\n",
    "        if chunk.page_content not in existing:\n",
    "            merged.append(chunk)\n",
    "    return merged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29434790",
   "metadata": {},
   "outputs": [],
   "source": "def rerank(query, chunks):\n    user_prompt = f\"The user has asked the following question:\\n\\n{query}\\n\\nRank all chunks by relevance, most relevant first.\\n\\n\"\n    \n    # Enumerates the chunk with an ID and the page_content to prepare the LLM to choose\n    for i, chunk in enumerate(chunks):\n        user_prompt += f\"# CHUNK ID: {i + 1}:\\n\\n{chunk.page_content}\\n\\n\"\n    user_prompt += \"Reply with ONLY the chunk IDs as comma-separated integers, most relevant first. Example: 3,1,4,2,5...\"\n\n    response = client.chat.completions.create(\n        model=model,\n        messages=[\n            {\"role\": \"system\", \"content\": \"You are a document re-ranker. Given a question and a list of chunks, return them ranked by relevance to the question, most relevant first. Respond in JSON format.\"},\n            {\"role\": \"user\", \"content\": user_prompt}\n        ],\n    )\n    order_str = response.choices[0].message.content.strip()\n    order = [int(x.strip()) for x in order_str.split(',') if x.strip().isdigit()] # Validates if order is a proper pydantic object and extracts the order list to a variable\n    print(f\"Total chunks sent to reranker: {len(chunks)}\")\n    print(f\"Order returned by LLM: {order}\")\n    return [chunks[i - 1] for i in order] # Reorders chunks by using the ranked IDs from the LLM, converting from 1-indexed to 0-indexed"
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c8aa4ef7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_context(query, n_results=20, history=[], final_k=10):\n",
    "      query_embedding = embedder.encode(query).tolist() # Convert the query into a vector and puts it in a list\n",
    "      results = collection.query(query_embeddings=[query_embedding], n_results=n_results) # Uses the list of vectors from query_embedding and gives n_results of similar vectors\n",
    "      chunks1 = [Chunk(page_content=doc, metadata=meta) for doc, meta in zip(results[\"documents\"][0], results[\"metadatas\"][0])] # Converts the chunk's page_content and metadata which was in a list, back into a Chunk object\n",
    "\n",
    "      rewritten = rewrite_query(query, history) # Rewrites the query into a concise way\n",
    "      rewritten_embedding = embedder.encode(rewritten).tolist() # Converts the rewritten query into a vector and puts it in a list\n",
    "      results2 = collection.query(query_embeddings=[rewritten_embedding], n_results=n_results) # Uses the list of vectors from rewritten_embedding and gives n_results of similar vectors\n",
    "      chunks2 = [Chunk(page_content=doc, metadata=meta) for doc, meta in zip(results2[\"documents\"][0], results2[\"metadatas\"][0])] # Converts the chunk's page_content and metadata which was in a list, back into a Chunk object\n",
    "\n",
    "      merged = merge_chunks(chunks1, chunks2) # Eliminates duplicates from the chunks\n",
    "      reranked = rerank(query, merged) # Ranks them in order from best to worst\n",
    "      return reranked[:final_k] # Gives the final_k best chunks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0e71d60",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_context_baseline(query, n_results=10):\n",
    "      \"\"\"\n",
    "      Baseline fetch_context to get a baseline score for evaluation\n",
    "      \"\"\"\n",
    "      query_embedding = embedder.encode(query).tolist()\n",
    "      results = collection.query(query_embeddings=[query_embedding], n_results=n_results)\n",
    "      return [Chunk(page_content=doc, metadata=meta) for doc, meta in zip(results[\"documents\"][0], results[\"metadatas\"][0])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8c2b233",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_context_crossencoder(query, n_results=20, final_k=10):\n",
    "      \"\"\"\n",
    "      A fetch_context for a cross encoder technique\n",
    "      \"\"\"\n",
    "      query_embedding = embedder.encode(query).tolist()\n",
    "      results = collection.query(query_embeddings=[query_embedding], n_results=n_results)\n",
    "      chunks1 = [Chunk(page_content=doc, metadata=meta)\n",
    "                 for doc, meta in zip(results[\"documents\"][0], results[\"metadatas\"][0])]\n",
    "\n",
    "      rewritten = rewrite_query(query)\n",
    "      rewritten_embedding = embedder.encode(rewritten).tolist()\n",
    "      results2 = collection.query(query_embeddings=[rewritten_embedding], n_results=n_results)\n",
    "      chunks2 = [Chunk(page_content=doc, metadata=meta) for doc, meta in zip(results2[\"documents\"][0], results2[\"metadatas\"][0])]\n",
    "\n",
    "      merged = merge_chunks(chunks1, chunks2) # All the merged Chunk objects\n",
    "      pairs = [[query, chunk.page_content] for chunk in merged] # pairs the query and each chunks page_content in their own list\n",
    "      scores = cross_encoder.predict(pairs) # Uses cross encoder to predict the pairs. Returns a list of Tensor objects which will be a rank\n",
    "      ranked = sorted(zip(scores, merged), key=lambda x: x[0], reverse=True) # Zips the score with the chunk as a tuple and sorted from highest to lowest\n",
    "      return [chunk for _, chunk in ranked[:final_k]]  # Returns final_k number of Chunk objects in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d40e77e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_context_hybrid(query, n_results=20, ce_k=15, final_k=10):\n",
    "      query_embedding = embedder.encode(query).tolist()\n",
    "      results = collection.query(query_embeddings=[query_embedding], n_results=n_results)\n",
    "      chunks1 = [Chunk(page_content=doc, metadata=meta)\n",
    "                 for doc, meta in zip(results[\"documents\"][0], results[\"metadatas\"][0])]\n",
    "                 \n",
    "      rewritten = rewrite_query(query)\n",
    "      rewritten_embedding = embedder.encode(rewritten).tolist()\n",
    "      results2 = collection.query(query_embeddings=[rewritten_embedding], n_results=n_results)\n",
    "      chunks2 = [Chunk(page_content=doc, metadata=meta)\n",
    "                 for doc, meta in zip(results2[\"documents\"][0], results2[\"metadatas\"][0])]\n",
    "\n",
    "      merged = merge_chunks(chunks1, chunks2) # All merged Chunk objects\n",
    "      pairs = [[query, chunk.page_content] for chunk in merged] # pairs the query and each chunks page_content in their own list\n",
    "      scores = cross_encoder.predict(pairs) # Uses cross encoder to predict the pairs. Returns a list of Tensor objects which will be a rank\n",
    "      ranked = sorted(zip(scores, merged), key=lambda x: x[0], reverse=True) # Zips the score with the chunk as a tuple and sorted from highest to lowest\n",
    "      ce_top = [chunk for _, chunk in ranked[:ce_k]]  # cross-encoder cuts pool to 15\n",
    "      return rerank(query, ce_top)[:final_k]           # # Returns final_k number of Chunk objects in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "7f31d7a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rewritten: pros and cons of retrieval augmented generation (RAG)\n",
      "\n",
      "Total chunks sent to reranker: 36\n",
      "Order returned by LLM: [5, 3, 14, 9, 1, 2, 18]\n",
      "--- Chunk 1 | transcripts/week5/day3.txt ---\n",
      "And we're going to really double down on this tomorrow.\n",
      "But but it's it's important to recognize that Rag is this very experimental, really quite hacky approach\n",
      "of trying to look up relevant context.\n",
      "And it can frequently go wrong.\n",
      "You can get good examples of rag working really, really well.\n",
      "Like it's surfacing that Maxine won the award.\n",
      "But you can also see that it didn't quite get her full name.\n",
      "It wasn't complete.\n",
      "\n",
      "--- Chunk 2 | transcripts/week5/day4.txt ---\n",
      "It's amazing.\n",
      "And everyone people love rag.\n",
      "People talk about it all the time is how is it going to be a naysayer now and come up with bad things?\n",
      "Well, here they are.\n",
      "The first thing is that rag is basically a big old hack Transformers we built, transformers.\n",
      "They have they have layers of the neural network which which are responsible for figuring out how to\n",
      "pay attention to what matters in the input.\n",
      "Uh, and that's what they're good at.\n",
      "And they've been trained.\n",
      "\n",
      "--- Chunk 3 | transcripts/week6/day2.txt ---\n",
      "to do something new, differently and better.\n",
      "Whereas something like rag generally is just about providing it information that already exists.\n",
      "It's about giving it expertise based on knowledge that you have in a knowledge base, but it won't help\n",
      "it to generalize beyond that knowledge base.\n",
      "If you're looking to add expertise, subject matter expertise knowledge to a model rag is your go to.\n",
      "If you're looking to teach a model a new skill, something it can generalize to new data it's never\n",
      "\n",
      "--- Chunk 4 | transcripts/week5/day4.txt ---\n",
      "And today we're going to do all of that.\n",
      "And then we're also, as a result of that, going to experiment with things like the chunking strategy\n",
      "and the encoder and see how it affects our evals.\n",
      "So I'd like to motivate evals by explaining what their is that what's great about rag.\n",
      "And then perhaps what's not so great about rag starting with what's great.\n",
      "Well of course first of all, it's so quick to get something out there.\n",
      "\n",
      "--- Chunk 5 | transcripts/week5/day4.txt ---\n",
      "We just select the part that matters.\n",
      "And then a very similar point is that it avoids us polluting the context with lots of information that's\n",
      "irrelevant, not needed.\n",
      "To answer this question, we can focus the context window on the most relevant information for the LLM\n",
      "to answer this exact question.\n",
      "Now I know what you're thinking.\n",
      "You're thinking, this all sounds great.\n",
      "What's there not to love about rag?\n",
      "It's amazing.\n",
      "And everyone people love rag.\n",
      "\n",
      "--- Chunk 6 | transcripts/week5/day4.txt ---\n",
      "more rigorous, but rather it's a kind of shortcut to try and get the relevant context.\n",
      "And my last point is, is really the same again.\n",
      "But but just to say that the tyranny of rag is that ultimately what matters is what are the answers\n",
      "to your questions, and it doesn't always end up the way you think.\n",
      "Often with Rag, I've had this idea about a way to do something, and I've been like, that is a fantastic\n",
      "\n",
      "--- Chunk 7 | transcripts/week5/day5.txt ---\n",
      "But but very much keep in mind that it is still in large part carrying out many of the previous steps\n",
      "on this list, just doing it through tool calling rather than through R code orchestrating step by step.\n",
      "Finally, I will end this slide.\n",
      "I know I've been on this slide for 20 minutes.\n",
      "I'm going to end this by saying a lot of people are saying that rag is dead.\n",
      "You hear that a lot.\n",
      "You see lots of memes on this.\n",
      "And there's typically two different reasons for this.\n",
      "\n",
      "=== Answer ===\n",
      "**What’s good about RAG (the “love” side)**  \n",
      "\n",
      "1. **Speed to prototype** – You can get a working system up very quickly by simply pulling in the pieces of text that matter, instead of waiting for a model to learn everything from scratch.  \n",
      "2. **Focused context** – RAG lets you trim the LLM’s context window to the most relevant information, so the model isn’t “polluted” with a lot of unrelated data.  \n",
      "3. **Easy way to add expertise** – If you have a knowledge base (e.g., product manuals, research papers, award announcements), RAG is a straightforward way to inject that subject‑matter knowledge into a model.  \n",
      "4. **Resource‑efficient** – Because you only feed the LLM the selected chunks, you use less compute and can stay within the model’s context‑length limits.  \n",
      "\n",
      "**What’s not so great about RAG (the “don’t love” side)**  \n",
      "\n",
      "1. **Hacky & experimental** – RAG is described as a “big old hack” on top of Transformers. It works but it’s not a clean, principled solution, so failures are common.  \n",
      "2. **Can return incomplete or inaccurate results** – The example of surfacing “Maxine won the award” but missing her full name shows that the retrieved chunk may be only partially correct.  \n",
      "3. **No real generalization** – RAG merely surfaces existing knowledge; it doesn’t teach the model new skills or let it reason beyond the contents of the knowledge base.  \n",
      "4. **Unpredictable answer quality** – The “tyranny of RAG” is that the final answer depends heavily on what chunks are retrieved, and the output can end up different from what you expected.  \n",
      "5. **Perception of being “dead”** – Because of these drawbacks, many people joke that RAG is dead, and memes about its limitations circulate in the community.  \n",
      "\n",
      "So, RAG is loved for its speed, relevance‑focused context, and ease of adding domain knowledge, but it’s criticized for being a hacky, brittle approach that can produce incomplete or surprising results and doesn’t give the model true generalization ability.\n"
     ]
    }
   ],
   "source": [
    "query = \"Whats there to love about rag and whats not to love?\"\n",
    "\n",
    "rewritten = rewrite_query(query)\n",
    "print(f\"Rewritten: {rewritten}\\n\")\n",
    "\n",
    "chunks = fetch_context(query)\n",
    "\n",
    "for i, chunk in enumerate(chunks):\n",
    "    print(f\"--- Chunk {i+1} | {chunk.metadata['source']} ---\")\n",
    "    print(chunk.page_content)\n",
    "    print()\n",
    "\n",
    "answer = generate_answer(query, chunks)\n",
    "print(\"=== Answer ===\")\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f97bd8bf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}