Hi everyone! I’m Aqsa Zafar, founder of MLTUT and a Ph.D. scholar in Machine Learning, working mostly in NLP and deep learning. Over the last few years I’ve talked to hundreds of readers who are trying to break into ML, and I keep getting the same message: “I’ve been learning for months, I’ve watched all the videos, why am I not getting anywhere?”

So today I want to lay out the roadmap I’d actually follow if I were starting from zero in 2026, not the one that was popular when I started, and honestly, not even the one I originally followed myself. A few things I did the first time around wasted a lot of my time, and I don’t want you to repeat them.

Let’s get into it.

Step 1: Build Intuition Before You Chase the Math

When I started my own ML journey, I made the mistake of thinking I needed to “master” math before I was allowed to touch a model. I sat with textbooks for weeks, working through proofs I didn’t really need yet. It didn’t make me a better practitioner, it just delayed the point where I actually started learning ML.

Here’s what I’d tell you instead: you need just enough math to not be scared of it, not a math degree.

• Linear algebra: enough to understand what a matrix multiplication is actually doing

• Probability and statistics: enough that Bayes’ theorem and distributions feel familiar, not intimidating

• Calculus: just enough of the chain rule to follow how backpropagation works

That’s genuinely most of it. Everything beyond this, you pick up as a specific project demands it, not before.

For building this intuition, I usually point beginners to Andrew Ng’s Machine Learning Specialization on Coursera, it’s still one of the best places to get a visual, intuitive feel for these concepts without drowning in derivations.

Give yourself two to three weeks here, max. This step is about building a mental map, not becoming an expert. If you’re still “learning the fundamentals” three months in, that’s a sign you’re stuck in prep mode instead of doing the work.

Step 2: Get a Working Understanding of Traditional ML

Before jumping into anything fancy, you need to know the basic vocabulary of the field:

• What’s the difference between classification and regression?

• How do tree-based models differ from linear models and neural networks?

• What does “overfitting” actually look like in practice?

You don’t need mastery yet, just enough that when someone mentions “gradient boosting” or “random forest,” you’re not lost.

This is a good point to pick up a structured course rather than piecing things together from scattered YouTube videos. I usually recommend DataCamp’s Machine Learning Fundamentals track for this stage, it’s hands-on, keeps you writing code from day one instead of just watching slides, and it pairs well with the next step, which is Python.

Step 3: Actually Learn Python Properly

I cannot stress this enough, Python is non-negotiable for ML. scikit-learn, PyTorch, TensorFlow, basically everything you’ll touch is Python-based.

At this stage, focus on:

• Core Python (data types, control flow, functions, working with files)

• NumPy, for anything involving arrays and matrix operations

• pandas, for working with real, messy tabular data

If you’ve never coded before, DataCamp’s Python for Data Science track is a solid, structured way to go from zero to comfortable without getting overwhelmed. I recommend it a lot to readers who tell me “I don’t even know where to start.”

Step 4: Don’t Just Call .fit() — Understand What’s Happening

This is a trap I see constantly. Someone learns just enough scikit-learn to call .fit() on a model, gets a score back, and assumes they understand machine learning now. They don’t, they understand how to call a function.

The thing that actually built my intuition was implementing algorithms from scratch using only NumPy. Logistic regression, k-means, decision trees, writing these out step by step, watching the data move through each part of the algorithm, made the math click in a way that reading about it never did.

I build a NumPy course on My YouTube Channel, you can watch it here- Learn NumPy from Scratch

This isn’t just an academic exercise either, ML interviews frequently ask you to implement these exact algorithms from scratch, so this step doubles as interview prep. Two birds, one stone.

Step 5: Build Projects That Actually Prove Something

Here’s something I’ve noticed reviewing dozens of portfolios: the people who get interview callbacks and the people who don’t often have studied roughly the same amount. The difference is almost always what’s sitting on their GitHub.

Most beginner portfolios are full of course exercises and Kaggle notebooks where the data, the problem, and even the scoring were handed to them. A hiring manager looking at that learns almost nothing about whether you can actually do the job.

What you want instead is a project where you made the decisions:

• You picked the problem

• You found or scraped the data

• You decided how to evaluate success

• You deployed something a real person could actually use

For example, if you’re into personal finance, you could build a model that predicts which subscriptions someone is likely to cancel based on usage patterns, and wrap it in a small dashboard. Or if you’re into health and wellness (an area close to my own research), you could build a simple tool that flags concerning patterns in a small, ethically-sourced dataset. Small in scope is fine. What matters is that every decision was yours.

And don’t stop at a notebook. A project that’s containerized with Docker, deployed somewhere like AWS or GCP, tracks experiments with MLflow or Weights & Biases, and has even a basic CI/CD pipeline tells a hiring manager you can operate like an engineer, not just a student.

If you want a structured, guided way to build a production-style project without having to figure out deployment on your own from scratch, Udacity’s Machine Learning Engineer Nanodegree is built almost entirely around this, I reviewed their Agentic AI Nanodegree recently on my site and came away genuinely impressed with how project-focused it is.

Step 6: Don’t Skip Generative AI Anymore

A year or two ago, I’d have told you to get classical ML rock-solid before worrying about Gen AI at all. I’ve softened on that. Classical ML foundations still matter, you need them to understand evaluation, and if you’re aiming at fields like healthcare or finance, interpretable models are often a requirement, not a preference. But even areas like fraud detection and recommendations are increasingly leaning on Gen AI approaches now.

Practically, two things matter most here:

RAG: not just building a retrieval pipeline, but knowing when retrieval is the right call versus fine-tuning versus simply writing a better prompt.

Evals: building evaluation pipelines for Gen AI systems is a huge, underrated chunk of the job right now, and very few beginners know how to do it properly.

