In our previous blog posts, we learned about Generative AI, LLMs, ChatGPT, How ChatGPT Works, and Prompt Engineering.
Now let's take the next step.
We know that an LLM can answer many questions using what it learned during training.
But what happens when we want AI to answer questions using our own information?
For example:
- A company's internal documents
- A college handbook
- A product manual
- A collection of PDFs
- A company's FAQs
- A private knowledge base
Imagine you give an AI assistant a 500-page college handbook and ask:
«“What is the minimum attendance required for students?”»
How can AI find the right information from hundreds of pages?
This is where some important AI concepts come together:
In this post, we will look at the overall picture.
We won't go deeply into each technology yet.
The goal is simply to understand how all these concepts connect with each other.
A Simple Real-World Example
Let's use one example throughout this entire post.
Imagine a college has a digital Student Handbook.
The handbook contains information about:
- Attendance
- Exams
- Fees
- Leave rules
- Hostel rules
- Library rules
- Academic regulations
Now a student asks an AI assistant:
«“What is the minimum attendance required to write the final exam?”»
Suppose the handbook says:
«“Students must maintain at least 75% attendance to be eligible for the final examination.”»
The AI needs to find this information and use it to answer the student's question.
But how?
Let's see.
1. First, We Have External Information 📄
The first thing we need is the information itself.
In our example, the information is inside the:
«College Student Handbook»
It could be a PDF containing hundreds of pages.
The AI system needs access to this information if we want it to answer questions based on the handbook.
So we start with:
College Handbook
Information about college rules
The information could be anything:
«“Students must maintain at least 75% attendance.”»
This is our external information.
Why do we call it external?
Because this information is specific to the college and may not be part of the general knowledge the LLM was trained on.
2. The Document Is Divided Into Smaller Parts
A 500-page document is too large to simply treat as one giant piece of text.
So the document can be divided into smaller sections or chunks.
For example:
College Handbook
Chunk 1: Attendance Rules
Chunk 2: Examination Rules
Chunk 3: Fee Rules
Chunk 4: Hostel Rules
Chunk 5: Library Rules
And so on.
Our important information might be inside the attendance section:
«“Students must maintain at least 75% attendance to be eligible for the final examination.”»
This smaller piece of information can now be processed further.
3. What Are Embeddings? 🔢
Now we come to Embeddings.
This is one of the important ideas in modern AI systems.
In simple terms:
«An embedding is a numerical representation of information that helps a computer work with the meaning of that information.»
For example, we have:
«“Students must maintain at least 75% attendance.”»
An embedding model can convert this text into a collection of numbers called a vector.
It may look something like:
«"[0.12, -0.45, 0.78, 0.31, ...]"»
Don't worry about the actual numbers.
The important idea is:
Text → Numbers that represent meaning
Why do we do this?
Because these numerical representations can help the system compare pieces of information based on their meaning.
For example:
«“What percentage of attendance is needed?”»
and
«“Students must maintain at least 75% attendance.”»
use different words, but they are talking about a similar concept.
Embeddings help the system recognize this kind of relationship.
We will explore embeddings in much more detail in a future post.
4. Where Do We Store These Embeddings?
Now imagine our college has thousands of documents.
We can't just create embeddings and leave them somewhere.
We need a system to store and search them efficiently.
This is where a Vector Database comes in.
A vector database can store vector representations and help retrieve information that is similar or relevant to a query.
So our process becomes:
College Documents
Text Chunks
Embeddings
Vector Database
For example, the vector database may contain information representing:
- Attendance rules
- Exam rules
- Hostel rules
- Fee rules
- Library rules
The actual implementation can be more complex, but this is the basic idea we need for now.
5. Now the User Asks a Question ❓
Let's return to our student.
The student asks:
«“What is the minimum attendance required to write the final exam?”»
The system now needs to find the most relevant information from the college handbook.
The question itself can also be converted into an embedding.
So we have:
User Question
«“What is the minimum attendance required?”»
Question Embedding
The system can then search the vector database for information that is semantically relevant to the question.
6. The System Searches for Relevant Information 🔍
The vector database contains many pieces of information.
But the student doesn't need everything.
They don't need:
«Hostel rules»
or:
«Library rules»
or:
«Fee payment rules»
They need information about:
«Attendance requirements»
So the system searches for the most relevant information.
It might retrieve:
«“Students must maintain at least 75% attendance to be eligible for the final examination.”»
This is the important part.
The system has now retrieved the information relevant to the user's question.
7. What Does RAG Do? 🔗
Now we reach RAG.
RAG :Retrieval-Augmented Generation
The name may sound complicated, but the basic idea is simple.
RAG combines two things:
Retrieval
Finding relevant information.
+
Generation
Using an LLM to generate the final answer.
In our example:
Student asks a question
System retrieves relevant information from the college handbook
Relevant information is given to the LLM
LLM generates the answer
«“Students need at least 75% attendance to be eligible for the final examination.”»
That's the basic idea of RAG.
8. The Complete Flow
Now let's connect everything together.
Our college handbook example looks like this:
📚 Before the Question
College Handbook
⬇️
Split into smaller chunks
⬇️
Create embeddings
⬇️
Store embeddings in a vector database
❓ When the Student Asks
Student asks:
«“What is the minimum attendance required to write the final exam?”»
⬇️
Question is processed
⬇️
Relevant information is searched
⬇️
Attendance-related information is retrieved
⬇️
Retrieved information is given to the LLM
⬇️
LLM generates the answer
⬇️
✅ Final Answer
«“Students must maintain at least 75% attendance to be eligible for the final examination.”»
Now we can see how the different concepts are connected.
How Everything Connects
Let's simplify the entire process into one line:
And RAG is the overall approach that combines retrieving relevant information with generating a response.
This is why these concepts are often discussed together.
Why Can't We Just Ask the LLM?
You may now have a question:
«“Why don't we simply give the question to ChatGPT?”»
Because the information may be private, specific, new, or outside the model's existing knowledge.
For example, suppose a college changes its attendance rule next month.
The AI's general training may not know about that new rule.
But if the college's updated handbook is connected to a retrieval system, the AI application can retrieve the relevant information from that source.
This allows the LLM to generate an answer using the retrieved context.
Another Simple Example: Company Documents
The Main Idea to Remember
At this stage, you don't need to remember every technical detail.
Just understand what each part is doing.
📄 External Information
Provides the knowledge that the AI application needs.
🧩 Chunks
Break large documents into smaller pieces.
🔢 Embeddings
Represent information as numerical vectors that help with meaning-based comparison.
🗄️ Vector Database
Stores these vectors and helps search for relevant information.
🔍 Retrieval
Finds the information related to the user's question.
🧠 LLM
Uses the retrieved information and generates a natural-language response.
🔗 RAG
Connects retrieval with generation, allowing an LLM-based application to answer using retrieved external information.
One Simple Story to Remember
Imagine a student entering a huge library.
The student asks:
«“What is the minimum attendance required for my exam?”»
The library has thousands of pages.
Instead of reading everything:
1. The system breaks the documents into smaller sections.
2. It creates embeddings to represent their meaning.
3. It stores them in a vector database.
4. The student's question is processed.
5. The system searches for relevant information.
6. It finds the attendance rule.
7. The relevant information is given to the LLM.
8. The LLM generates a simple answer.
«“You need at least 75% attendance to be eligible for the final examination.”»
That's the basic story behind the connection between Embeddings, Vector Databases, Retrieval, RAG, and LLMs.
What's Next?
In this post, we looked at the big picture.
We intentionally didn't go deep into the technical details.
In the next posts, we can explore each concept separately:
Next:
What Are Embeddings?
How does text become numbers, and how can those numbers represent meaning?
Then:
What Is a Vector Database?
How does it store vectors and find relevant information?
Then:
What Is RAG?
How does retrieval work together with an LLM to generate an answer?
And finally:
RAG Pipeline Explained Step by Step
How does the complete system work from document upload to the final AI response?
Conclusion
AI doesn't always have to rely only on the information it learned during training.
It can also be connected to external information such as documents, company knowledge bases, product manuals, and other data sources.
To make this work, several concepts can come together:
«Documents → Chunks → Embeddings → Vector Database → Retrieval → RAG → LLM → Answer»
Each concept has a different role.
Embeddings help represent information numerically.
Vector databases help store and search those representations.
Retrieval finds relevant information.
RAG combines retrieval with generation.
And the LLM turns the retrieved information into a natural-language answer.
For now, just remember the big picture.
In the next posts, we'll open each of these concepts and understand how they actually work, step by step, with simple examples. 🤖
No comments:
Post a Comment