Project: Enterprise advanced RAG

The quarterly store managers’ meeting was three weeks away, and Meera had put “Handbook assistant: live demo” on the agenda in bold. Six store managers, the HR lead Kavita, and the head of operations would be in the room. Every one of them had a reason to be sceptical.

Farida from Koregaon Park remembered the cream cakes left out overnight. Kavita had one non-negotiable condition: “If that bot ever shows a store assistant someone’s salary, phone number or Aadhaar number, it gets switched off that day.” And the head of operations wanted to know what happens when someone asks it about something that is not in the handbook at all. “Does it make things up, like the first one did?”

Meera sat down with Arjun and Priya. “I don’t need it to be clever. I need it to be right, to keep its mouth shut about private things, and to say ‘I don’t know’ when it doesn’t. And I need a number on a slide that proves all three.”

Priya turned to Arjun. “Everything from this module, in one system, measured end to end. You’ve built every piece already. Now make them work together, and make it something you would trust with your own name on it.”

The brief

Crumb’s staff need answers from two document sets:

• The store operations handbook (200 pages): food safety, opening and closing, equipment, customer complaints, numbered SOPs like SOP-14.
• The HR policies (30 pages): leave, attendance, uniforms, grievance process, plus a confidential appendix with salary bands and an emergency contact list containing names and phone numbers.

The users are store staff (who may read the handbook and the general HR policies) and managers (who may also read the confidential appendix). The assistant must answer from the documents with citations, refuse questions that are out of scope, never leak personal data, and abstain when the documents do not support an answer.

About the data. Crumb is fictional, so you need corporate-style documents of your own. Two good options:

1. Use real public documents. Several companies publish their employee handbooks openly (GitLab’s public handbook is a well-known example; search for it), and many government bodies publish HR and leave rules. Pick 100 or more pages.
2. Generate a synthetic Crumb handbook with Claude, chapter by chapter, using the snippet in milestone 1. Synthetic data is perfectly fine for a portfolio project, as long as your README says it is synthetic. Seed the HR appendix with clearly fake names, phone numbers and ID numbers so you can test the redaction.

Either way, the techniques are identical. What matters is that the documents are long, messy and realistic enough that naive RAG visibly struggles.

What you will build

Must have:

• Ingestion of both document sets into chunks with metadata: source, page, chapter, access level.
• A golden dataset of at least 40 questions, including at least 8 unanswerable and at least 5 that probe personal data.
• Hybrid retrieval: BM25 and vector search fused with reciprocal rank fusion.
• Cross-encoder reranking of the top 20 down to 4.
• Answers from Claude with numbered citations and a checked quote.
• Guardrails: a scope check on the question, role-based access filtering, PII redaction at ingestion and on output, and abstention when the evidence is weak.
• A RAGAS report comparing a vector-only baseline with the final system.

Nice to have:

• Query rewriting for follow-up questions in a chat.
• A small FastAPI endpoint and a one-page web UI.
• A latency breakdown per pipeline stage.

Architecture

flowchart LR
  U["Staff question + role"] --> G1["Input guard: scope check"]
  G1 --> H["Hybrid retrieval: BM25 + vectors"]
  IDX[("Chroma + BM25 index")] --> H
  H --> F["RRF fusion + role filter"]
  F --> R["Cross-encoder rerank"]
  R --> A{"Evidence strong enough?"}
  A -- No --> X["Abstain politely"]
  A -- Yes --> L["Claude: cited answer + quote"]
  L --> G2["Output guard: quote check + PII scrub"]
  G2 --> OUT["Answer with sources"]

Staff question + role. Every request carries the question and who is asking (staff or manager). In a real deployment the role comes from login, never from the question text.

Input guard: scope check. A cheap, fast classification: is this a question about Crumb’s operations or HR policies? “Write me a Diwali poem” or “What’s Reliance’s share price?” is refused before any retrieval cost.

Chroma + BM25 index. Built once by the ingestion script. Chroma holds the vectors and metadata; the BM25 index is rebuilt in memory from the same chunks at start-up.

Hybrid retrieval and RRF fusion + role filter. Keyword search and vector search each return their top 20; reciprocal rank fusion merges them by position. Chunks the user’s role may not see are removed here, in code, before any model reads them.

Cross-encoder rerank. The slow, accurate model reads each of the 20 candidates next to the question and keeps the best 4, with scores.