Beyond that, get comfortable with agents and tool use, prompt engineering for production systems, and basic security concerns like prompt injection.

Udemy has a lot of good, affordable, project-based courses specifically on RAG and LLM applications if you want something hands-on rather than theory-heavy, I’d rather point you there than a dense research paper if you’re just starting out with Gen AI engineering.

On my YouTube Channel, I also made videos on

• Build a Local RAG App In 26 Minutes (Ollama + ChromaDB + Flask)

• Build an AI Agent That Organizes Your Files In 13 Minutes (Ollama + Llama 3.2)

• Build a RAG Chatbot That Doesn’t Hallucinate | Python + LangChain

• Build an AI Chatbot That Works With No Internet (Step by Step)

One more thing on this: use AI tools to help you learn, but don’t let them think for you. There’s a real “fluency illusion” where an AI gives you a clean answer, you nod along, and you walk away feeling like you understood it, when really you skipped the part where your brain does the work that makes it stick. Use AI to explain, to quiz you, to unblock you. Don’t use it to skip understanding.

Step 7: Prepare for Interviews Properly

I wish I could tell you that coding interviews are going away for ML roles. They’re not, at least not everywhere. Some companies have moved toward more AI-native interviewing, but plenty of the bigger names still run a LeetCode-style round alongside ML-specific questions. Budget time for this, it’s a separate skill from ML itself.

Step 8: Don’t Underestimate Your Network

Last thing, and it matters more than people want to admit: who you know affects your callback rate. You don’t need connections handed to you, you can build them. Go to conferences, be genuinely active in online ML communities, comment thoughtfully on people’s work, reach out with real questions instead of generic “can you refer me” messages. Networking is one of the highest-leverage things you can do in this field, and it costs nothing but consistency.

Final Thoughts

The path into ML today looks different from the one I walked a few years ago, faster in some ways, but with a lot more ground to cover, especially with Gen AI now a baseline expectation rather than a bonus skill. It’s not a short road. But it is a very learnable one if you follow it in the right order: intuition, fundamentals, real projects, Gen AI skills, and then interviews and networking — not the other way around.

If you found this helpful, I write more roadmaps and tutorials like this over at MLTUT, and I’d love to have you there.

Happy Learning!

Do you wanna learn RAG (Retrieval Augmented Generation)? If yes, then this blog is just for you. Here I will share a complete list of RAG resources- starting with a few free ones, and then the best paid courses on Coursera, Udemy, DataCamp, and Udacity. So, give your few minutes to this article and pick the right resource for yourself.

Hello, & Welcome!

Before going further, a quick note on why I am writing this-

I made a basic, 30-minute RAG explainer video on my own YouTube channel a while back. It’s nothing deep, just enough to understand what RAG actually is and why it matters. While putting that together and going through other people’s content on RAG, I went through a bunch of free tutorials and a few of these paid courses myself to see what’s actually worth your time and what’s just repackaged documentation. This list is a mix of that personal experience and proper research, not just a copy-paste of course descriptions.

Now let’s get into it-

What is RAG and why should you learn it?

You already know that Large Language Models (LLMs) like ChatGPT or Claude are trained on a fixed set of data. So, what happens when you ask them something about your own company’s documents, or something that happened after their training cutoff?

They either say “I don’t know” or worse, they hallucinate (means they confidently give you a wrong answer).

This is exactly the problem RAG solves.

RAG connects an LLM to an external knowledge source (your documents, your database, your PDFs) and retrieves the most relevant information at the time you ask a question. Then it passes that information to the LLM so it can generate an accurate, grounded answer.

In simple words- RAG = Retrieval (search your data) + Generation (LLM writes the answer using that data).

That’s why almost every real-world AI chatbot, internal company assistant, or customer support bot you see today is built on top of RAG.

Now, let’s go through the resources, starting with the free ones.

Free RAG Resources

If you just want to understand RAG without spending a rupee or a dollar, start here.

1. What is RAG? Explained in Under 30 Minutes – YouTube (mine)

This is my own video, so I’ll keep it honest- it’s basic, nothing deep. I made it for people who keep hearing “RAG” everywhere and just want a clear, no-jargon explanation of what it is, how it works step by step, and where it actually fails in practice.

Best for- Someone who wants the “what and why” in half an hour, before deciding if they want to go deeper.

Link- What is RAG? Retrieval Augmented Generation Explained in Under 30 Minutes

2. RAG From Scratch – YouTube Playlist (LangChain)

This is a free video series put together by the LangChain team itself. It builds up your understanding of RAG piece by piece- starting from the basic concept of connecting LLMs to external data, and going into more technical depth as the series progresses.

Best for- Anyone who wants a free, structured, video-based path that goes deeper than a single explainer video.

Link- RAG From Scratch playlist on YouTube

3. Fundamentals of AI Agents Using RAG and LangChain – Coursera (IBM, Free to Audit)

This one’s from IBM and goes a bit further than the other free options. It covers the full RAG process, encoders, tokenizers, the FAISS library for vector search, prompt engineering, and how LangChain ties it all together. You also get hands-on labs using Hugging Face and PyTorch.

Best for- Beginners who want a free course backed by a known company (IBM), with actual hands-on labs instead of just videos.

Link- Fundamentals of AI Agents Using RAG and LangChain on Coursera

Paid RAG Courses (Coursera, Udemy, DataCamp, Udacity)

Once you’ve got the basics down for free, these paid courses go deeper into building production-ready RAG systems.

4. Retrieval Augmented Generation (RAG) – Coursera (DeepLearning.AI)

If you want to learn RAG from the people who literally teach half the AI industry, this is a solid next step after the free resources above.

