This course is for those who feel unsure about what to do after implementing a basic Vector Search–based RAG. You will understand the differences and use cases of Classic RAG, GraphRAG, and Agentic RAG, then directly implement a dynamic routing structure that selects different RAG paths based on the nature of each question, as well as a long-term memory architecture based on GraphRAG+xMemory.
At first, simply embedding and searching documents to generate answers may seem sufficient. However, as soon as you start handling slightly more complex questions in practice, you repeatedly face trade-offs between accuracy, cost, and response speed. What you need at that point is not to blindly add more new technologies, but criteria for choosing an architecture suited to the question and situation.
As you continue adding search, reranking, summarization, and verification steps, quality may improve, but processing time increases accordingly. In real-world services, “doing more” is less important than “doing only as much as necessary.”
Including many documents as context for every question is simple, but token usage and costs quickly increase. A structure is needed to select the necessary information.
Questions that require finding relationships between multiple documents, or that are difficult to answer with a single search, are hard to handle with basic similarity search alone.
Some questions can be answered with a single quick search, while others require following relationships, and still others require searching again after reviewing the search results. In this course, you’ll learn how to distinguish between these cases and connect them to the appropriate RAG architecture.
Rather than memorizing numerous new RAG techniques, this course focuses on developing criteria for determining which architecture is needed in each situation.
Rather than merely different names for technologies, we compare Classic RAG, GraphRAG, and Agentic RAG to understand what problems each was created to solve.
Instead of putting every question through the same RAG pipeline, we design a dynamic routing structure that selects the appropriate path based on the complexity of the question and the level of reasoning required.
Using GraphRAG and xMemory, we explore long-term memory architectures that go beyond one-off searches by leveraging relationships and past information together.
Rather than learning the three architectures separately, we compare their differences from the perspective of “Which architecture is more suitable for which questions?”
It is a basic RAG structure that finds the necessary documents, adds them to the context, and generates an answer. It is suitable for questions or document search services that need to operate quickly and simply.
It structures the entities and relationships within documents and uses those connections to find context that simple similarity searches might miss.
Instead of using the results from a single search as they are, we evaluate whether the results are sufficient and, if necessary, search again.
What really matters is not that “GraphRAG is better” or “Agentic RAG is more advanced.” It is deciding which architecture is more reasonable to use depending on the question. In this course, we implement a dynamic routing flow that translates that decision into code.
It determines the complexity of the question, the scope of the information needed, and whether additional reasoning is required.
Select the RAG path based on whether a quick search is needed or whether relationship exploration or iterative searches are required.
Document retrieval, relationship graph exploration, and self-evaluation loops as needed are applied appropriately to the situation.
We adjust the architecture while considering not only accuracy, but also token usage and response time.
Rather than being an introductory course on building RAG for the first time, this course is designed for those who have already encountered basic RAG and are now considering how to solve more complex problems.
It is structured to help you understand why we move from basic RAG to GraphRAG, and from GraphRAG to Agentic RAG, together with the problem scenarios involved.
We consider token costs and response times alongside improving accuracy. We address the balance needed when designing RAG with real-world services in mind.
Rather than stopping at simple retrieval, we examine an architecture that connects to relational reasoning, iterative retrieval, and long-term memory.
Suitable for those who have implemented basic RAG but are considering the architecture for the next stage due to search quality, cost, and latency concerns.
You are building RAG into LLM-based search and knowledge services and want to understand the overall architecture beyond simple API integration.
We recommend this course for those who want to move beyond Vector Search-based architectures and work directly with next-generation architectures such as GraphRAG, Agentic RAG, and dynamic routing.
To prevent a mismatch between expectations and the actual content after enrollment, we clearly outline the intended audience.
Rather than throwing complex structures at you from the start, we first identify where the limitations of basic RAG arise, then expand the architecture as much as needed.
We examine why basic RAG expands into GraphRAG and Agentic RAG, and summarize the differences between each architecture and the need for hybrid routing.
We revisit basic RAG from a practical perspective and cover improvement methods and routing structures that take search quality and token usage into account.
Extract entities and relationships from text, and implement the process of using connections between documents in search.
Covers the core flow of Agentic RAG for questions where a single search is insufficient, evaluating the results and retrieving the necessary information again.
We explore a long-term memory architecture that connects GraphRAG and xMemory, enabling the continuous use of relational information and past context.
We expand the design perspective on which path to use for each question and how to consider quality, cost, and latency together.
Use simple RAG for questions that can be answered quickly, leverage GraphRAG for questions that require following relationships, and apply Agentic RAG to questions where a single search is insufficient. By connecting dynamic routing and long-term memory structures, you can begin to view RAG not as a single feature, but as an architecture.
![[Qt/QML Practical Part 2] 6 Practical Projects for C++ Developers (REST API)Course Thumbnail](https://cdn.inflearn.com/public/courses/333527/cover/eb60879b-b2d9-4194-bbb0-9291102ceda3/333527.png?w=420)
![[Qt/QML Basics Part 1] Cross-platform App Development Learning through C++ Integration and Signals-SlotsCourse Thumbnail](https://cdn.inflearn.com/public/courses/331907/cover/d506b3da-e9ed-4683-97ba-4f01c51e3c4c/331907.png?w=420)
![[The Ultimate Manufacturing DX] AI Practical Application Strategy Master Class for 7 Major IndustriesCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/342169/cover/ai/2/e0850074-3049-4f98-b6db-611d07ea5083.png?w=420)
![[Basic Part 2.5] OpenClaw.AI Master Class: Fundamentals of Multi-Agent Team Design and Role SeparationCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/341784/cover/01knxyn4p6xrrydvz16tkf6yvb?w=420)
![[Deep-Up_PASS] AWS Certified AI Practitioner Exam Question ExplanationsCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/337055/cover/01jxh5hzmh89eztnpmr0hbssfz?w=420)
![[Lv.5] SwiftUI with AI - Building AI Apps with Apple IntelligenceCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/341905/cover/01krprhwat5ngfskp43xy1nsj3?w=420)