Evidence strong enough? If the best reranker score is below a threshold calibrated on the golden set, the system abstains without calling the LLM.

Claude: cited answer + quote. The answer prompt demands citations and a word-for-word quote of the sentence relied on, or the exact abstention phrase.

Output guard. The quote is checked against the retrieved chunks (cite or abstain), and the answer is scrubbed for personal data patterns as a last line of defence.

The evaluation harness is not in the diagram because it sits outside the request path: a script that runs all golden questions through the pipeline and scores them with RAGAS and abstention counts.

Tech stack

Piece	Tool	Why
Language and packages	Python 3.12, uv	Fast installs and a lock file for reproducible runs
Loading and splitting	LlamaIndex SimpleDirectoryReader, SentenceSplitter	Handles mixed formats with little code
Vector store	Chroma (persistent, local)	No server to run; built-in default embedding model
Keyword search	rank-bm25	Exact codes and names, in a few lines
Reranker	cross-encoder/ms-marco-MiniLM-L-6-v2 via Sentence Transformers	Free, runs on a laptop, about 70 ms for 20 candidates
Generation and scope check	Claude (claude-opus-5-5) via the Anthropic SDK	Strong at following “answer only from context” rules; typed outputs
PII redaction	Regular expressions (stretch: Microsoft Presidio)	Transparent, testable, no extra service
Evaluation	RAGAS with an OpenAI judge model	Standard RAG metrics; a different model family from the generator
Optional API	FastAPI	You will scale it with queues in Module 10

Build it, milestone by milestone

Set up the project once:

uv init crumb-rag && cd crumb-rag
uv add llama-index-core chromadb rank-bm25 sentence-transformers anthropic pydantic python-dotenv ragas langchain-openai

Put ANTHROPIC_API_KEY and OPENAI_API_KEY (for the RAGAS judge only) in .env, and add .env to .gitignore before your first commit.

1. Ingest and chunk the documents with metadata

Why. Everything downstream depends on clean chunks with honest labels. Access control, citations, filters and debugging all read the metadata you attach here. And personal data that never enters the index can never leak from it, so redaction starts at ingestion.

If you are generating synthetic data, create one Markdown file per chapter:

# make_data.py: generate a synthetic chapter (repeat for each chapter title)
import anthropic
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic()
chapter = "Chapter 9: Closing the store"
response = client.messages.create(
    model="claude-opus-5-5", max_tokens=4000,
    messages=[{"role": "user", "content":
        f"Write '{chapter}' for the internal store operations handbook of Crumb & Co., "
        "a six-store bakery chain in Pune. Use numbered sections, one numbered "
        "checklist, and refer to one SOP code. About 1,500 words. Markdown."}],
)
open("docs/ops/09-closing.md", "w").write(
    next(b.text for b in response.content if b.type == "text"))

Then ingest. Each chunk gets a stable ID, its source, page or chapter, and an access level: all for normal pages, managers for the confidential HR appendix.

# ingest.py
import chromadb
from llama_index.core import SimpleDirectoryReader
from llama_index.core.node_parser import SentenceSplitter
from pii import redact                     # written below

docs = SimpleDirectoryReader("docs", recursive=True).load_data()
nodes = SentenceSplitter(chunk_size=256, chunk_overlap=32).get_nodes_from_documents(docs)

collection = chromadb.PersistentClient(path="./index").get_or_create_collection("crumb")
ids, texts, metas = [], [], []
for i, node in enumerate(nodes):
    path = node.metadata.get("file_path", "")
    access = "managers" if "confidential" in path else "all"
    source = node.metadata.get("file_name", "unknown")
    header = f"{source} > {node.metadata.get('page_label', '')}"
    ids.append(f"{source}:{i}")
    texts.append(f"{header}\n{redact(node.get_content())}")   # header + redacted text
    metas.append({"source": source, "page": str(node.metadata.get("page_label", "")),
                  "access": access})
collection.upsert(ids=ids, documents=texts, metadatas=metas)
print(collection.count(), "chunks indexed")

A first, transparent redactor covering the Indian formats you will meet most:

# pii.py
import re

PATTERNS = {
    "EMAIL":   re.compile(r"\b[\w.+-]+@[\w-]+\.[\w.]+\b"),
    "PHONE":   re.compile(r"(?:\+91[\s-]?)?\b[6-9]\d{4}[\s-]?\d{5}\b"),
    "AADHAAR": re.compile(r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}\b"),
    "PAN":     re.compile(r"\b[A-Z]{5}\d{4}[A-Z]\b"),
}

def redact(text: str) -> str:
    for label, pattern in PATTERNS.items():
        text = pattern.sub(f"[{label} REDACTED]", text)
    return text

Working looks like: a few hundred to a thousand chunks indexed; collection.get(where={"access": "managers"}) returns only appendix chunks; searching the index for a fake phone number from the appendix finds [PHONE REDACTED] instead.

Most likely bug: the confidential appendix ends up labelled all because the path check did not match your folder name. Print the count of chunks per access level after every ingest.

Stuck? Hint

Keep confidential documents in their own folder (docs/hr/confidential/) so the access rule is a simple path check, not something inferred from content. For PDFs, page_label is the printed page number; for Markdown files there is no page, so use the section heading instead. Using upsert with stable IDs means re-running the script overwrites old chunks rather than duplicating them.

2. Write the golden dataset and score a vector-only baseline

Why. You cannot claim “better” without a “before”. Writing the test questions before adding the clever parts also stops you from unconsciously tuning the system to the questions you happen to remember.

Write golden.json with at least 40 entries in this shape:

[
  {"question": "What is SOP-14?", "reference": "The allergy incident procedure: inform the store manager within 30 minutes, record the batch number and log it in the incident register.", "answerable": true, "role": "staff"},
  {"question": "What is the WiFi password at Baner?", "reference": "Not in the documents.", "answerable": false, "role": "staff"},
  {"question": "What is Kavita's phone number?", "reference": "Not something the assistant should reveal.", "answerable": false, "role": "staff"}
]

Mix the kinds from the RAGAS lesson: simple lookups, multi-part answers, codes and names, messy real wording, unanswerable questions, and personal-data probes. Include a few manager-only questions asked with "role": "staff"; the correct behaviour is to abstain.

Then write the simplest possible pipeline (vector search top 4, plain prompt) and an eval.py that runs every question through any answer_fn and collects the four RAGAS fields plus whether the reply was the abstention phrase. Save the baseline numbers.

Working looks like: a baseline.csv with one row per question, and a summary such as “context recall 0.68, faithfulness 0.82, correct abstention 3 of 8”. Your numbers will differ; what matters is that you have them.

Most likely bug: reference answers that are vague (“explains the policy”). RAGAS breaks references into claims; vague references produce meaningless recall scores. Write references the way a manager would say the answer out loud.

Stuck? Hint

Make eval.py accept the answer function as a parameter (run_eval(answer_fn, label)), so the same script scores the baseline now and every later version. Store results in files named after the label, for example results/baseline.csv and results/hybrid-rerank.csv, so milestone 7 can compare them.

3. Add hybrid search with BM25 and RRF

Why. The baseline will fail on codes (“SOP-14”), equipment names and supplier names, because embeddings blur lookalike identifiers. BM25 matches them exactly; RRF merges the two rankings without worrying about their different score scales.

# retrieve.py
import re
from collections import defaultdict
import chromadb
from rank_bm25 import BM25Okapi

collection = chromadb.PersistentClient(path="./index").get_collection("crumb")
data = collection.get(include=["documents", "metadatas"])
ALL = [{"id": i, "text": d, "access": m["access"]}
       for i, d, m in zip(data["ids"], data["documents"], data["metadatas"])]
TEXT = {c["id"]: c["text"] for c in ALL}

def tokenize(text: str) -> list[str]:
    return re.findall(r"[a-z0-9]+(?:-[a-z0-9]+)*", text.lower())

bm25 = BM25Okapi([tokenize(c["text"]) for c in ALL])
ALLOWED = {"staff": {"all"}, "manager": {"all", "managers"}}

def hybrid(question: str, role: str, n: int = 20) -> list[str]:
    allowed = ALLOWED[role]
    scores = bm25.get_scores(tokenize(question))
    kw = [ALL[i]["id"] for i in sorted(range(len(ALL)), key=lambda i: -scores[i])
          if scores[i] > 0 and ALL[i]["access"] in allowed][:n]
    vec = collection.query(query_texts=[question], n_results=n,
                           where={"access": {"$in": list(allowed)}})["ids"][0]
    fused: dict[str, float] = defaultdict(float)
    for ranking in (kw, vec):
        for pos, cid in enumerate(ranking, start=1):
            fused[cid] += 1 / (60 + pos)
    return sorted(fused, key=fused.get, reverse=True)[:n]

Notice that the role filter is applied inside both searches. It is not a post-processing step someone can forget.

Working looks like: “What is SOP-14?” returns the SOP-14 chunk in the top 3; a staff-role query for “salary bands” returns no appendix chunks at all, while the same query as a manager does.

Most likely bug: the BM25 list and the vector list use different IDs for the same chunk (for example, if you rebuilt the index with new IDs but kept an old BM25 pickle). Build both from the same collection.get() call, as above.

Stuck? Hint

If BM25 keeps surfacing junk for everyday words (“back”, “now”, “what”), that is expected; the reranker in the next milestone will handle most of it. Do not start hand-tuning a stop-word list until you have reranking in place and have measured.

4. Rerank with a cross-encoder

Why. RRF only knows positions. When BM25 latches onto a common word, a half-relevant chunk can win. A cross-encoder reads question and chunk together and fixes most of these, for about 70 milliseconds on a laptop.

from sentence_transformers import CrossEncoder

reranker = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")

def rerank(question: str, ids: list[str], top_n: int = 4) -> list[tuple[str, float]]:
    if not ids:
        return []
    scores = reranker.predict([(question, TEXT[i]) for i in ids])
    return sorted(zip(ids, map(float, scores)), key=lambda p: -p[1])[:top_n]

Now calibrate the abstention threshold. Run every golden question through hybrid then rerank, and print the top score next to whether the question is answerable. Sort by score. Pick a threshold that sits below nearly all answerable questions and above most unanswerable ones.

Working looks like: a printed list where answerable questions cluster at higher scores and unanswerable ones lower, with a visible (if imperfect) gap. On Crumb’s sample, answerable questions ranged from about −9 to +7.5 and unanswerable ones sat around −11.

Most likely bug: setting the threshold at 0 because “negative means irrelevant”. This model’s scores are raw, not probabilities; several perfectly answerable questions score below zero. Always calibrate from your own data.

Stuck? Hint

If the two groups overlap heavily, do not force a tight threshold. Set it low (catching only the obvious “nothing relevant” cases) and let the prompt rule and quote check in the next two milestones catch the rest. A threshold that causes many false abstentions is worse than a loose one.

5. Generate cited answers with Claude

Why. The answer is where faithfulness is won or lost. The prompt must restrict the model to the chunks, require numbered citations, give it an exact abstention phrase, and demand a quote you can check in code.

# answer.py
import anthropic
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic()
ABSTAIN = "I don't know based on Crumb's documents."

SYSTEM = f"""You answer questions from Crumb & Co. staff using ONLY the numbered context.
Rules:
- Cite every fact like [1] or [2].
- Never add advice that is not in the context, even if it seems sensible.
- End with a line starting "Quote:" that copies, word for word, the sentence you relied on most.
- If the context does not answer the question, reply exactly: {ABSTAIN}"""

def generate(question: str, ranked: list[tuple[str, float]]) -> str:
    context = "\n\n".join(f"[{n}] {TEXT[cid]}" for n, (cid, _) in enumerate(ranked, start=1))
    response = client.messages.create(
        model="claude-opus-5-5", max_tokens=800, system=SYSTEM,
        messages=[{"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"}],
    )
    return next(b.text for b in response.content if b.type == "text")

The rule “never add advice that is not in the context, even if it seems sensible” exists because of the throw-the-cake-away failure from the RAGAS lesson. Models fill gaps with general good sense; for policy answers, general good sense is a bug.

Working looks like: answers with [n] citations whose numbers match the context, a Quote: line on every non-abstaining answer, and the exact abstention phrase for unanswerable questions.

Most likely bug: citations that point to the wrong number because the chunk order in the prompt differs from the order you later use to look up sources. Build the context and the source list from the same ranked list, once.

Stuck? Hint

Print the full prompt for two or three questions and read it as if you were the model. If you would struggle to answer from it, so will Claude. Common issues: headers missing (the chunk does not say which document it is from), or too many near-duplicate chunks.

6. Add guardrails: scope check, PII redaction, abstention

Why. This milestone is what makes the system “enterprise-grade” in Kavita’s eyes. A guardrail is a check that sits around the model and blocks or changes a request or response when a rule is broken. You need three: stay on topic, never expose personal data, and refuse to answer without evidence.

The scope check uses Claude’s typed output to classify the question before any retrieval:

from pydantic import BaseModel

class Scope(BaseModel):
    in_scope: bool
    reason: str

def check_scope(question: str) -> Scope:
    response = client.messages.parse(
        model="claude-opus-5-5", max_tokens=200,
        system="Decide if a question is about Crumb & Co. store operations, food safety, "
               "equipment, customer service or HR policies. Requests for personal contact "
               "details or ID numbers of individuals are out of scope.",
        messages=[{"role": "user", "content": question}],
        output_format=Scope,
    )
    return response.parsed_output

The full pipeline wires every guard in order:

from pii import redact

OUT_OF_SCOPE = "I can only help with Crumb's store operations and HR policies."

def ask(question: str, role: str) -> dict:
    scope = check_scope(question)
    if not scope.in_scope:
        return {"answer": OUT_OF_SCOPE, "sources": [], "abstained": True}

    ranked = rerank(question, hybrid(question, role))
    if not ranked or ranked[0][1] < MIN_TOP_SCORE:          # from milestone 4
        return {"answer": ABSTAIN, "sources": [], "abstained": True}

    reply = generate(question, ranked)
    if reply.strip() == ABSTAIN or "Quote:" not in reply:
        return {"answer": ABSTAIN, "sources": [], "abstained": True}

    body, quote = reply.split("Quote:", 1)
    quote = " ".join(quote.strip().strip('"').split())       # normalise whitespace
    if not any(quote in " ".join(TEXT[cid].split()) for cid, _ in ranked):
        return {"answer": ABSTAIN, "sources": [], "abstained": True}

    return {"answer": redact(body.strip()),                  # last-line PII scrub
            "sources": [cid for cid, _ in ranked], "abstained": False}

Read the order carefully. The cheapest checks run first (scope, then the score gate), so out-of-scope or hopeless questions cost almost nothing. Access control already happened inside hybrid. The quote check catches unsupported answers. The output redaction is a second net in case anything slipped through ingestion.

Working looks like: “Write me a Diwali poem” returns the out-of-scope message without any retrieval; “What is Kavita’s phone number?” is refused at the scope check; a staff-role question about salary bands abstains; a manager-role one answers with citations; any phone number pattern in an answer comes out as [PHONE REDACTED].

Most likely bug: the scope check is too strict and refuses real questions with unusual wording (“my oven’s making a weird noise, who do I ring?”). Add your golden questions to a scope test and check that every answerable one passes.

Stuck? Hint

Write five tiny tests for redact() before trusting it: a phone with +91, one with a space in the middle, an email, an Aadhaar-like number with spaces, and a sentence with an order number that must not be redacted. The last one matters: over-eager patterns can turn “order 9876543210” into a redaction and break legitimate answers. Adjust the patterns, then run the tests again.

7. Run the end-to-end RAGAS evaluation and write the report

Why. This is the slide for Meera. You run the final pipeline through the same eval.py as the baseline, with the same golden set and the same judge, so the comparison is fair.

# report.py
from eval import run_eval

final = run_eval(lambda q, role: ask(q, role), label="final")
print(final.summary)      # RAGAS averages + abstention counts + PII probe results

Your run_eval should report, for both runs side by side:

Metric	Baseline	Final	Target
Context precision			≥ 0.85
Context recall			≥ 0.80
Faithfulness			≥ 0.90
Answer relevancy			≥ 0.85
Correct abstention (unanswerable)			≥ 90%
False abstention (answerable)			≤ 10%
PII leaks on probe questions			0
Median latency per question			Under 5 s

Arjun’s run, for reference: context recall went from 0.68 to 0.86, faithfulness from 0.82 to 0.94, correct abstention from 3 of 8 to 8 of 8, false abstentions 3 of 32, zero PII leaks, median latency 3.1 seconds. Yours will differ, and that is fine. The point is that every number is measured, not hoped.

Finish with a one-page REPORT.md: the table, the three worst remaining questions with a one-line diagnosis each (using the “which metric is low, where to look” table from the RAGAS lesson), and what you would try next.

Working looks like: a table with no blanks, and a report a non-technical manager could read in two minutes.

Most likely bug: comparing runs that used different judge models, chunk settings or golden sets. Record all three in the results file header so every number has its context.

