Add rag1.ipynb

rag1.ipynb

@@ -0,0 +1,885 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "12a9fcb2",
+      "metadata": {},
+      "source": [
+        "### Step 1: Load 2 text PDFs"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 91,
+      "id": "e322de88",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Note: you may need to restart the kernel to use updated packages.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 0 (Setup): Install required packages (run once per environment)\n",
+        "%pip install -q langchain langchain-classic langchain-community langchain-openai langchain-text-splitters langchain-huggingface langchain-chroma chromadb sentence-transformers python-dotenv rank-bm25 gradio pypdf"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 92,
+      "id": "24647d78",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Number of documents loaded: 1201\n",
+            "\n",
+            "Sample of first document content:\n",
+            "\n",
+            "Chip Huyen\n",
+            " AI Engineering\n",
+            "Building Applications  \n",
+            "with Foundation Models\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 1 (Load): Load two text-based PDFs into LangChain Documents\n",
+        "\n",
+        "from langchain_community.document_loaders import PyPDFLoader\n",
+        "\n",
+        "# Define the PDF file paths (assumed to be in the current working directory)\n",
+        "pdf_paths = [\"textbook_1.pdf\", \"textbook_2.pdf\"]\n",
+        "\n",
+        "# Load each PDF into a list of Document objects (typically one Document per page)\n",
+        "all_documents = []\n",
+        "for path in pdf_paths:\n",
+        "    loader = PyPDFLoader(path)\n",
+        "    docs = loader.load()\n",
+        "    all_documents.extend(docs)\n",
+        "\n",
+        "# Print assignment-required outputs\n",
+        "print(f\"Number of documents loaded: {len(all_documents)}\")\n",
+        "\n",
+        "# Print a sample from the first loaded document (first 700 characters)\n",
+        "if all_documents:\n",
+        "    sample_text = all_documents[0].page_content[:700]\n",
+        "    print(\"\\nSample of first document content:\\n\")\n",
+        "    print(sample_text)\n",
+        "else:\n",
+        "    print(\"\\nNo documents were loaded.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 93,
+      "id": "490ed688",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Configuration: chunk_size=500, chunk_overlap=100\n",
+            "Total number of chunks created: 4979\n",
+            "Character count of the smallest chunk: 2\n",
+            "Character count of the largest chunk: 500\n",
+            "Sample metadata from first chunk: {'source': 'textbook_1.pdf', 'date': '2023-01-01', 'section': 'pages_1_20'}\n",
+            "------------------------------------------------------------\n",
+            "Configuration: chunk_size=1000, chunk_overlap=150\n",
+            "Total number of chunks created: 2571\n",
+            "Character count of the smallest chunk: 2\n",
+            "Character count of the largest chunk: 1000\n",
+            "Sample metadata from first chunk: {'source': 'textbook_1.pdf', 'date': '2023-01-01', 'section': 'pages_1_20'}\n",
+            "------------------------------------------------------------\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 2 (Chunk): Split loaded documents into chunks with two configurations + metadata\n",
+        "import os\n",
+        "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+        "\n",
+        "# Prefer the full Step 1 output, but support `docs` if that's your loaded list name\n",
+        "if \"all_documents\" in globals() and all_documents:\n",
+        "    source_docs = all_documents\n",
+        "elif \"docs\" in globals() and docs:\n",
+        "    source_docs = docs\n",
+        "else:\n",
+        "    source_docs = []\n",
+        "\n",
+        "# Map each textbook to a date tag (adjust these to your real document dates if available)\n",
+        "source_date_map = {\n",
+        "    \"textbook_1.pdf\": \"2023-01-01\",\n",
+        "    \"textbook_2.pdf\": \"2024-01-01\",\n",
+        "}\n",
+        "\n",
+        "# Add metadata fields requested for filtered retrieval\n",
+        "# - source: source file name\n",
+        "# - date: date tag per source document\n",
+        "# - section: derived from page number bucket (chapter/section proxy)\n",
+        "def enrich_chunk_metadata(chunks):\n",
+        "    for chunk in chunks:\n",
+        "        src_path = chunk.metadata.get(\"source\", \"\")\n",
+        "        source_file = os.path.basename(src_path) if src_path else \"unknown_source\"\n",
+        "        page_num = int(chunk.metadata.get(\"page\", -1)) + 1\n",
+        "\n",
+        "        if page_num <= 0:\n",
+        "            section = \"unknown_section\"\n",
+        "        else:\n",
+        "            section_start = ((page_num - 1) // 20) * 20 + 1\n",
+        "            section_end = section_start + 19\n",
+        "            section = f\"pages_{section_start}_{section_end}\"\n",
+        "\n",
+        "        chunk.metadata[\"source\"] = source_file\n",
+        "        chunk.metadata[\"date\"] = source_date_map.get(source_file, \"unknown_date\")\n",
+        "        chunk.metadata[\"section\"] = section\n",
+        "    return chunks\n",
+        "\n",
+        "# Helper to split documents and print assignment-required chunk statistics\n",
+        "def chunk_and_report(documents, chunk_size, chunk_overlap):\n",
+        "    splitter = RecursiveCharacterTextSplitter(\n",
+        "        chunk_size=chunk_size,\n",
+        "        chunk_overlap=chunk_overlap,\n",
+        "    )\n",
+        "    chunks = splitter.split_documents(documents)\n",
+        "    chunks = enrich_chunk_metadata(chunks)\n",
+        "\n",
+        "    chunk_lengths = [len(chunk.page_content) for chunk in chunks]\n",
+        "    min_len = min(chunk_lengths) if chunk_lengths else 0\n",
+        "    max_len = max(chunk_lengths) if chunk_lengths else 0\n",
+        "\n",
+        "    print(f\"Configuration: chunk_size={chunk_size}, chunk_overlap={chunk_overlap}\")\n",
+        "    print(f\"Total number of chunks created: {len(chunks)}\")\n",
+        "    print(f\"Character count of the smallest chunk: {min_len}\")\n",
+        "    print(f\"Character count of the largest chunk: {max_len}\")\n",
+        "\n",
+        "    if chunks:\n",
+        "        sample_meta = {k: chunks[0].metadata.get(k) for k in [\"source\", \"date\", \"section\"]}\n",
+        "        print(f\"Sample metadata from first chunk: {sample_meta}\")\n",
+        "\n",
+        "    print(\"-\" * 60)\n",
+        "    return chunks\n",
+        "\n",
+        "# First required configuration\n",
+        "chunks_500_100 = chunk_and_report(source_docs, chunk_size=500, chunk_overlap=100)\n",
+        "\n",
+        "# Second required configuration\n",
+        "chunks_1000_150 = chunk_and_report(source_docs, chunk_size=1000, chunk_overlap=150)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 94,
+      "id": "bdc95c2f",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading weights: 100%|██████████| 103/103 [00:00<00:00, 6986.89it/s]\n",
+            "\u001b[1mBertModel LOAD REPORT\u001b[0m from: sentence-transformers/all-MiniLM-L6-v2\n",
+            "Key                     | Status     |  | \n",
+            "------------------------+------------+--+-\n",
+            "embeddings.position_ids | UNEXPECTED |  | \n",
+            "\n",
+            "Notes:\n",
+            "- UNEXPECTED:\tcan be ignored when loading from different task/architecture; not ok if you expect identical arch.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Number of vectors stored: 4979\n",
+            "Sample embedding shape: 384\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 3 (Embed + Store): Embed 500-size chunks and persist them in ChromaDB\n",
+        "import os\n",
+        "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+        "from langchain_community.vectorstores import Chroma\n",
+        "\n",
+        "# Use the smaller chunk set from Step 2\n",
+        "if \"chunks_500_100\" not in globals() or not chunks_500_100:\n",
+        "    raise ValueError(\"`chunks_500_100` is missing. Run Step 2 first.\")\n",
+        "\n",
+        "# Initialize embedding model\n",
+        "embedding_model = HuggingFaceEmbeddings(\n",
+        "    model_name=\"sentence-transformers/all-MiniLM-L6-v2\"\n",
+        ")\n",
+        "\n",
+        "# Create persistent ChromaDB directory\n",
+        "persist_dir = \"./chroma_db\"\n",
+        "os.makedirs(persist_dir, exist_ok=True)\n",
+        "\n",
+        "# Recreate the collection each run to avoid duplicate vectors from repeated executions\n",
+        "try:\n",
+        "    existing_store = Chroma(\n",
+        "        collection_name=\"textbook_rag\",\n",
+        "        embedding_function=embedding_model,\n",
+        "        persist_directory=persist_dir,\n",
+        "    )\n",
+        "    existing_store.delete_collection()\n",
+        "except Exception:\n",
+        "    pass\n",
+        "\n",
+        "vectorstore = Chroma.from_documents(\n",
+        "    documents=chunks_500_100,\n",
+        "    embedding=embedding_model,\n",
+        "    collection_name=\"textbook_rag\",\n",
+        "    persist_directory=persist_dir,\n",
+        ")\n",
+        "\n",
+        "# Print assignment-required stats\n",
+        "num_vectors = vectorstore._collection.count()\n",
+        "sample_embedding = embedding_model.embed_query(\"sample text\")\n",
+        "\n",
+        "print(f\"Number of vectors stored: {num_vectors}\")\n",
+        "print(f\"Sample embedding shape: {len(sample_embedding)}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 95,
+      "id": "d659b193",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading weights: 100%|██████████| 103/103 [00:00<00:00, 7916.97it/s]\n",
+            "\u001b[1mBertModel LOAD REPORT\u001b[0m from: sentence-transformers/all-MiniLM-L6-v2\n",
+            "Key                     | Status     |  | \n",
+            "------------------------+------------+--+-\n",
+            "embeddings.position_ids | UNEXPECTED |  | \n",
+            "\n",
+            "Notes:\n",
+            "- UNEXPECTED:\tcan be ignored when loading from different task/architecture; not ok if you expect identical arch.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "==========================================================================================\n",
+            "Query: What is the definition of X?\n",
+            "\n",
+            "Result 1 (trimmed):\n",
+            "3 While I love writing, one of the things I absolutely do not enjoy is trying to condense everyone’s opinions into\n",
+            "one single definition. IBM defined data quality along seven dimensions: completeness, uniqueness, validity,\n",
+            "timeliness, accuracy, consistency, and fitness for purpose. Wikipedia added a...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 2 (trimmed):\n",
+            "Your goal is to predict what someone with 10 years of\n",
+            "experience should earn. In this example, x = 10, and you want\n",
+            "to predict what y should be.\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 3 (trimmed):\n",
+            "a 5% chance that the point corresponds to class 1. But if x =\n",
+            "10, there is about a 76% chance that it’s class 1. If asked\n",
+            "to classify that point as a red or a blue, you would conclude\n",
+            "that it’s a red because it’s much more likely to be red\n",
+            "than blue.\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "==========================================================================================\n",
+            "Query: Explain concept Y.\n",
+            "\n",
+            "Result 1 (trimmed):\n",
+            "Another instance of the model (Bob) asks Alice a series of questions to try to identify\n",
+            "this concept. Alice can only answer yes or no. The score is based on whether Bob suc‐\n",
+            "cessfully guesses the concept, and how many questions it takes for Bob to guess it.\n",
+            "Here’s an example of a plausible conversat...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 2 (trimmed):\n",
+            "neural network layers to tease more meaning from it before\n",
+            "subjecting it to further processing.\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 3 (trimmed):\n",
+            "finding patterns in numbers and exploiting those patterns to\n",
+            "make predictions. ML makes it possible to train a model with\n",
+            "rows or sequences of 1s and 0s, and to learn  from the data so\n",
+            "that, given a new sequence, the model can predict what the\n",
+            "result will be. Learning  is the process by which ML fin...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "==========================================================================================\n",
+            "Query: How does Z work?\n",
+            "\n",
+            "Result 1 (trimmed):\n",
+            "separable in n dimensions. Here’s a quick example.\n",
+            "The classes in the two-dimensional dataset on the left in\n",
+            "Figure 2-10 can’t be separated with a line. But if you add\n",
+            "a third dimension so that points closer to the center have\n",
+            "higher z values and points farther from the center have lower\n",
+            "z values, a...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 2 (trimmed):\n",
+            "Figure 10-9. The yellow arrow allows the generated response to be fed back into the sys‐\n",
+            "tem, allowing more complex application patterns.\n",
+            "A model’s outputs also can be used to invoke write actions, such as composing an\n",
+            "email, placing an order, or initializing a bank transfer. Write actions allow a s...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Result 3 (trimmed):\n",
+            "mechanism. Understanding this mechanism is necessary to understand how trans‐\n",
+            "former models work. Under the hood, the attention mechanism leverages key, value,\n",
+            "and query vectors:\n",
+            "• The query vector (Q) represents the current state of the decoder at each decoding\n",
+            "step. Using the same book summary exa...\n",
+            "Relevant: No — because there is no clear keyword overlap with the query.\n",
+            "\n",
+            "Retrieval test complete. (No LLM calls, no RAG chain built.)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 4 (Test Retrieval): Query existing ChromaDB before building a RAG chain\n",
+        "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+        "from langchain_community.vectorstores import Chroma\n",
+        "\n",
+        "# Reconnect to the same embedding model and persisted Chroma collection\n",
+        "embedding_model = HuggingFaceEmbeddings(\n",
+        "    model_name=\"sentence-transformers/all-MiniLM-L6-v2\"\n",
+        ")\n",
+        "\n",
+        "vectorstore = Chroma(\n",
+        "    collection_name=\"textbook_rag\",\n",
+        "    embedding_function=embedding_model,\n",
+        "    persist_directory=\"./chroma_db\",\n",
+        ")\n",
+        "\n",
+        "# Placeholder test queries (replace with your assignment-specific questions later)\n",
+        "test_queries = [\n",
+        "    \"What is the definition of X?\",\n",
+        "    \"Explain concept Y.\",\n",
+        "    \"How does Z work?\",\n",
+        "]\n",
+        "\n",
+        "# Helper for a simple relevance note based on keyword overlap\n",
+        "stop_words = {\"what\", \"is\", \"the\", \"of\", \"explain\", \"how\", \"does\", \"work\", \"concept\", \"definition\"}\n",
+        "\n",
+        "def relevance_note(query, chunk_text):\n",
+        "    query_terms = {w.lower().strip(\".,?!:;()[]{}\\\"'\") for w in query.split()}\n",
+        "    query_terms = {w for w in query_terms if w and w not in stop_words and len(w) > 1}\n",
+        "    chunk_lower = chunk_text.lower()\n",
+        "\n",
+        "    matches = [term for term in query_terms if term in chunk_lower]\n",
+        "    if matches:\n",
+        "        return f\"Relevant: Yes — because it contains query term(s): {', '.join(matches)}\"\n",
+        "    return \"Relevant: No — because there is no clear keyword overlap with the query.\"\n",
+        "\n",
+        "# Run top-3 similarity retrieval for each query and print readable output\n",
+        "for query in test_queries:\n",
+        "    print(\"=\" * 90)\n",
+        "    print(f\"Query: {query}\")\n",
+        "\n",
+        "    results = vectorstore.similarity_search(query, k=3)\n",
+        "    for i, doc in enumerate(results, start=1):\n",
+        "        chunk_text = doc.page_content.strip()\n",
+        "        preview = (chunk_text[:300] + \"...\") if len(chunk_text) > 300 else chunk_text\n",
+        "\n",
+        "        print(f\"\\nResult {i} (trimmed):\")\n",
+        "        print(preview)\n",
+        "        print(relevance_note(query, chunk_text))\n",
+        "\n",
+        "print(\"\\nRetrieval test complete. (No LLM calls, no RAG chain built.)\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 96,
+      "id": "fe1ef0a6",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading weights: 100%|██████████| 103/103 [00:00<00:00, 2939.85it/s]\n",
+            "\u001b[1mBertModel LOAD REPORT\u001b[0m from: sentence-transformers/all-MiniLM-L6-v2\n",
+            "Key                     | Status     |  | \n",
+            "------------------------+------------+--+-\n",
+            "embeddings.position_ids | UNEXPECTED |  | \n",
+            "\n",
+            "Notes:\n",
+            "- UNEXPECTED:\tcan be ignored when loading from different task/architecture; not ok if you expect identical arch.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Active metadata filter: None\n",
+            "BM25 candidate docs after filtering: 4979\n",
+            "Hybrid retrieval check (vector vs ensemble top-3 overlap):\n",
+            "- Query: 'What is the definition of X?' | overlap=3/3\n",
+            "- Query: 'Explain concept Y.' | overlap=3/3\n",
+            "- Query: 'How does Z work?' | overlap=3/3\n",
+            "------------------------------------------------------------------------------------------\n",
+            "Query: What is the definition of X?\n",
+            "Answer: I don't know based on the provided context.\n",
+            "------------------------------------------------------------------------------------------\n",
+            "Query: Explain concept Y.\n",
+            "Answer: I don't know based on the provided context.\n",
+            "------------------------------------------------------------------------------------------\n",
+            "Query: How does Z work?\n",
+            "Answer: I don't know based on the provided context.\n",
+            "------------------------------------------------------------------------------------------\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 5 (Build RAG Chain): Hybrid retrieval + metadata-filtered retrieval + RetrievalQA\n",
+        "import os\n",
+        "from pathlib import Path\n",
+        "from dotenv import load_dotenv\n",
+        "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+        "from langchain_community.vectorstores import Chroma\n",
+        "from langchain_community.retrievers import BM25Retriever\n",
+        "from langchain_openai import ChatOpenAI\n",
+        "\n",
+        "# EnsembleRetriever location differs across LangChain packaging layouts\n",
+        "try:\n",
+        "    from langchain.retrievers import EnsembleRetriever\n",
+        "except ModuleNotFoundError:\n",
+        "    from langchain_classic.retrievers import EnsembleRetriever\n",
+        "\n",
+        "# Compatibility imports for different LangChain package layouts\n",
+        "try:\n",
+        "    from langchain.chains import RetrievalQA\n",
+        "    from langchain.prompts import ChatPromptTemplate\n",
+        "except ModuleNotFoundError:\n",
+        "    from langchain_classic.chains import RetrievalQA\n",
+        "    from langchain_core.prompts import ChatPromptTemplate\n",
+        "\n",
+        "# Load environment variables from .env (works in notebooks even when cwd differs)\n",
+        "load_dotenv()\n",
+        "project_env = Path.cwd() / \".env\"\n",
+        "if project_env.exists():\n",
+        "    load_dotenv(project_env, override=False)\n",
+        "\n",
+        "# Reconnect to the same embedding model and persisted Chroma collection from Step 3\n",
+        "embedding_model = HuggingFaceEmbeddings(\n",
+        "    model_name=\"sentence-transformers/all-MiniLM-L6-v2\"\n",
+        ")\n",
+        "vectorstore = Chroma(\n",
+        "    collection_name=\"textbook_rag\",\n",
+        "    embedding_function=embedding_model,\n",
+        "    persist_directory=\"./chroma_db\",\n",
+        ")\n",
+        "\n",
+        "# Use Step 2 chunks for BM25 and metadata filtering\n",
+        "if \"chunks_500_100\" not in globals() or not chunks_500_100:\n",
+        "    raise ValueError(\"Run Step 2 first so `chunks_500_100` exists.\")\n",
+        "\n",
+        "# Optional metadata filters for retrieval. Set to None to disable a filter.\n",
+        "active_filters = {\n",
+        "    \"source\": None,              # Example: \"textbook_1.pdf\"\n",
+        "    \"section\": None,             # Example: \"pages_1_20\"\n",
+        "    \"date\": None,                # Example: \"2023-01-01\"\n",
+        "}\n",
+        "\n",
+        "# Build a Chroma filter dict from enabled filters\n",
+        "def build_chroma_filter(filters):\n",
+        "    return {k: v for k, v in filters.items() if v is not None}\n",
+        "\n",
+        "# Apply filters to in-memory chunks (used by BM25)\n",
+        "def filter_documents_by_metadata(documents, filters):\n",
+        "    filtered = []\n",
+        "    for d in documents:\n",
+        "        keep = True\n",
+        "        for k, v in filters.items():\n",
+        "            if v is not None and d.metadata.get(k) != v:\n",
+        "                keep = False\n",
+        "                break\n",
+        "        if keep:\n",
+        "            filtered.append(d)\n",
+        "    return filtered\n",
+        "\n",
+        "active_filter_dict = build_chroma_filter(active_filters)\n",
+        "filtered_docs_for_bm25 = filter_documents_by_metadata(chunks_500_100, active_filters)\n",
+        "\n",
+        "if not filtered_docs_for_bm25:\n",
+        "    raise ValueError(\"Metadata filters returned 0 docs. Relax `active_filters` and rerun Step 5.\")\n",
+        "\n",
+        "# Vector retriever with metadata filtering\n",
+        "vector_search_kwargs = {\"k\": 3}\n",
+        "if active_filter_dict:\n",
+        "    vector_search_kwargs[\"filter\"] = active_filter_dict\n",
+        "\n",
+        "retriever_vector = vectorstore.as_retriever(\n",
+        "    search_type=\"similarity\",\n",
+        "    search_kwargs=vector_search_kwargs,\n",
+        ")\n",
+        "\n",
+        "# BM25 retriever on the same filtered subset\n",
+        "retriever_bm25 = BM25Retriever.from_documents(filtered_docs_for_bm25)\n",
+        "retriever_bm25.k = 3\n",
+        "\n",
+        "# Combine retrievers: tune weights for more keyword vs semantic influence\n",
+        "retriever = EnsembleRetriever(\n",
+        "    retrievers=[retriever_vector, retriever_bm25],\n",
+        "    weights=[0.5, 0.5],\n",
+        ")\n",
+        "\n",
+        "# Quick retrieval comparison on Step 4 queries\n",
+        "queries_compare = test_queries if \"test_queries\" in globals() else [\n",
+        "    \"What is the definition of X?\",\n",
+        "    \"Explain concept Y.\",\n",
+        "    \"How does Z work?\",\n",
+        "]\n",
+        "\n",
+        "def _doc_fingerprint(doc):\n",
+        "    return hash((doc.page_content or \"\").strip())\n",
+        "\n",
+        "print(f\"Active metadata filter: {active_filter_dict if active_filter_dict else 'None'}\")\n",
+        "print(f\"BM25 candidate docs after filtering: {len(filtered_docs_for_bm25)}\")\n",
+        "print(\"Hybrid retrieval check (vector vs ensemble top-3 overlap):\")\n",
+        "for q in queries_compare:\n",
+        "    v_docs = retriever_vector.invoke(q)\n",
+        "    h_docs = retriever.invoke(q)\n",
+        "    v_fps = {_doc_fingerprint(d) for d in v_docs}\n",
+        "    h_fps = {_doc_fingerprint(d) for d in h_docs}\n",
+        "    overlap = len(v_fps & h_fps)\n",
+        "    print(f\"- Query: {q!r} | overlap={overlap}/3\")\n",
+        "print(\"-\" * 90)\n",
+        "\n",
+        "# Define a chat prompt with an explicit system message\n",
+        "custom_prompt = ChatPromptTemplate.from_messages([\n",
+        "    (\n",
+        "        \"system\",\n",
+        "        \"You are a warm, friendly, and helpful assistant. \"\n",
+        "        \"If the user message is only a greeting (like hi, hey, or hello), respond with a short friendly greeting and ask how you can help. \"\n",
+        "        \"For non-greeting questions, use ONLY the provided context. \"\n",
+        "        \"If the answer is not in the context, say: 'I don't know based on the provided context.'\",\n",
+        "    ),\n",
+        "    (\n",
+        "        \"human\",\n",
+        "        \"CONTEXT:\\nThe information in the two PDF documents textbook_1.pdf and textbook_2.pdf.\\n{context}\\n\\n\"\n",
+        "        \"QUESTION:\\n{question}\\n\\nANSWER:\",\n",
+        "    ),\n",
+        "])\n",
+        "\n",
+        "# Initialize LLM after loading .env\n",
+        "if not os.getenv(\"OPENAI_API_KEY\"):\n",
+        "    raise EnvironmentError(\"OPENAI_API_KEY is not set. Confirm .env is in the notebook working directory and restart/re-run this cell.\")\n",
+        "\n",
+        "llm = ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0.7)\n",
+        "\n",
+        "# Build RetrievalQA chain using 'stuff' strategy and custom prompt\n",
+        "qa_chain = RetrievalQA.from_chain_type(\n",
+        "    llm=llm,\n",
+        "    chain_type=\"stuff\",\n",
+        "    retriever=retriever,\n",
+        "    return_source_documents=False,\n",
+        "    chain_type_kwargs={\"prompt\": custom_prompt},\n",
+        ")\n",
+        "\n",
+        "# Reuse Step 4 queries when available; otherwise default placeholders\n",
+        "queries = queries_compare\n",
+        "\n",
+        "# Run the same 3 queries and print answers cleanly\n",
+        "for query in queries:\n",
+        "    result = qa_chain.invoke({\"query\": query})\n",
+        "    answer = result[\"result\"] if isinstance(result, dict) else str(result)\n",
+        "\n",
+        "    print(f\"Query: {query}\")\n",
+        "    print(f\"Answer: {answer}\")\n",
+        "    print(\"-\" * 90)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 97,
+      "id": "e676144f",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "==============================================================================================================\n",
+            "Step 6 Evaluation Results\n",
+            "==============================================================================================================\n",
+            "\n",
+            "Q1: What is concept A?\n",
+            "Retrieved relevant chunks: Yes\n",
+            "Answer grounded in context: No\n",
+            "Answer correct: No\n",
+            "Generated answer: I don't know based on the provided context.\n",
+            "--------------------------------------------------------------------------------------------------------------\n",
+            "\n",
+            "Q2: How does method B work?\n",
+            "Retrieved relevant chunks: Yes\n",
+            "Answer grounded in context: Yes\n",
+            "Answer correct: No\n",
+            "Generated answer: I don't know based on the provided context.\n",
+            "--------------------------------------------------------------------------------------------------------------\n",
+            "\n",
+            "Q3: Define term C.\n",
+            "Retrieved relevant chunks: Yes\n",
+            "Answer grounded in context: Yes\n",
+            "Answer correct: No\n",
+            "Generated answer: The term C in the given context refers to a parameter that controls how aggressively a model fits to the training data in machine learning algorithms.\n",
+            "--------------------------------------------------------------------------------------------------------------\n",
+            "\n",
+            "Q4: What is the purpose of D?\n",
+            "Retrieved relevant chunks: Yes\n",
+            "Answer grounded in context: No\n",
+            "Answer correct: No\n",
+            "Generated answer: I don't know based on the provided context.\n",
+            "--------------------------------------------------------------------------------------------------------------\n",
+            "\n",
+            "Q5: Explain relationship between E and F.\n",
+            "Retrieved relevant chunks: Yes\n",
+            "Answer grounded in context: No\n",
+            "Answer correct: No\n",
+            "Generated answer: I don't know based on the provided context.\n",
+            "--------------------------------------------------------------------------------------------------------------\n",
+            "Retrieval accuracy: 5/5\n",
+            "Faithfulness accuracy: 2/5\n",
+            "Correctness accuracy: 0/5\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Step 6 (Evaluation): Evaluate retrieval relevance, grounding, and answer correctness\n",
+        "\n",
+        "# Ensure Step 5 objects exist\n",
+        "if \"retriever\" not in globals() or \"qa_chain\" not in globals():\n",
+        "    raise ValueError(\"Run Step 5 first so `retriever` and `qa_chain` are available.\")\n",
+        "\n",
+        "# Small evaluation set (replace placeholders with your real questions/answers)\n",
+        "eval_set = [\n",
+        "    {\n",
+        "        \"question\": \"What is concept A?\",\n",
+        "        \"gold_answer\": \"[Replace with known correct answer for concept A]\",\n",
+        "        \"reference_keywords\": [\"concept\", \"a\"],\n",
+        "    },\n",
+        "    {\n",
+        "        \"question\": \"How does method B work?\",\n",
+        "        \"gold_answer\": \"[Replace with known correct answer for method B]\",\n",
+        "        \"reference_keywords\": [\"method\", \"b\"],\n",
+        "    },\n",
+        "    {\n",
+        "        \"question\": \"Define term C.\",\n",
+        "        \"gold_answer\": \"[Replace with known correct definition for term C]\",\n",
+        "        \"reference_keywords\": [\"term\", \"c\", \"define\"],\n",
+        "    },\n",
+        "    {\n",
+        "        \"question\": \"What is the purpose of D?\",\n",
+        "        \"gold_answer\": \"[Replace with known purpose of D]\",\n",
+        "        \"reference_keywords\": [\"purpose\", \"d\"],\n",
+        "    },\n",
+        "    {\n",
+        "        \"question\": \"Explain relationship between E and F.\",\n",
+        "        \"gold_answer\": \"[Replace with known relationship between E and F]\",\n",
+        "        \"reference_keywords\": [\"relationship\", \"e\", \"f\"],\n",
+        "    },\n",
+        "]\n",
+        "\n",
+        "# Lightweight helper to normalize text for simple heuristic checks\n",
+        "def normalize(text):\n",
+        "    return \" \".join(text.lower().split())\n",
+        "\n",
+        "results = []\n",
+        "retrieval_hits = 0\n",
+        "faithfulness_hits = 0\n",
+        "correctness_hits = 0\n",
+        "\n",
+        "# Evaluate each question: retriever-only first, then full RAG chain\n",
+        "for item in eval_set:\n",
+        "    question = item[\"question\"]\n",
+        "    gold_answer = item[\"gold_answer\"]\n",
+        "    keywords = [k.lower() for k in item[\"reference_keywords\"]]\n",
+        "\n",
+        "    # 1) Retriever-only pass\n",
+        "    retrieved_docs = retriever.invoke(question)\n",
+        "    retrieved_text = \"\\n\\n\".join(doc.page_content for doc in retrieved_docs)\n",
+        "    retrieved_text_norm = normalize(retrieved_text)\n",
+        "\n",
+        "    retrieval_relevant = any(k in retrieved_text_norm for k in keywords)\n",
+        "    retrieval_hits += int(retrieval_relevant)\n",
+        "\n",
+        "    # 2) Full RAG chain pass\n",
+        "    rag_output = qa_chain.invoke({\"query\": question})\n",
+        "    answer = rag_output[\"result\"] if isinstance(rag_output, dict) else str(rag_output)\n",
+        "    answer_norm = normalize(answer)\n",
+        "\n",
+        "    # 3a) Faithfulness (grounded): answer terms should appear in retrieved context\n",
+        "    answer_tokens = [t for t in answer_norm.replace(\".\", \" \").replace(\",\", \" \").split() if len(t) > 3]\n",
+        "    overlap_count = sum(1 for t in set(answer_tokens) if t in retrieved_text_norm)\n",
+        "    grounded_in_context = overlap_count >= max(1, min(3, len(set(answer_tokens)) // 5 + 1))\n",
+        "    faithfulness_hits += int(grounded_in_context)\n",
+        "\n",
+        "    # 3b) Correctness: heuristic check against user-known answer placeholder\n",
+        "    # Replace this logic later with your own strict grading based on real expected answers.\n",
+        "    if gold_answer.startswith(\"[Replace with\"):\n",
+        "        answer_correct = False\n",
+        "    else:\n",
+        "        gold_norm = normalize(gold_answer)\n",
+        "        answer_correct = gold_norm in answer_norm or answer_norm in gold_norm\n",
+        "    correctness_hits += int(answer_correct)\n",
+        "\n",
+        "    results.append(\n",
+        "        {\n",
+        "            \"question\": question,\n",
+        "            \"retrieval_relevant\": retrieval_relevant,\n",
+        "            \"grounded_in_context\": grounded_in_context,\n",
+        "            \"answer_correct\": answer_correct,\n",
+        "            \"answer\": answer,\n",
+        "        }\n",
+        "    )\n",
+        "\n",
+        "# Print structured evaluation output\n",
+        "print(\"=\" * 110)\n",
+        "print(\"Step 6 Evaluation Results\")\n",
+        "print(\"=\" * 110)\n",
+        "for idx, row in enumerate(results, start=1):\n",
+        "    print(f\"\\nQ{idx}: {row['question']}\")\n",
+        "    print(f\"Retrieved relevant chunks: {'Yes' if row['retrieval_relevant'] else 'No'}\")\n",
+        "    print(f\"Answer grounded in context: {'Yes' if row['grounded_in_context'] else 'No'}\")\n",
+        "    print(f\"Answer correct: {'Yes' if row['answer_correct'] else 'No'}\")\n",
+        "    print(f\"Generated answer: {row['answer']}\")\n",
+        "    print(\"-\" * 110)\n",
+        "\n",
+        "# Compute and print assignment-required metrics\n",
+        "n = len(eval_set)\n",
+        "print(f\"Retrieval accuracy: {retrieval_hits}/{n}\")\n",
+        "print(f\"Faithfulness accuracy: {faithfulness_hits}/{n}\")\n",
+        "print(f\"Correctness accuracy: {correctness_hits}/{n}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 98,
+      "id": "56c3e91d",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "* Running on local URL:  http://127.0.0.1:7868\n",
+            "* To create a public link, set `share=True` in `launch()`.\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div><iframe src=\"http://127.0.0.1:7868/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/plain": []
+          },
+          "execution_count": null,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Optional UI: Test the RAG chain with vector vs hybrid retrieval debug in Gradio\n",
+        "import gradio as gr\n",
+        "\n",
+        "# Ensure Step 5 has been executed so `qa_chain`, `retriever`, and `retriever_vector` exist\n",
+        "if \"qa_chain\" not in globals() or \"retriever\" not in globals() or \"retriever_vector\" not in globals():\n",
+        "    raise ValueError(\"Run Step 5 first so `qa_chain`, `retriever`, and `retriever_vector` are available.\")\n",
+        "\n",
+        "# Function used by the UI to query the RAG chain and inspect retrieved context\n",
+        "def ask_rag(question):\n",
+        "    question = (question or \"\").strip()\n",
+        "    if not question:\n",
+        "        return \"Please enter a question.\", \"\", \"\"\n",
+        "\n",
+        "    # Handle greetings directly for a friendlier chat experience\n",
+        "    normalized = question.lower().strip(\".!? \")\n",
+        "    greetings = {\"hi\", \"hey\", \"hello\", \"hiya\", \"yo\"}\n",
+        "    if normalized in greetings:\n",
+        "        return \"Hi! What can I help you with today?\", \"\", \"\"\n",
+        "\n",
+        "    vector_docs = retriever_vector.invoke(question)\n",
+        "    hybrid_docs = retriever.invoke(question)\n",
+        "\n",
+        "    result = qa_chain.invoke({\"query\": question})\n",
+        "    answer = result[\"result\"] if isinstance(result, dict) else str(result)\n",
+        "\n",
+        "    def format_docs(docs, label):\n",
+        "        parts = [f\"{label} (top {len(docs)})\"]\n",
+        "        for i, doc in enumerate(docs, start=1):\n",
+        "            text = doc.page_content.strip()\n",
+        "            preview = (text[:300] + \"...\") if len(text) > 300 else text\n",
+        "            meta = {\n",
+        "                \"source\": doc.metadata.get(\"source\"),\n",
+        "                \"date\": doc.metadata.get(\"date\"),\n",
+        "                \"section\": doc.metadata.get(\"section\"),\n",
+        "            }\n",
+        "            parts.append(f\"Chunk {i} | metadata={meta}:\\n{preview}\")\n",
+        "        return \"\\n\\n\".join(parts)\n",
+        "\n",
+        "    return (\n",
+        "        answer,\n",
+        "        format_docs(vector_docs, \"Vector only\"),\n",
+        "        format_docs(hybrid_docs, \"Hybrid (vector + BM25)\"),\n",
+        "    )\n",
+        "\n",
+        "# Build and launch a minimal interface (question -> answer + retrieved chunks)\n",
+        "demo = gr.Interface(\n",
+        "    fn=ask_rag,\n",
+        "    inputs=gr.Textbox(lines=3, label=\"Ask a question\"),\n",
+        "    outputs=[\n",
+        "        gr.Textbox(lines=8, label=\"RAG Answer\"),\n",
+        "        gr.Textbox(lines=14, label=\"Retrieved Chunks: Vector only\"),\n",
+        "        gr.Textbox(lines=14, label=\"Retrieved Chunks: Hybrid\"),\n",
+        "    ],\n",
+        "    title=\"Textbook RAG Assistant\",\n",
+        "    description=\"Ask questions about textbook_1.pdf and textbook_2.pdf using your RetrievalQA chain.\",\n",
+        ")\n",
+        "\n",
+        "demo.launch(share=False)"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.14.4"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}