LLM Zoomcamp: A 10-Week RAG Course You Run on Your Own Laptop

A Curriculum Rather Than a Package

The first thing to get straight is what this repository is. It is the course material for LLM Zoomcamp, a free program run by DataTalks.Club, and the primary language is Jupyter Notebook. There is no installable artifact, no versioned package, and no releases listed in the repository metadata. If you arrived expecting a RAG framework you can pip install and import, you are in the wrong place. What you get instead is a sequence of notebooks, videos, and homeworks that build one system end to end across ten weeks.

The problem it addresses is specific. Plenty of people can call an LLM API and get text back. Far fewer can explain why their retrieval step returned the wrong passage, or how they would know whether a change to their prompt made answers better or worse. The README frames the outcome as a working codebase plus the hands-on experience to build your own LLM-powered applications. The stated audience is software engineers, data engineers, and ML practitioners, and the prerequisites are deliberately shallow: confident Python, a terminal, basic Docker familiarity. Machine learning background is explicitly not required, and no GPU is needed. The README puts the expected expense at roughly $1 to $5 in API credits.

What the Ten Weeks Actually Cover

The syllabus is ordered so that each module adds a layer to the same retrieval system. Module 1, Agentic RAG, starts with a pipeline built on keyword search and then makes it agentic through function calling. Module 2, Vector Search, introduces semantic search with embeddings and compares three storage options by name: minsearch, sqlitesearch, and PGVector. That progression from lexical to vector search inside the first two modules is the spine of the course.

Module 3 covers orchestration with Kestra, and a separate workshop builds dlt pipelines to ingest and analyze LLM traces, with filesystem and REST API sources feeding DuckDB and marimo dashboards. Module 4 handles evaluation, split into offline and online measurement of retrieval and answer quality. Module 5 is monitoring: user feedback, system health, live dashboards. Module 6 collects best practices, listing LangChain, hybrid search that combines vector and keyword retrieval, and reranking for precision. Module 7 is a complete worked example described as a fitness assistant. The capstone asks you to ship your own project covering a searchable knowledge base, the full retrieval flow, an evaluation process using search metrics or LLM-as-a-Judge, a user interface or API such as Streamlit or FastAPI, and monitoring with feedback loops.

The design logic is visible in that ordering. Evaluation arrives in week four, before the best-practices module, so that hybrid search and reranking in week six can be measured rather than assumed. That is a defensible choice and it distinguishes the syllabus from courses that teach retrieval techniques and leave assessment to the end.

Running the Notebooks and Paying for Tokens

The README does not reproduce per-module commands, so the concrete starting point is the repository itself: open the numbered directory for the module you want, for example 01-agentic-rag or 02-vector-search, and work through the notebooks in order. The course expects Python and a terminal, and Docker is listed as a prerequisite, which points at the container-based setup used for the storage and orchestration components. The README gives no single bootstrap command, and I will not invent one.

Two practical constraints are stated plainly. First, hardware: any laptop or PC, no GPU. Embeddings and generation happen through hosted APIs, so the heavy computation is remote. Second, cost: roughly $1 to $5 in API credits for the whole course. That figure is the README's own estimate and will move with which providers you use and how much you re-run. The vector search module names PGVector alongside minsearch and sqlitesearch, so the storage layer spans an in-process option and a Postgres extension, which is where the Docker requirement becomes concrete.

The live cohort is the other half of the setup. Despite the name, all lectures are pre-recorded. The README is direct about this: live means deadlines, graded homework, peer review, a leaderboard, and a certificate. Registration happens through the courses.datatalks.club link, and the cohort schedule and deadlines live on the llm-zoomcamp-2026 page.

The Self-Paced Track Is a Different Course

The README presents live and self-paced as two ways to follow the same material, and then lists what disappears in the self-paced column: no leaderboard, no peer review, no certificate, and homework that is available but not scored. The lectures are pre-recorded in both cases, so the video content is identical. What you lose by going self-paced is every external source of accountability.