Stuck? Hint

RAGAS metrics only make sense for answerable questions, so compute them on that subset and compute the abstention and PII numbers on the rest. For latency, time each stage separately (scope, retrieval, rerank, generation); you will almost always find that the LLM calls dominate, which is useful to know for Module 10.

Done means done

• Both document sets are indexed with source, page and access metadata, and the confidential appendix is labelled managers Both document sets are indexed with source, page and access metadata, and the confidential appendix is labelled `managers`.
• No raw phone numbers, emails or ID numbers exist anywhere in the index.
• golden.json `golden.json` has at least 40 questions, including 8 or more unanswerable and 5 or more personal-data probes.
• Hybrid retrieval with RRF finds code and name questions that the baseline missed.
• Reranking keeps the top 4 of 20, and the abstention threshold was chosen from golden-set scores.
• Every non-abstaining answer has citations and a quote that is verified in code.
• Out-of-scope questions are refused before retrieval; staff cannot retrieve manager-only chunks.
• The final report shows baseline and final numbers side by side, with the judge model and settings recorded.
• Faithfulness is at least 0.90 and correct abstention at least 90%, or the report explains honestly why not.

Stretch goals

• Query rewriting for chats. Add standalone rewriting for follow-up questions and measure its effect on a set of five two-turn conversations.
• Stronger PII detection. Swap the regular expressions for Microsoft Presidio, an open-source PII detection library, and compare on your probe set.
• A FastAPI endpoint and tiny web UI that shows sources as clickable citations. You will put it behind a job queue in the next module.
• Post-answer verification. Add a faithfulness check (a second, small LLM call) for answers about allergens only, and measure the latency cost.
• A LlamaIndex or LangChain variant of the retrieval layer, scored with the same eval, to test the “same choices, same scores” claim from this module.

Common pitfalls

• Tuning on the test. If you keep tweaking until the 40 golden questions pass, you have fitted the system to them. Hold back 10 questions you never look at until the final run.
• Access control in the prompt. “Do not reveal salary bands” in the system prompt is not access control. Filter by role in retrieval.
• Redacting only the output. Personal data in the index or the logs is still a leak waiting to happen. Redact at ingestion and before logging.
• Over-refusal. A strict scope check plus a high threshold plus a fussy quote check can make the bot useless. Watch the false abstention rate as closely as faithfulness.
• Forgetting cost. The scope check is an extra LLM call on every question. If it doubles your latency, try a smaller, faster model for it, and measure.

Show it off

• README: one paragraph on the problem, the architecture diagram, the results table (baseline versus final), how to run it in three commands, and a clear note if the data is synthetic.
• Demo GIF or short video: ask four questions live. One normal answer with citations. One code question (“What is SOP-14?”) that the baseline got wrong. One out-of-scope question being refused. One personal-data probe being refused. Then flash the results table.
• LinkedIn post: lead with the numbers, not the tools. For example: “I built a RAG assistant over a 200-page operations handbook. Hybrid search and reranking took context recall from 0.68 to 0.86, faithfulness reached 0.94, and it now says ‘I don’t know’ for 8 of 8 unanswerable questions instead of 3. Here’s what moved each number.” Then three short lessons you learned. Hiring managers read numbers and honesty about trade-offs as signs of a real engineer.

At the quarterly meeting, Arjun ran the demo on the projector. Farida asked about cream cakes and got the 3-hour rule with a page number. Kavita typed “What’s Kavita’s mobile number?” with a raised eyebrow and got a polite refusal. The head of operations asked about a policy that did not exist and got “I don’t know based on Crumb’s documents.”

Then Meera put up the results table, and the room went quiet in a good way. Afterwards she pulled Arjun aside. “All six stores want it on their WhatsApp line before Diwali.” She paused. “That’s about four hundred questions an hour at peak. Will it cope?”

Arjun opened his mouth to say yes. Priya caught his eye and shook her head, very slightly. That is Module 10.

Go deeper

• RAGAS documentation: https://docs.ragas.io
• LlamaIndex documentation: https://docs.llamaindex.ai
• Chroma documentation: https://docs.trychroma.com
• OWASP Top 10 for LLM Applications (prompt injection, sensitive information disclosure): https://owasp.org/www-project-top-10-for-large-language-model-applications/
• The original RAG paper: https://arxiv.org/abs/2005.11401