A good RAG course takes you from “I called an embedding API” to “I can debug why retrieval returned the wrong chunk.” These five DeepLearning.AI picks cover the full retrieval stack: vector storage, embeddings-to-application pipelines, building and evaluating RAG systems, end-to-end RAG fundamentals, and the accuracy work that turns a demo green. Four of them take a single evening each; the fifth is a proper month-long build. The list scales to whatever time you actually have.
Organized by stack layer: storage, then application, then retrieval-plus-evaluation, then accuracy. Four courses each own one layer; the fifth, the full-length RAG build, walks the whole stack in one project.
Read the list that way and the apparent overlap disappears. The two vector database courses differ by direction: one looks down at the index from the application, the other looks up at applications from the index. The advanced retrieval course and the accuracy course differ by phase: one improves what reaches the model, the other improves what comes out of it. And the long course in the middle simply refuses to split the problem at all, which is exactly why it exists. Durations below range from about an hour to about a month, and every course states its level up front, so nothing here will ambush your calendar.
Vector databases
Building Vector Databases with Pinecone (Tim Tully, via DeepLearning.AI, free)
The storage layer. You learn what a vector index actually is (HNSW, flat, IVF), how Pinecone organizes namespaces and metadata filters, and the trade-offs between managed vector databases and rolling your own with FAISS. Tim Tully teaches it as a tour of six working applications, semantic search and RAG among them but also outliers like anomaly detection, which is a useful reminder that vector search is a general similarity engine rather than a chatbot accessory. The right course when you are about to choose a vector store and want to understand what you are buying. Starts at the data layer, not the chatbot.
Level and shape: beginner, about an hour and a half, eight lessons. Because the six applications differ so much, the course doubles as a requirements tool. You leave knowing which problems are vector problems and which merely look like them, and that judgment saves a week of wrong architecture in any first retrieval project.
Course: Building Applications with Vector Databases.
Embeddings to applications
Vector Databases from Embeddings to Apps (Sebastian Witalec, via DeepLearning.AI, free)
The application layer on top of the storage course. Sebastian Witalec teaches the mechanics that sit between your data and your search box: how vector representations of data are actually produced, how similarity search walks an index, and where approximate nearest neighbour trade-offs bite. It finishes on hybrid and multilingual search, the two features teams discover they need right after the first naive demo ships. If the first course is “what is a vector database,” this one is “how do I build a product on one.” Take both if you are shipping retrieval for the first time.
A note on pairing: this course and the one above run in opposite directions, and neither replaces the other. If your job is choosing infrastructure, do the storage course first; if your job is shipping the app, do this one first and backfill the index internals when they become the bottleneck. At an hour each, doing both costs you one long evening.
Course: Vector Databases from Embeddings to Applications.
Building and evaluating RAG
Building and Evaluating Advanced RAG Applications (Jerry Liu and Anupam Datta, via DeepLearning.AI, free)
The best short course on this list. Jerry Liu and Anupam Datta teach it together with LlamaIndex and TruEra, and the focus is the part most teams skip: making retrieval measurably better. You build a baseline pipeline, improve it with sentence-window and auto-merging retrieval, then score both against the RAG Triad of metrics so the improvement is a number, not a vibe. The evaluation half is what separates a working RAG system from a hallucination machine, and this is the course that treats evaluation as the main event rather than an appendix.
The techniques travel further than the tooling. Sentence-window retrieval (embed small, retrieve the surrounding context) and auto-merging (cluster the chunks, retrieve the parent when enough children match) are framework-agnostic ideas, and the scoring discipline is even more so. Even if you never adopt LlamaIndex, the habit of scoring every retrieval change against a fixed eval set is the durable takeaway.
Course: Building and Evaluating Advanced RAG Applications.
Retrieval Augmented Generation (RAG) (Zain Hasan, DeepLearning.AI, free to audit)
The whole pipeline in one course. Zain Hasan teaches RAG as a single connected build, from keyword and semantic search through vector databases and LLM behavior to monitoring a deployed system. It is the only intermediate-level pick here, the only one with graded assignments (ten of them across 49 video lessons), and the only one that assumes real commitment: roughly 26 hours, paced at about five hours a week for a month, with intermediate Python expected. Pick this when you want one course that connects every layer the shorter picks cover separately; it is also available on Coursera if you prefer that platform.
The through-line is production posture. Most short courses end at a working notebook; this one keeps going into deployment and monitoring, on the argument that a RAG system you cannot observe is a RAG system you cannot trust. If your goal is to own retrieval in a real product rather than prototype one, this is the course that matches the job. The graded assignments are the tell that this is a course rather than a lecture series: ten of them, each one a checkpoint on the road from retrieval basics to a monitored deployment.
Course: Retrieval Augmented Generation (RAG).
Improving accuracy
Improving Accuracy of LLM Applications (Sharon Zhou and Amit Sangani, via DeepLearning.AI, free)
The accuracy layer. Once retrieval works, accuracy is the next bottleneck, and Sharon Zhou and Amit Sangani teach it as a loop rather than a trick: build an SQL agent, wrap it in an evaluation, then improve the result with prompting and memory tuning and watch the score move. Just under two hours, intermediate level, relentlessly tactical. The right pick when your RAG demo works on five examples and fails on the sixth, and you need a debugging method, not another API.
The quiet radical move is the ordering: the evaluation comes before the tuning, not after. Most teams discover evaluation once accuracy has already slipped; the course installs the harness first and improves against it, which is exactly the discipline that makes everything else on this page stick in production.
Course: Improving Accuracy of LLM Applications.
If you only do one short course: Building and Evaluating Advanced RAG Applications. It is the fastest route from working retrieval to measured retrieval, which is where most RAG projects actually fail. If you want the whole stack in one build and have a month to spend, begin with the full-length Retrieval Augmented Generation (RAG) course instead. And if your system already works but still disappoints, the accuracy course is the cheapest fix on this page.