Introduction to Retrieval-Augmented Generation (RAG)

Understanding RAG — The Big Idea 6 topics

• Why plain LLMs aren't enough
  Ask ChatGPT (or any large language model) "What is our refund policy?" and it will confidently make something up — because it has never seen your company's refund…
• What RAG actually is — the open-book exam metaphor
  Imagine two students taking the same history exam. Student A has to answer purely from memory — anything they don't remember, they have to guess.
• RAG vs. fine-tuning vs. plain prompting — choosing the right tool
  There are three broad ways to make a language model behave the way you need.
• Real-world RAG in action — five industries, five examples
  RAG is not a lab curiosity — it's already the backbone of many assistants you may have used without realising it. Five concrete examples, one per industry:
• The business case: cost, ROI and risk reduction
  Before you build anything, it helps to be able to make the case for why a business should invest in a RAG assistant at all. Three angles matter most:
• Where RAG shines and where it struggles
  RAG is powerful, but it is not magic, and setting the right expectations early will save you a lot of frustration later.

Architecture & Components 7 topics

• The two-pipeline mental model: ingestion vs. query
  Every RAG system, no matter how it's built, is really two separate pipelines that happen to share the same storage:
• Component: the knowledge base (your source documents)
  The knowledge base is simply the collection of real documents you want your assistant to be able to answer from: PDFs, Word documents, web pages, spreadsheets…
• Component: chunking — breaking documents into retrievable pieces
  You can't hand an entire 40-page policy manual to the model every time someone asks one small question — it would be slow, expensive, and the model would have to hunt…
• Component: embeddings — turning meaning into numbers
  Computers can't compare the meaning of two pieces of text directly — they need numbers.
• Component: the vector database — your searchable memory
  Once every chunk has been converted into an embedding (a list of numbers), you need somewhere to store all of those number-lists so you can quickly find the closest ones…
• Component: the retriever — finding the right pieces
  The retriever is the piece of the system that actually performs the search: given a question, it asks the vector database for the top few most-similar chunks (often…
• Component: the generator and the orchestrator — writing the answer
  Once the retriever has found the most relevant chunks, two more pieces finish the job:

How Orchestration Works 5 topics

• A question's journey — the request lifecycle end to end
  Let's trace one real question through a working RAG system, step by step, so the architecture from the last module stops being abstract.
• Building the augmented prompt — combining context and question
  The single most underrated skill in RAG is writing the instructions that wrap around the retrieved context — often called the prompt template.
• Orchestration tools — no-code, low-code and code
  You never have to write a program to build a real RAG pipeline today. The whole spectrum, from friendliest to most flexible:
• Memory and multi-turn conversations
  So far we've treated every question as if it arrived in isolation. Real conversations don't work that way — a user might ask "what's the return window for electronics?"…
• Guardrails, citations and "I don't know" in the orchestration layer
  Two orchestration-layer features separate a trustworthy RAG assistant from a risky one:

Essentials, Trade-offs & Business Fit 5 topics

• The essentials checklist — what you must get right
  Before your first RAG project, it helps to have a short checklist of the things that matter most — in rough order of impact:
• The pros of RAG
  A clear-eyed summary of what RAG genuinely gets you, useful when you need to defend the approach to a sceptical stakeholder:
• The cons and risks of RAG
  An equally clear-eyed look at the honest downsides — knowing these up front will save you from over-promising what a RAG project can deliver:
• A decision framework — should your business use RAG?
  A simple framework, in the form of five yes/no questions, to sanity-check whether a use case is a good first RAG project:
• Business use-case matrix — support, sales, HR, compliance, research
  A working reference table connecting business function to the kind of knowledge base and value each typically brings:

Setting Up Your Infrastructure 6 topics

• Preparing your knowledge base documents
  Every hands-on module in this course uses one real knowledge base that you choose and keep using throughout — a product FAQ, a course syllabus, an employee handbook, a…
• Getting and securing an LLM API key
  To use a language model inside a no-code tool, you'll need an API key — a long, private password-like string that lets a tool call a language model provider's service on…
• Setting up a hosted vector database
  Next, set up a place to store your documents' embeddings once they're created.
• Choosing and setting up a no-code orchestration tool
  Now for the tool that ties everything together: a visual, drag-and-drop orchestration builder.
• Wiring it together — your first end-to-end RAG flow
  With your tool set up and credentials saved, it's time to connect the blocks into one working pipeline, mirroring the two-pipeline architecture from earlier in this…
• Testing and debugging your setup
  Before moving on, run through this checklist against your own working flow — treat it the way you'd treat a pre-flight checklist, not a one-time formality.

Mastering Each Sub-part 6 topics

• How to chunk documents well
  Building on the chunking concept from the architecture module, here is a practical, repeatable process for chunking any real document well:
• How to choose and tune an embedding model
  Most no-code tools let you pick from a short list of embedding models. For a beginner project, the decision is simpler than it looks:
• How to tune retrieval (top-k, threshold, hybrid search)
  Retrieval tuning is where most of the real quality improvement in a RAG system comes from, once your basic pipeline is working. Three knobs matter most:
• How to write a grounded prompt template
  Building on the prompt-template basics from the orchestration module, here's how to iteratively improve one for real use:
• How to add citations and "I don't know" handling
  Two specific, testable upgrades that separate a classroom demo from something you'd trust in front of real users:
• How to evaluate your RAG system without writing code
  You don't need to write a single line of code to evaluate a RAG system rigorously — a well-organised spreadsheet is enough for a project at this scale, and is exactly…

Your first working no-code RAG assistant

A working question-answering flow over your chosen knowledge base, built entirely with no-code tools, that a stranger could use. ```mermaid %% title: How the three deliverables build on each other flowchart LR P["Working no-code<br/>RAG assistant"] --> R["Evaluation report<br/>(measured accuracy)"] R --> C["Capstone:<br/>business-ready assistant<br/>+ business case memo"] ```

RAG evaluation report

A completed manual test sheet (question / expected / actual / correct? / cited correctly?) plus a short written summary of your accuracy rate and what you changed to improve it.

Capstone: a business-ready RAG assistant

A polished, end-to-end RAG assistant for a real business use case of your choosing, with citations, "I don't know" handling, an evaluation report, and a one-page business case memo.

Why take this course

• Every concept is taught with a real business example first, jargon second.
• No programming background required — every hands-on step uses free, point-and-click tools.
• You choose your own real knowledge base on day one and use it all the way to your capstone.

You will build

• A complete, working RAG assistant with citations and honest "I don't know" handling.
• A tuned retrieval pipeline you improved using your own before/after test results.
• A manual evaluation sheet with a real, calculated accuracy rate.
• A one-page business case memo you could hand to a real stakeholder.

What you can do afterwards

• A working mental model of every RAG component, transferable to any tool you meet later — no-code or code.
• The confidence to scope, pitch and justify a RAG project inside a real business.