This matters more than the table suggests. The capstone requires peer review in the live track, and reviewing someone else's retrieval pipeline is one of the few ways to see failure modes you would not hit in your own dataset. Self-paced learners also lose the graded feedback loop that tells them whether their evaluation module was implemented correctly. If your reason for taking the course is the certificate, the self-paced path cannot produce it. If your reason is the material, the self-paced path is the same material at the same price, which is zero.

The honest framing is that the live cohort is a structured commitment and the self-paced track is a reading list with videos. The README states this without dressing it up, which is to its credit.

Where the Course Stops Short

There are no releases in the repository metadata, and the last push date is listed as 2026-09-10. Course material that tracks fast-moving APIs ages in a way that a pinned library does not. A notebook calling a hosted model endpoint can break when that provider changes a parameter name, and nothing in the repository metadata suggests a versioning scheme that would tell you which cohort a given notebook belongs to. Expect to debug environment and API drift yourself, particularly in the earlier modules.

The license is listed as unknown. That is a real gap for anyone who wants to reuse the notebooks in a company training program or adapt the capstone structure internally. Without a stated license, you cannot assume permission to redistribute the material, and I am not in a position to tell you what the default is. Treat this as something to resolve before building on it commercially.

There is also a scope limit worth naming. The course teaches you to build and evaluate a RAG application. It does not claim to cover serving at scale, cost optimization under load, or the operational work of running a retrieval system for many concurrent users. The monitoring module covers feedback and dashboards, which is observability, not capacity planning. If your production problem is latency or throughput rather than answer quality, this syllabus addresses a different layer.

How It Compares to a RAG Framework

The obvious alternative is a framework such as LangChain or LlamaIndex, and the comparison is not close because the two things are not the same kind of object. A framework gives you abstractions: document loaders, retrievers, chains, and agents behind stable interfaces. You import them, and when retrieval quality is poor you debug inside someone else's abstraction. LLM Zoomcamp has you assemble the retrieval flow yourself, choose between minsearch, sqlitesearch, and PGVector, and then measure the result. LangChain does appear in the syllabus, but as one topic inside Module 6 on best practices, not as the substrate of the course.

That difference has consequences in both directions. A framework gets you to a working prototype in an afternoon; the course takes ten weeks. In exchange, you finish the course knowing why hybrid search beat dense-only retrieval on your data, because you implemented both and evaluated them. The framework user often cannot answer that question without reading the source.

There is a middle path the README implies but does not spell out: take the course, then adopt a framework for the parts you no longer want to maintain by hand. The evaluation and monitoring modules are the ones that transfer most cleanly, since search metrics and LLM-as-a-Judge scoring are framework-agnostic concepts.

Who Should Enroll and What to Check First

The fit is narrow but clear. You should enroll if you write Python comfortably, you want a graded sequence with deadlines pushing you through retrieval, evaluation, and monitoring, and you are willing to spend a few dollars on API credits. Engineers who have built a prototype with an LLM API and hit the wall of not knowing whether it got better or worse are the core audience. Data engineers who want to understand where vector and hybrid retrieval sit in a pipeline are the second.

You should not enroll if you need a maintained library, if the certificate is the point and you cannot make the cohort schedule, or if your problem is serving infrastructure rather than answer quality. You should also pause if you need clear reuse rights, given the unknown license.

Before registering, do two things. Open the 01-agentic-rag and 04-evaluation directories and skim the notebooks to see whether the APIs they call still match what your provider offers today. Then check the cohort schedule page for the current deadline list, because the live track is where grading, peer review, and the certificate live, and the self-paced track is the same videos without any of them.

Editorial conclusion

Take LLM Zoomcamp if you already write Python and want a graded, deadline-driven path through RAG, vector search, evaluation, and monitoring, and you accept spending roughly $1 to $5 in API credits. Skip it if you want a maintained library to import, if you need a certificate, or if you cannot commit to the cohort schedule, because the self-paced track drops grading, peer review, and certification. Before registering, open the 01-agentic-rag and 04-evaluation directories and confirm the notebooks run against current model APIs, since the repository carries no releases and the material is revised between cohorts.

Official sources

1. DataTalksClub/llm-zoomcamp on GitHub
2. Issues
3. Project website
4. README