Across five modules, you build progressively more advanced parts of a RAG system- starting from a simple retrieval + prompt augmentation prototype, all the way to production-ready components like hybrid retrieval, reranking, and evaluation. You also get to work with real datasets from e-commerce, media, and healthcare.

What you’ll learn-

• How retrievers, vector databases, and LLMs fit together

• Chunking, query parsing, and reranking techniques

• How to evaluate a RAG system at both component and system level

Best for- Anyone who wants a structured, no-fluff foundation in RAG after covering the basics.

Link- Retrieval Augmented Generation (RAG) on Coursera

5. Introduction to Retrieval Augmented Generation (RAG) – Coursera (Guided Project)

Confused about where to start coding? Don’t worry, this one’s for you.

This is a short, 2-hour, hands-on Guided Project. You will import data into Pandas, create embeddings using SentenceTransformers, and build a working RAG system using Qdrant and an LLM. The video plays side-by-side with your workspace, so you literally code along with the instructor.

What you’ll learn-

• How to set up a basic RAG pipeline end-to-end

• Working with vector databases like Qdrant

• Connecting your pipeline to an LLM

Best for- Beginners who want to “see it work” with their own hands, in under a couple of hours.

Link- Introduction to Retrieval Augmented Generation (RAG) on Coursera

6. Ultimate RAG Bootcamp Using LangChain, LangGraph & LangSmith – Udemy

This one is for the folks who don’t want a “basic RAG” course. They want the whole package.

This bootcamp takes you from traditional RAG pipelines all the way to Agentic RAG architectures used in production. You’ll work with multiple vector databases (FAISS, Pinecone, Weaviate), implement hybrid search, build multimodal RAG (text + images), and even use LangSmith to track and debug your pipelines.

What you’ll learn-

• Advanced retrieval strategies (hybrid search, vector optimization)

• Multi-agent, autonomous RAG pipelines using LangGraph

• Domain-specific chatbots and multimodal AI assistants

Best for- Developers who already know RAG basics and want to go “advanced and agentic.”

Link- Ultimate RAG Bootcamp Using LangChain, LangGraph & LangSmith on Udemy

7. Build AI Retrieval-Augmented Systems (RAG) – Udemy

Do you learn better by building something real rather than just watching lectures? Then this course is for you.

This is a step-by-step, project-based course where you build a fully working RAG system that reads your documents and answers questions with cited, grounded answers. By the end, you will have built and deployed a real RAG application using Streamlit and the OpenAI API.

What you’ll learn-

• Connecting retrieval and generation into one working pipeline

• Building an interactive Streamlit app for document chat

• Deploying your RAG system to Streamlit Cloud

Best for- Beginners and intermediate learners who want a portfolio-ready project, not just theory.

Link- Build AI Retrieval-Augmented Systems (RAG) on Udemy

8. Retrieval Augmented Generation (RAG) with LangChain – DataCamp

If you like structured, bite-sized lessons with interactive coding exercises (instead of long video lectures), DataCamp’s style will suit you well.

This course goes a level deeper than “basic RAG with LangChain.” You’ll learn to load and split code files in a way that respects code syntax, split documents by tokens instead of characters so nothing overflows your model’s context window, and even explore Graph RAG as an alternative to vector-based retrieval.

What you’ll learn-

• Advanced document loading and splitting strategies

• Self-query retrieval and evaluation frameworks for RAG

• Basics of Graph RAG

Best for- Learners who prefer DataCamp’s hands-on, in-browser coding style.

Link- Retrieval Augmented Generation (RAG) with LangChain on DataCamp

9. Retrieval Augmented Generation with LlamaIndex – DataCamp

LangChain is not the only framework in town. If you want to explore the LlamaIndex side of RAG, this one’s for you.

This course teaches you advanced RAG methods like dense retrieval, reranking, and multi-step reasoning, which directly help tackle issues like hallucination and ambiguous queries. It’s a great companion course if you’ve already done a LangChain-based RAG course and want to compare frameworks.

What you’ll learn-

• Building RAG pipelines using LlamaIndex

• Reranking approaches to improve retrieval quality

• Multi-step reasoning techniques for complex queries

Best for- Learners who want to compare LlamaIndex vs LangChain for RAG.

Link- Retrieval Augmented Generation with LlamaIndex on DataCamp

10. Master LLMs and RAG – Udacity

Want something more structured, like a proper course with instructors from real companies, rather than a one-off tutorial? Udacity’s course fits that need.

This course doesn’t just teach you RAG in isolation. It first builds your understanding of LLM architecture, tokenization, and attention, then moves into prompt engineering and model selection trade-offs, and only then dives deep into RAG- covering naive vs advanced modular RAG, vector database indexing (HNSW), and advanced retrieval techniques like HyDE and reranking. By the end, you build an end-to-end RAG chatbot using real NASA mission data and evaluate it using RAGAS.

What you’ll learn-

• Naive vs advanced modular RAG architecture

• Semantic search, vector databases, and indexing algorithms

• Evaluating RAG systems using RAGAS metrics

Best for- Learners who want a complete, guided path from LLM fundamentals to a finished RAG project.

Link- Master LLMs and RAG on Udacity

Conclusion

RAG is no longer an “optional skill” for AI practitioners. Whether you are a data scientist, ML engineer, or just an AI enthusiast, RAG is something you will run into in almost every real-world LLM application you build or work on.

I started this list with free resources (including my own basic explainer) on purpose- there’s no need to spend money before you’re even sure RAG is something you want to go deep into. Once you’ve got the fundamentals down for free, the paid courses above will help you go from “I understand RAG” to “I can build and deploy a real RAG system.”

If you have already taken any of these courses, let me know in the comments how your experience was. And if you pick one after reading this, I would love to know which one you chose!

Happy Learning!

