Building a RAG application in Python

Name: Building a RAG application in Python
Rating: 4.5 (9 reviews)

Build a streaming web chat with hybrid retrieval, multi-turn memory, and image support — from scratch

Created byTrevor Sawler

Last updated 8/2026

English

English [Auto],

What you'll learn

Build a complete Retrieval-Augmented Generation pipeline in Python, from document ingestion to streaming chat output
Run Postgres with the pgvector extension via Docker Compose, including HNSW indexing for fast approximate-nearest-neighbour vector search
Chunk documents with paragraph-aware splitting and overlap, and explain why each chunking choice affects retrieval quality
Implement idempotent, atomic document ingestion using SHA-256 content hashes and transactional upserts
Use the OpenAI SDK to call local Ollama models and OpenAI's hosted API through the same code path
Implement hybrid retrieval that combines dense vector search with Postgres full-text BM25, fused with Reciprocal Rank Fusion
Build a query rewriter that turns follow-up questions like "what does it eat?" into standalone search queries that actually retrieve useful chunks
Build a directory watcher with watchdog, including per-path debouncing so editor saves never trigger reads of half-written files
Apply the Strategy/Adapter pattern to swap a Postgres backend for Weaviate via a single environment variable, with zero changes to the rest of the code
Build a streaming chat web UI with FastAPI, Server-Sent Events, and vanilla JavaScript — no React, no build step
Ingest images using a "describe-then-embed" vision-model pipeline, including format normalization for vision backends
Render LLM markdown output safely in the browser with marked + DOMPurify, including inline images
Apply standard software-engineering patterns — Dependency Injection, Factory, Strategy/Adapter, context managers, lazy imports, etc.
Diagnose RAG failures empirically (cosine scores, full-text ranks, fused output) instead of guessing at prompts

Course content

13 sections • 75 lectures • 9h 33m total length

Introduction5:07
Installing Python5:24
Installing an IDE1:22
Mistakes - we all make them0:57
Embrace mistakes as a normal part of software development, especially in not strictly typed Python. Acknowledge errors openly, and expect the instructor to draw attention to mistakes in future lectures.

Getting started with the Vector Store9:06
Setting up Postgres3:36
Define the vector store contract14:26
Implementing the Postgres store I15:31
Implement a Postgres vector store by creating postgres.py, establishing a lazy, single connection, and upserting documents with chunks inside a transactional, rollback-capable process.
Implementing the Postgres store II4:08
Wiring things up4:05
Trying things out9:00

Getting started9:11
Setting up our chunking logic12:36
Chunk large documents for a RAG store by splitting text into around 1,000 characters per chunk, paragraph-aware chunks with overlap, using a Python chunking module before embedding.
Creating embeddings from chunks12:01
Trying out our embedder4:15
Setting up the ingestor14:39
Wire up the CLI for the ingestor9:40
Wire up the cli for the ingestor by configuring logging and building with config, embedder, and store, then expose ingest and scan commands to process files and the documents dir.
Trying out the ingestion pipeline4:19

Getting started: the system prompt9:00
Configure a default system prompt to make the assistant an expert in mythological creatures and to use vector store documents, avoid inventing facts, and allow file-based overrides.
Wrapping retrieval into a user message11:29
Implement an ask command — RAG end-to-end in one function13:05
Learn to implement a stateless ask command in a Python RAG app, wiring config, top-k retrieval, and end-to-end vector store querying for one-shot use.
Using an external system prompt2:57
Explore implementing a custom external system prompt by loading from prompts/system-prompt.txt and using the system_prompt_file environment variable to override the default prompt in pyrag with vector store support.
Modifying the chat command to use RAG7:56
Modify the chat command to use rag by querying the vector store and incorporating retrieved context into the response, with configurable top k and dynamic system prompts.
Adding a spinner9:58
Improving the spinner2:45

Getting started: moving processed files8:56
Safety check: prevent re-triggering ingest of files1:54
Scanning the documents directory on app startup3:53
Setting up a debouncing handler11:56
Starting our watcher to look for files to process5:29
Set up a watcher that uses a watchdog observer and a debounced handler to monitor the documents directory non-recursively, perform initial scan, ensure directories exist, and stop cleanly on interruption.
Adding the watch command2:09
add the watch command to the cli to monitor ingester activity, set up logging, manage the ingester lifecycle, and ensure the database connection closes after use.
Trying things out3:39