Disclosure- This post contains affiliate links. If you sign up for a course through one of these links, I may earn a small commission at no extra cost to you. I only recommend courses I genuinely think are worth your time.

In my last post, I explained What is RAG. But there's one part I skipped over, how does the AI actually find the right document so fast, out of hundreds or thousands of files? That part has a name, it's called a Vector Database. So in this article, I am gonna break that down too.

So give your few minutes and learn about Vector Databases and why every AI tool you use is secretly built on top of one.

So, without further ado, let’s get started-

What is a Vector Database?

Before moving to the working of a Vector Database, I would like to tell you about the actual problem it solves.

Suppose you have a search bar, and you type the word “dog.” A normal search bar will look for the exact word “dog” in all your documents. But what if your document has the word “puppy” instead? A normal search bar will completely miss it. Because for a computer, “dog” and “puppy” are two different words, even though for us, they basically mean the same thing.

This is the actual problem. Computers are good at matching exact text, but they are not good at understanding meaning. That’s where a Vector Database comes in.

So, this is the basic problem. Now let's understand what a vector actually is.

What is a Vector, Actually?

A vector is nothing but a list of numbers. That’s it. That list of numbers represents something, it could be a word, a sentence, a paragraph, or even an image.

Do you think? How can numbers represent a word?

Let me explain with an example you already know, GPS location.

When you share your location with a friend, you don’t say “I’m near the big tree, past the blue gate, next to the shop.” You just send two numbers, latitude and longitude. Those two numbers tell exactly where you are on the map.

A vector works the same way. Except instead of 2 numbers showing your location on Earth, it might have hundreds of numbers showing the “location” of a word or sentence in a giant space of meaning.

So when an AI model converts the word “dog” into a vector, it is basically giving “dog” a coordinate. And the word “puppy” gets a coordinate very close to it. Because their meaning is close too.

A vector database is not magic. It’s just a smart way of storing meaning as numbers, and then searching by closeness instead of by exact words.

The Map of Meaning

Now imagine a huge map. But instead of cities, this map has words placed on it. Words with similar meaning are placed close together. Words with different meaning are placed far apart.

As you can see in this image, “dog,” “puppy,” and “canine” are placed close together, because they mean almost the same thing. “Apple,” “banana,” and “mango” form their own group. And “sadness” is sitting all alone, far from everything, because it has nothing to do with the other words.

So a Vector Database is basically the system that stores all these coordinates. And when you ask a question, it just finds whatever is closest to your question on this map. That’s the whole idea.

How Does a Vector Database Actually Work?

Now Let’s understand the working in steps. There are mainly 4 steps involved-

1. Convert text into a vector (this step is called embedding)

2. Store the vector in the database along with the original text

3. Convert your search query into a vector too

4. Find the closest vectors and return their original text

Let’s understand each step one by one.

1. Embedding- Converting Text into Numbers

Every sentence or document you want to store first passes through an embedding model. This model converts your text into a vector, that long list of numbers we talked about earlier.

text = "I love machine learning"
vector = embedding_model.encode(text)

# Output (simplified)
# vector = [0.21, -0.08, 0.44, 0.12, ......]

So now this sentence is no longer just text, it’s a point in a giant space of meaning.

2. Storing the Vector

This vector, along with the original text, gets stored inside the vector database. Most popular vector databases right now are Pinecone, Chroma, Weaviate, and Qdrant. You don’t need to memorize all these names, just know that these tools exist for exactly this purpose.

3. Converting Your Question into a Vector

When you type a question, like “What is machine learning?”, that question also gets converted into a vector using the same embedding model.

4. Finding the Closest Match

Now the database compares your question’s vector with every vector it has stored. And it finds whichever ones are sitting closest. This closeness is usually measured using something called cosine similarity, but you don’t need to worry about the math behind it right now. Just remember, closer vectors mean closer meaning.

And that's the whole working procedure. Not that complicated once you break it down, right?

If you want to see this whole process explained visually with a real walkthrough, I made a full video on it. Watch it here-

Where is Vector Database Used in Real Life?

Now you might be thinking, “Okay Aqsa, but where do I actually see this in action?” So let me give you a few real examples-

1. RAG Systems- Remember my previous post on RAG? The retriever part, the one that searches your documents, runs on a vector database in the background. This is literally the missing piece that connects both topics.

2. Product Recommendations- When a shopping site shows “similar products,” it’s often comparing vectors of products, not just matching categories.

3. Music and Video Recommendations- Apps that suggest songs based on “vibe” rather than just genre are comparing vectors of how the content sounds or feels.

4. Chatbots and Customer Support- Any chatbot that searches through your company’s documents to answer a question is most likely using a vector database under the hood.

Vector Database vs Normal Database

I know at this point, you might be confused, what’s the difference between this and a normal database you already know? Let me clear it up-

• Normal database stores exact values, and searches using exact match or filters. Good for something like “find the customer with ID = 5.”

• Vector database stores meaning as numbers, and searches by closeness. Good for something like “find documents similar to this question.”

One thing you need to remember is, a vector database doesn’t replace a normal database. Most real systems use both together. Normal database for structured facts like price, ID, date. Vector database for anything that needs understanding of meaning, like text, images, or questions.

Conclusion

I tried to explain Vector Databases in a simple and easy to understand way. Hope you understood.

To summarize everything-

• Normal search matches exact words, and misses things phrased differently

• A vector is just a list of numbers that represents meaning

• A vector database stores these numbers and finds the closest match when you search

That’s it. Not magic, just a smart way to store meaning so a computer can finally search through it the way our brain naturally does.

I would suggest you go try a tool like Chroma yourself, it’s free and beginner friendly. And if you have any doubts, feel free to ask me in the comments. I would like to help you.

Happy Learning!

Okay, real talk for a second.

When I first heard the term “RAG,” I had zero idea what it meant. But once someone explained it to me in plain English, not in a research paper, not in a two-hour lecture, it made total sense.

So that is exactly what I am going to do for you today. I will explain RAG the way I wish someone had explained it to me: simply, with examples you actually recognise from real life.

"RAG changed how I think about what AI can and cannot do. Once you understand it, you will see it everywhere."

Starting from the very beginning.

First, the problem

You have probably used ChatGPT or any AI assistant and noticed something odd. You ask it about something that happened last week and it either gives you wrong information or says it does not know.

Why? Because AI models have a knowledge cutoff, a date after which they were not trained on any new information. Think of it like this:

Imagine you studied hard for an exam in 2024. You memorised everything up to that point. Then someone asks you about news from last Tuesday. You would have no idea, because that happened after you finished studying.

That is exactly what happens with AI. It was trained up to a certain date and then stopped learning. So when you ask it about your company’s internal documents, your latest research, or anything recent, it either guesses or says it does not know.

So... what is RAG?

RAG stands for Retrieval-Augmented Generation. I know, still sounds technical. But broken down word by word, it makes sense.

📚 Retrieval

• Go find the right information

• Search through documents

• Pick the most relevant bits

✍️ Generation

• Use AI to write an answer

• Combine what was retrieved

• Produce a clear response

Put those together: find the right information, then use AI to form a good answer from it. That is RAG.

The library analogy

Here is the best way I can explain it. Picture two students. Both are smart. Both have been studying hard.

Student A walks into the exam using only what is in their head. They might do fine on familiar topics but will struggle, or guess, on anything outside their memory.

Student B is allowed a reference book. Not to cheat, but to look things up accurately when needed. They still need to understand what they are reading. But their answers are grounded in actual sources.

RAG makes AI into Student B.

How does RAG actually work? (step by step)

Now you have the idea. Here is what actually happens under the hood when RAG is running.

1. You ask a question

You type something like: “What is our leave policy for new employees?” Simple enough, but the AI does not have this in its training data.

2. The system searches your documents

Before the AI even tries to answer, RAG searches through documents you have given it, PDFs, notes, databases, websites. It finds the most relevant pieces.

3. The relevant bits get pulled out

Think of someone highlighting the parts of a document that actually answer your question. RAG pulls those chunks and passes them along.

4. The AI reads those bits alongside your question

Now the AI gets: “Here is the relevant info from the documents, and here is the question. Now answer it.” It reads both at the same time.

5. You get a grounded, accurate answer

The AI forms a response using the information it just retrieved. It can even tell you exactly which document it got the answer from.

Real world examples you can relate to

Here are three places where RAG is being used right now:

Customer support bots- When you chat with a company’s support bot and it knows their exact return policy? That is RAG. The bot is not guessing, it is pulling the answer straight from the company’s internal documents.

Medical research tools- Doctors using AI to search through thousands of research papers and get answers about specific treatments? RAG. The AI retrieves the relevant studies first, then summarises only what matters.

Studying and personal notes- Tools like NotebookLM where you upload your notes and ask questions about them? That is RAG. You are giving the AI your own documents to reference before it answers.

Without RAG vs. With RAG

Here is a side-by-side so you can see exactly what the difference looks like:

Why does this matter for you?

You might be thinking: “Okay Aqsa, this is interesting but how does this affect me?”

Here is the honest answer: RAG is what allows AI to become genuinely useful for your specific life, your specific work, your specific documents, not just general knowledge that anyone could Google.

Without RAG, AI is a very smart person who only read books up to a certain year. With RAG, that same person now has access to your personal library, your company’s files, your research, your notes, and can answer questions about all of that accurately.

That is the difference between an AI tool you play around with once and one you actually rely on every single day.

Want to see this explained visually?

I made a full video breaking down RAG with animations and more depth. If reading is not your thing, go watch it below:

Learn RAG in-depth on YouTube

Quick recap

RAG = Retrieval-Augmented Generation. Here is what you now know:

→ AI has a knowledge cutoff. It stops knowing things after a certain date.

→ RAG solves this by letting AI search through documents before answering.

→ The result is answers that are grounded, accurate, and specific to YOUR information.

That is it. You now understand RAG better than most people who work in tech.

Next time someone says “this chatbot uses RAG,” you will know exactly what they mean and why it matters. That is the whole point of everything I make. I want you to feel confident, not lost.

Happy Learning!

Best RAG Tutorials & Courses

1. Introduction to Retrieval Augmented Generation (RAG) – Guided Project (2 hours, Intermediate)

2. Generative Adversarial Networks (GANs) Specialization – Coursera (3 months, Intermediate)

3. Large Language Models (LLMs) & Text Generation – Udacity (4 weeks, Intermediate)

4. Building Generative AI Solutions – Udacity (4 weeks, Intermediate)

5. OpenAI GPTs: Creating Your Own Custom AI Assistants – Coursera (7 hours, Beginner)

6. Master Retrieval-Augmented Generation (RAG) Systems – Udemy (1.5 hours, Intermediate)

7. Large Language Models (LLMs) Concepts – DataCamp (2 hours, Intermediate)

8. Operationalizing LLMs on Azure – Duke University (10 hours, Intermediate)

Most RAG pipelines are doing a sophisticated version of ctrl+F. That’s not a criticism, it’s often exactly what you need. But there’s a class of questions it fundamentally cannot answer, and understanding why reveals something important about how AI systems retrieve knowledge.

Retrieval-Augmented Generation changed how large language models access information. Instead of relying solely on what they learned during training, RAG lets models pull in fresh, external knowledge at query time. You embed your documents, store those vectors in a database, and when a user asks something, you find the most semantically similar chunks and feed them into the prompt. The LLM gets context; the user gets a grounded, current answer.

It works. Until it doesn’t.

The fundamental problem with similarity search

Imagine you’ve built a RAG system over a detailed company knowledge base, product documentation, internal wikis, engineering specs, customer records. A user asks: “What decisions led to the current API rate limiting policy, and which teams were involved?”

Traditional RAG will find chunks that semantically match “API rate limiting policy.” It might return the policy document, a ticket that mentions rate limits, maybe a blog post. But each chunk arrives alone, stripped of the organisational context, the causal chain, the team relationships. The LLM has to infer the connections from fragments that weren’t retrieved because they weren’t similar enough to the query surface. It might get there. Or it might hallucinate the gaps.

Traditional RAG asks: “what text sounds like this question?” Graph RAG asks: “what surrounds this concept, and how does it connect to everything else?”

This is the retrieval gap. It’s not a failure of the embedding model or the vector database, it’s structural. Flat text chunks cannot carry relational information. They are, by design, isolated units of similarity.

What Graph RAG actually does differently

Graph RAG doesn’t replace the embedding + retrieval pipeline, it extends it with a knowledge graph layer. Here’s where the two approaches diverge from the very first step.

Traditional RAG pipeline

1. Documents → Embedding model. Your corpus is encoded into dense vectors.

2. Index into vector database. Vectors are stored and indexed for fast lookup.

3. Query is encoded. The user’s question becomes a vector too.

4. Similarity search. Find the top-k vectors closest to the query vector.

5. Retrieve similar documents. The matching chunks come back from the database.

6. Prompt the LLM. Retrieved chunks + query are handed to the model.

7. Final response. The LLM generates an answer grounded in retrieved context.

Graph RAG pipeline

1. Documents → LLM Graph Generator. An LLM reads the corpus and extracts entities (people, concepts, events) and the relationships between them.

2. Entities and relationships stored as graph nodes and edges. Not flat text, structured facts with typed connections.

3. Graph nodes encoded as embeddings. Each concept gets a vector home, giving dual access modes.

4. Similarity search + graph traversal. At query time, the system finds entry points semantically, then fans out through connected nodes.

5. Everything lands in a graph database. One structure, two retrieval modes, vector and graph.

6. Query encoded and entity-linked. The question is vectorised and mapped to known graph nodes simultaneously.

7. Relevant context retrieved via graph traversal. Entry points expand to neighbours, pulling in the web of related facts.

8. Relevant context assembled. Nodes, edges, and surrounding text combine into a richer context package.

9. Prompt the LLM. Context + nodes + relationships + query, a structurally-grounded prompt.

10. Final response. Generated from connected knowledge, not just similar-sounding passages.

The visual in the image above captures this cleanly. The traditional pipeline is a tight loop. The graph pipeline has a second phase that runs before retrieval even starts, graph construction, and a richer retrieval mechanism that operates on structure, not just statistics.

Where each approach genuinely wins

Traditional RAG

• Fast to set up, embed, index, go

• Handles large unstructured corpora well

• Efficient updates, no reindexing overhead

• Low upfront infrastructure cost

• Scales predictably with data volume

• Ideal for self-contained queries

Graph RAG

• Captures entities and how they relate

• Multi-hop reasoning comes naturally

• More explainable retrieval paths

• Rich context, not just similar text

• Performs well on relational domains

• Dual retrieval: semantic + structural

The real tradeoffs: Graph RAG demands significant upfront work to build and maintain the knowledge graph. When new data arrives, the graph may need reindexing, unlike vector RAG where you simply add new embeddings. Highly-connected generic entity types can also skew results if not filtered carefully. It's not a free upgrade; it's a different architectural bet.

When should you actually reach for Graph RAG?

The honest answer: not always. The graph overhead is real, and for many use cases, well-tuned traditional RAG is the better choice. Here’s how to think about it.

The practical signal: if your users are asking questions that require joining context across multiple documents, following dependencies, or reasoning through causal chains, you’re hitting the ceiling of what flat retrieval can do. That’s when the graph layer earns its cost.

The deeper shift this represents

What Graph RAG really points to is a change in how we think about AI knowledge retrieval. The traditional model is essentially information-theoretic: find text that is statistically close to the query. It’s powerful, well-understood, and scales cleanly.

Graph RAG is trying to do something more like reasoning: not “what text is similar?” but “how does this concept fit into the web of everything we know?” That’s a fundamentally different question, and it requires a fundamentally different data structure to answer it.

As the Memgraph team puts it well: retrieval alone is not enough when data is inherently interconnected. The future of AI knowledge systems likely involves both, vector retrieval for fast semantic access, graph traversal for structural reasoning, working together as complementary layers rather than alternatives.

“RAG retrieves relevant chunks. Graph RAG retrieves relevant context. That gap, in the right domain, is everything.”

If you’re building a production RAG system today, the question isn’t whether to use Graph RAG, it’s whether your data and your users’ questions have the relational structure that makes the graph investment worthwhile. Start by auditing the questions your system gets wrong. If they cluster around multi-hop reasoning and entity relationships, you have your answer.

Watch the full visual breakdown

Graph RAG explained: step by step on YouTube👇

Watch Now

It’s not. Let me break it down the way I actually understand it.

Subscribe now

First, what even is the problem?

Your neural network makes a prediction. That prediction is wrong. Now what?

The network has hundreds, sometimes millions, of weights. How does it know which ones caused the problem and by exactly how much? If you just randomly adjusted weights hoping things get better, you’d be there forever.

That’s the problem backpropagation solves. It gives every single weight a precise number, its gradient, that says “here’s how much you contributed to the error, and in which direction you need to move to fix it.”

Without this, neural networks couldn’t learn. Full stop.

Before backprop runs, there’s a forward pass

Every time your network sees a training example, it does a forward pass first.

Input goes in → flows through hidden layers → activation functions fire → output comes out.

You then compare that output ŷ with the real answer y using a loss function. The most common one for regression is Mean Squared Error:

L = (1/m) Σ (ŷ − y)²

This single number, the loss, tells you how wrong the network is overall. But it doesn’t tell you why it’s wrong or what to fix. That’s backprop’s job.

Now the backward pass, this is where the learning actually happens

Backpropagation works by going backwards through the network, layer by layer, using the chain rule from calculus.

The chain rule basically says: if one thing depends on another, which depends on another, you can find the total effect by multiplying the individual effects together.

In a neural network, the loss depends on the output, which depends on the weights in the last layer, which depend on the layer before that, and so on. Backprop chains all of this together systematically.

Step 1 — Gradient at the output layer:

δ(L) = ∂L/∂a(L) ⊙ f′(z(L))

For MSE with sigmoid specifically:

δ(L) = (a(L) − y) ⊙ f′(z(L))

The ⊙ symbol means element-wise multiplication. f′ is the derivative of your activation function.

Step 2 — Gradient at any hidden layer l:

δ(l) = (W(l+1))ᵀ δ(l+1) ⊙ f′(z(l))

You’re taking the error signal from the layer in front, passing it back through the transposed weights, and multiplying by the local derivative. This is how error flows backward.

Step 3 — Compute weight and bias gradients:

∂L/∂W(l) = δ(l) (a(l−1))ᵀ

∂L/∂b(l) = Σ δ(l)

These are the actual gradients you use to update your weights. The sum for biases is over all training examples in the batch.

Why sigmoid? What’s its derivative?

Sigmoid is one of the most commonly used activation functions, especially when you’re learning the basics:

sigmoid(x) = 1 / (1 + e⁻ˣ)

Its derivative has a really clean form:

sigmoid′(x) = sigmoid(x) × (1 − sigmoid(x))

This is why sigmoid is popular for teaching, the math stays clean. In practice though, ReLU and its variants are used more often in deep networks because sigmoid can cause vanishing gradients in very deep architectures. But that’s a topic for another post.

Let’s see this in actual Python: a 2-2-1 network from scratch

No PyTorch, no TensorFlow. Pure NumPy so you can see every single operation:

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

# Input and target
x = np.array([[0.5, 0.1]])
y_true = np.array([[1.0]])

# Initialize weights and biases
np.random.seed(42)
w1 = np.random.randn(2, 2)
b1 = np.zeros((1, 2))
w2 = np.random.randn(2, 1)
b2 = np.zeros((1, 1))

# Forward pass
z1 = np.dot(x, w1) + b1
a1 = sigmoid(z1)
z2 = np.dot(a1, w2) + b2
a2 = sigmoid(z2)

# Loss (MSE)
loss = np.mean((a2 - y_true) ** 2)

# Backward pass
m = y_true.shape[0]

dz2 = (2/m) * (a2 - y_true) * sigmoid_derivative(z2)
dW2 = np.dot(a1.T, dz2)
db2 = np.sum(dz2, axis=0, keepdims=True)

dz1 = np.dot(dz2, w2.T) * sigmoid_derivative(z1)
dW1 = np.dot(x.T, dz1)
db1 = np.sum(dz1, axis=0, keepdims=True)

print(f"Loss: {loss:.4f}")
print(f"dW2: {dW2}")
print(f"dW1: {dW1}")

Output:

Loss: 0.0971
dW2: [[-0.00141853]
      [-0.00312015]]
dW1: [[ 1.44911558e-03 -6.26849107e-04]
      [ 3.19130741e-03 -1.38085749e-03]]

Each value in dW1 and dW2 is the gradient for that weight. A positive gradient means the weight should decrease to reduce loss. Negative means it should increase. Gradient descent then takes these and updates the weights:

W = W − learning_rate × dW

Do this thousands of times across your training data and your network actually learns.

The thing most beginners miss about backprop

People often think backprop is complicated because of the math notation. But conceptually, there are only three questions it’s answering:

1. How wrong are we? (the loss)

2. Who is responsible and by how much? (the gradients)

3. In which direction should each weight move to do better? (the sign of the gradient)

Everything else, the deltas, the transposes, the chain rule, is just the machinery to answer those three questions precisely.

What comes after you understand this?

Once backprop clicks, a lot of other things start making sense too, why vanishing gradients are a problem in deep networks, why weight initialization matters, why batch normalization helps training, and how optimizers like Adam improve on basic gradient descent.

Backprop is honestly the foundation. Get this right and you’ll read any deep learning paper with a much stronger intuition.

If you want to go deeper and actually build serious deep learning skills, I put together a list of the best advanced deep learning courses I’ve personally gone through and recommend:

👉 8 Best Advanced Deep Learning Courses

When I started learning machine learning, I made one mistake.

I learned randomly.

One week statistics.
Next week, deep learning.
Then some random Kaggle notebooks.

It took me some time to realize something simple:

You don’t need more courses. You need structure.

If you’re starting today, this guide will give you that structure.

In this roadmap, you’ll understand:

• What to learn

• Why you’re learning it

• The right order to learn things

• Which resources are actually useful

• How to move from beginner to job-ready

This is not an overwhelming list of courses.

It’s a clear and practical path.

Step 1: Build Your Foundation (Month 1–2)

Before machine learning, you need three basics:

→ Python
→ Math fundamentals
→ Data handling

Let’s break this down.

1. Learn Python the Right Way

You don’t need to master all of Python.

Focus on:

• Variables and data types

• Lists, dictionaries, sets

• Loops and functions

• File handling

• Basic OOP

Then move to the libraries used in data science:

• NumPy

• Pandas

• Matplotlib

The most important rule:

Type everything. Don’t just watch tutorials.

Build small scripts and experiments.

If you want structured learning, the Google Crash Course on Python is a good starting point.

I also created a beginner-friendly Python course on my YouTube channel where I walk through these concepts step by step.

2. Learn Only the Math You Actually Need

Many beginners panic when they hear “math”.

The truth is simpler.

You do not need advanced proofs.

Focus on:

• Linear Algebra (vectors, matrices, dot product)

• Probability basics

• Mean, variance, standard deviation

• Gradient intuition

• Basic derivatives

Your goal is intuition, not theoretical perfection.

Some useful learning resources include:

• Intro to Statistics — Udacity

• Basic Statistics — Online course

• Statistics and Probability — Khan Academy

• Mathematics for Machine Learning (Linear Algebra) — Coursera

Choose courses that connect math to real ML models, not abstract theory.

3. Understand Data First (Very Important)

Before building models, understand data.

Learn:

• What is a dataset?

• What is a feature?

• What is a target?

• Structured vs unstructured data

• Missing values

• Outliers

Practice with real datasets:

• Load CSV files

• Clean data

• Handle missing values

• Perform basic EDA

This step alone separates serious learners from casual learners.

Step 2: Core Machine Learning (Month 3–4)

Once your foundation is ready, start with supervised learning.

1. Regression

Learn:

• Linear Regression

• Multiple Regression

• Regularization (Ridge, Lasso)

Understand concepts like:

• Cost functions

• Overfitting

• Train/test split

2. Classification

Then move to classification algorithms:

• Logistic Regression

• KNN

• Decision Trees

• Random Forest

• SVM

Learn evaluation metrics:

• Accuracy

• Precision

• Recall

• F1 Score

• Confusion Matrix

Practice with small projects like:

• House price prediction

• Spam detection

• Customer churn prediction

If you prefer structured learning, the Machine Learning Specialization from DeepLearning.AI and Stanford is a solid option.

It includes real assignments and practical model building.

Step 3: Build Projects (Month 5)

This is where many learners fail.

They watch tutorials but never build anything.

Your goal should be:

• At least 3 end-to-end projects

• A clean GitHub profile

• Clear README explanations

Good project ideas:

• End-to-end ML pipeline

• Data analysis with storytelling

• Deploying a machine learning model

Programs like Udacity Nanodegrees can be helpful because they force you to build real projects.

Step 4: Deep Learning & Generative AI (Month 6–7)

Now you can move into deeper topics.

Start with:

• Neural networks

• Activation functions

• Backpropagation

• CNN basics

• RNN basics

• Transformers overview

Then explore modern AI topics:

• Large Language Models

• Prompt design

• Fine-tuning basics

• Vector databases

One common mistake beginners make is jumping into ChatGPT or LLM tools too early.

Without fundamentals, this creates knowledge gaps.

The Deep Learning Specialization from DeepLearning.AI is one structured path to learn neural networks with real coding exercises.

Step 5: MLOps & Deployment (Month 8)

This is where industry demand is growing quickly.

Companies need people who can deploy models, not just train them.

Learn:

• Model serialization

• APIs (FastAPI or Flask)

• Docker basics

• Cloud basics (AWS, GCP, or Azure)

• CI/CD for ML

You don’t need to master everything.

Even basic deployment knowledge gives you a strong advantage.

Some useful resources include:

• MLOps Fundamentals — Coursera

• MLOps Fundamentals — Udemy

• Open Source Platforms for MLOps — Coursera

• Complete MLOps Bootcamp — Udemy

Career Paths You Can Choose

After a few months of learning and projects, choose a direction.

Here are common roles.

1. Data Analyst

Focus on:

• SQL

• Data visualization

• Dashboards

• Business metrics

Python helps automate tasks.

2. Data Scientist

Focus on:

• Machine learning models

• Experimentation

• Statistical thinking

• Feature engineering

3. Machine Learning Engineer

Focus on:

• Model deployment

• ML pipelines

• Performance optimization

• Scalability

4. AI Engineer (Generative AI)

Focus on:

• LLM workflows

• Prompt engineering

• RAG pipelines

• Model integration

Choose one direction after building fundamentals.

Tools You Should Know

Here is a practical stack for beginners:

• Python

• Pandas

• NumPy

• Scikit-learn

• Matplotlib / Seaborn

• TensorFlow or PyTorch

• Git

• Basic SQL

• One cloud platform

That’s enough.

You don’t need 50 tools.

How to Choose Courses Wisely

When evaluating courses, ask:

• Does it include projects?

• Are assignments practical?

• Does it teach deployment?

• Does it teach problem solving?

Avoid courses that only have:

• slides

• theory

• quizzes without coding

If a course saves you months of confusion, it’s worth it.

A Sustainable Weekly Study Plan

If you are working or studying:

• 1–2 hours daily

• 4–6 hours on weekends

Divide your time like this:

• 40% learning

• 40% coding

• 20% revision

Consistency beats intensity.

Common Mistakes Beginners Make

Here are mistakes I see frequently:

• Jumping into deep learning too early

• Ignoring math completely

• Watching too many tutorials

• Not building projects

• Not documenting work

Avoid these and you’re already ahead of most learners.

Final Advice

AI and data science are not about collecting certificates.

They are about solving problems.

If you follow this roadmap:

• Build foundations

• Learn core machine learning

• Work on real projects

• Explore advanced topics

• Understand deployment

You won’t feel lost.

You’ll feel in control of your learning.

If you’re starting today, start with Python. Open your editor. Write your first script.

Momentum matters more than perfection.

Happy learning.

— Aqsa