Getting started: making the Postgres search method hybrid21:30
Combine dense vector search with lexical ranking to create a hybrid retrieval for a Python rag app in Postgres, using reciprocal rank fusion and content TSV.
Reviewing the code and trying hybrid retrieval3:55
Improve rag retrieval by replacing pure dense search with hybrid retrieval that combines dense vector semantic ranking and lexical content tsv ranking, fused via reciprocal rank fusion in postgres.py.

Getting started: Modifying the abstract interface for metadata3:51
Updating the Postgres vector store for metadata4:00
Updating the search method for metadata8:07
Update the search method to return document metadata and ingested at by selecting documents.metadata as document_metadata and including it in each search hit, without changing semantic, lexical, or fusion logic.
Populating metadata4:02
Update ingest logic to populate document and chunk metadata by extending upsertDocument with suffix, kind, and type text, then ingest and verify metadata in Postgres and the vector store.

Getting started: starting weaviate and adding the dependency2:46
Getting started with the weaviate store with config entries3:38
Setting up the Weaviate Store: Part I19:39
Setting up has_document3:46
Setting up upsert_document11:41
Define upsertDocument in the Weave 8 store, delete old chunks, batch-insert new chunks with metadata and vector embedding, and ensure atomicity with error handling.
Setting up delete_document1:46
Implement delete document by removing all chunks for a given source path using deleteMany with a where clause on the source path. Proceed to the upcoming search method.
Setting up search15:48
Trying things out4:54

Requirements

Basic Python skills, basic SQL, comfort with the command line and Docker. No prior LLM or vector-database experience needed.

Description

Build a working Retrieval-Augmented Generation (RAG) application in Python — from an empty directory to a streaming web chat with multi-turn memory, hybrid retrieval, image ingestion, and two interchangeable vector-store backends. No LangChain, no LlamaIndex, no magic. You write every line yourself, and by the end you understand exactly what each one does.

Most RAG tutorials wrap everything in a single high-level library and stop at "it works." This course goes the other way. You'll build the pipeline from scratch — chunking, embeddings, idempotent ingestion, hybrid semantic-plus-lexical retrieval with Reciprocal Rank Fusion, a query rewriter for follow-up questions, server-sent token streaming, a vision-model branch for images — on top of plain Postgres (with pgvector) and a local Ollama server. No API bills while you learn. No black boxes. When you later reach for a framework like LangChain, you'll actually understand what it's doing under the hood.

What you'll build, in one project:

Runs entirely locally against Ollama, or transparently against the OpenAI API by changing one environment variable
Stores embeddings in Postgres + pgvector with HNSW indexing, or in Weaviate — backends swappable via a single config setting
Hybrid retrieval: dense vector search and Postgres full-text BM25, fused with Reciprocal Rank Fusion — fixing the cases where pure semantic search silently fails on rare terms, names, and identifiers
A directory watcher that ingests new files automatically, with editor-save debouncing so it never reads a half-written file
A streaming web chat UI built on FastAPI + Server-Sent Events + vanilla JavaScript — no React, no build step — with multi-turn memory, query rewriting for follow-ups, source citations, and inline image rendering
Image ingestion through a vision model with a "describe-then-embed" pipeline — multimodal in the same chunks table, no schema change required

Along the way you'll work through real software-design patterns in real code: Dependency Injection, Strategy/Adapter, Factory, lifespans, context managers, thread-safety boundaries, atomic transactions, defensive coding against external services that quietly don't work the way their docs claim. The course's recurring theme is the payoff of good abstractions: the vector-store interface designed early lets you bolt on a second backend in one file; the same retrieval pipeline serves both the CLI and the web app; the chunk-metadata field that seemed academic early in the course is what makes image support a simple change later on.

You'll finish with a codebase you can extend — add a reranker, try a different embedder, swap the chat model, point it at a corpus of your own docs — and the engineering vocabulary to talk about RAG as production software, not a notebook demo.

Who this course is for:

Python developers interested in integrating LLMs into their projects, and adding RAG functionality.

Building a RAG application in Python

What you'll learn

Explore related topics

Course content

Introduction4 lectures • 13min

Getting Started: Chatting with the LLM4 lectures • 42min

Setting up the Vector Store7 lectures • 1hr

Setting up the Ingestion Pipleline7 lectures • 1hr 7min

Setting up Retrieval4 lectures • 26min

Implementing RAG: Bringing it all together7 lectures • 57min

Automating Ingestion7 lectures • 38min

Hybrid Search & Retrieval2 lectures • 25min

Metadata4 lectures • 20min

Weaviate: An alternative vector store8 lectures • 1hr 4min

Requirements

Description

Who this course is for: