ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← RAG & Agents

AI Builder

RAG tăng cường với Agent

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kết hợp RAG với AI Agent để tự quyết định khi nào truy xuất, xác minh và tổng hợp thông tin

lesson94 minRAG & AgentsAI Engineer

Dự đoán

Chatbot công ty dùng Basic RAG. Người dùng hỏi “Chính sách nghỉ phép năm 2025 là gì?” — RAG trả về tài liệu năm 2024 (chưa cập nhật) và chatbot trả lời sai. Giải pháp nào?

Khám phá — naive RAG và agentic RAG

Hãy đóng vai người dùng: chọn một câu hỏi, rồi xem cả hai hệ thống chạy từng bước. Chú ý số bước, điểm liên quan và kết luận cuối. Sự khác biệt giữa naive RAG và agentic RAG nằm ở đó.

Naive RAGAgentic RAG
Số bướcCố định: truy xuất rồi trả lờiThay đổi theo câu hỏi: có thể bỏ qua truy xuất khi không cần
Điểm liên quanKhông kiểm tra lạiĐánh giá từng tài liệu và truy xuất lại khi cần
Mục tiêuLuôn trả lờiĐúng số bước cho loại câu hỏi, không phải nhiều bước nhất

Ví dụ câu hỏi đơn giản như “1 + 1”: agentic RAG có thể ít bước hơn naive RAG, vì agent biết bỏ qua bước truy xuất khi không cần. “Nhiều bước” không phải mục tiêu.

Khoảnh khắc aha

Basic RAG giống máy tra cứu tự động: luôn tìm, luôn trả. Agentic RAG giống nhà nghiên cứu thông minh: suy nghĩ trước khi tìm, kiểm tra nguồn, đối chiếu, và biết nói “tôi không chắc chắn” khi thông tin không đủ. Bước nhảy từ “retrieve and read” sang “think, retrieve, verify, synthesize”.

Khi thêm vòng lặp Plan → Retrieve → Evaluate → Re-retrieve, hệ thống từ một pipeline trở thành một agent. Không phải model giỏi hơn, mà là cấu trúc giỏi hơn.

Thử thách

Người dùng hỏi “So sánh doanh thu Q3 2024 của FPT và Viettel”. Basic RAG lấy hai tài liệu riêng, nhưng hai tài liệu dùng đơn vị khác nhau (triệu và tỷ đồng). Agentic RAG xử lý thế nào?
Chatbot hỗ trợ khách hàng: 80% câu hỏi là kiến thức chung (giờ mở cửa, địa chỉ), 20% câu phức tạp (hoàn tiền một đơn hàng). Agentic RAG nên áp dụng thế nào?

Lý thuyết

Agentic RAG kết hợp RAG với AI agent: agent tự quyết định khi nào truy xuất, từ nguồn nào, bao nhiêu lần, và có cần kiểm chứng không. Khả năng điều phối nhiều công cụ đến từ function calling.

Bốn năng lực cốt lõi:

  • Truy xuất thích ứng: quyết định có cần truy xuất không (bỏ qua với câu đơn giản).
  • Nhiều nguồn: truy xuất từ vector DB, SQL, tìm kiếm web, API.
  • Tự phản tư: tự đánh giá tài liệu có liên quan không, câu trả lời có được hỗ trợ không.
  • Tinh chỉnh lặp: nếu chưa đủ tốt thì viết lại truy vấn và truy xuất lại.

Ví dụ với Anthropic SDK và tool use

Agentic RAG với Anthropic SDK + tool use

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "name": "search_docs",
        "description": "Tìm tài liệu trong knowledge base nội bộ",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "source": {
                    "type": "string",
                    "enum": ["internal_vector_db", "web", "sql_database"],
                },
                "top_k": {"type": "integer", "default": 5},
            },
            "required": ["query", "source"],
        },
    },
    {
        "name": "verify_fact",
        "description": "Verify một claim cụ thể với nguồn thứ ba",
        "input_schema": {
            "type": "object",
            "properties": {
                "claim": {"type": "string"},
                "check_against": {
                    "type": "array",
                    "items": {"type": "string"},
                },
            },
            "required": ["claim"],
        },
    },
    {
        "name": "fetch_metadata",
        "description": "Lấy metadata của một document (date, author, version)",
        "input_schema": {
            "type": "object",
            "properties": {"doc_id": {"type": "string"}},
            "required": ["doc_id"],
        },
    },
]

SYSTEM_PROMPT = """Bạn là một nghiên cứu viên thông minh.
Trước khi trả lời, hãy:
1. PLAN: phân tích câu hỏi, liệt kê thông tin cần tìm.
2. RETRIEVE: chọn nguồn phù hợp nhất, truy vấn.
3. EVALUATE: docs có đủ, có cập nhật, có nhất quán?
4. RE-RETRIEVE (nếu cần): reformulate hoặc đổi nguồn.
5. ANSWER: tổng hợp và trích dẫn rõ nguồn.
Nếu câu hỏi là kiến thức chung, có thể SKIP retrieve."""

def run_agent(user_question: str, max_loops: int = 6):
    messages = [{"role": "user", "content": user_question}]
    for loop in range(max_loops):
        resp = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=4096,
            system=SYSTEM_PROMPT,
            tools=tools,
            messages=messages,
        )
        if resp.stop_reason == "end_turn":
            return resp.content[-1].text
        # process tool_use blocks
        tool_results = []
        for block in resp.content:
            if block.type == "tool_use":
                result = call_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
        messages.append({"role": "assistant", "content": resp.content})
        messages.append({"role": "user", "content": tool_results})
    return "[agent dừng: quá số vòng cho phép]"

# Ví dụ
answer = run_agent(
    "So sánh chính sách nghỉ phép của FPT và VNG năm 2025"
)
print(answer)

Ví dụ với LangGraph

LangChain: agentic RAG với LangGraph

from typing import TypedDict, Literal
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document

llm = ChatAnthropic(model="claude-sonnet-4-5")
vector_store = Chroma(persist_directory="./kb")

class AgentState(TypedDict):
    question: str
    plan: str
    docs: list[Document]
    eval_label: Literal["correct", "ambiguous", "incorrect", "pending"]
    reformulated: str
    iterations: int
    answer: str

def plan_node(state: AgentState) -> AgentState:
    """Phase 1: agent lập kế hoạch."""
    prompt = f"""Câu hỏi: {state['question']}
Hãy xác định: (1) đây là kiến thức chung hay cần retrieve?
(2) nếu cần, nguồn phù hợp nhất là gì?
(3) query tối ưu để tìm kiếm là gì?"""
    plan = llm.invoke([HumanMessage(content=prompt)]).content
    return {**state, "plan": plan, "iterations": 0}

def should_retrieve(state: AgentState) -> Literal["retrieve", "answer_direct"]:
    """Router: adaptive retrieval quyết định có retrieve hay không."""
    if "kiến thức chung" in state["plan"].lower() or "skip" in state["plan"].lower():
        return "answer_direct"
    return "retrieve"

def retrieve_node(state: AgentState) -> AgentState:
    """Phase 2: retrieve docs."""
    query = state.get("reformulated") or state["question"]
    docs = vector_store.similarity_search(query, k=5)
    return {**state, "docs": docs, "eval_label": "pending"}

def evaluate_node(state: AgentState) -> AgentState:
    """Phase 3: evaluator chấm relevance."""
    context = "\n---\n".join(d.page_content for d in state["docs"])
    prompt = f"""Câu hỏi: {state['question']}
Docs retrieved:
{context}

Docs có đủ trả lời câu hỏi?
Trả lời một từ: correct | ambiguous | incorrect"""
    label = llm.invoke([HumanMessage(content=prompt)]).content.strip().lower()
    return {**state, "eval_label": label}  # type: ignore

def should_reretrieve(state: AgentState) -> Literal["reformulate", "answer"]:
    if state["eval_label"] == "correct":
        return "answer"
    if state["iterations"] >= 3:
        return "answer"  # bỏ cuộc sau 3 lần
    return "reformulate"

def reformulate_node(state: AgentState) -> AgentState:
    """Phase 4: reformulate query."""
    prompt = f"""Query cũ: {state.get('reformulated') or state['question']}
Docs không đủ tốt. Hãy viết lại query — cụ thể hơn, đổi từ khoá."""
    new_q = llm.invoke([HumanMessage(content=prompt)]).content
    return {**state, "reformulated": new_q, "iterations": state["iterations"] + 1}

def answer_node(state: AgentState) -> AgentState:
    """Phase 5: synthesize + cite."""
    context = "\n---\n".join(d.page_content for d in state.get("docs", []))
    prompt = f"""Câu hỏi: {state['question']}
Context: {context or '(no retrieval)'}
Trả lời ngắn gọn, trích dẫn nguồn khi có."""
    answer = llm.invoke([HumanMessage(content=prompt)]).content
    return {**state, "answer": answer}

# Lắp graph
graph = StateGraph(AgentState)
graph.add_node("plan", plan_node)
graph.add_node("retrieve", retrieve_node)
graph.add_node("evaluate", evaluate_node)
graph.add_node("reformulate", reformulate_node)
graph.add_node("answer", answer_node)

graph.set_entry_point("plan")
graph.add_conditional_edges("plan", should_retrieve, {
    "retrieve": "retrieve",
    "answer_direct": "answer",
})
graph.add_edge("retrieve", "evaluate")
graph.add_conditional_edges("evaluate", should_reretrieve, {
    "reformulate": "reformulate",
    "answer": "answer",
})
graph.add_edge("reformulate", "retrieve")
graph.add_edge("answer", END)

app = graph.compile()

result = app.invoke({"question": "Chính sách nghỉ phép FPT 2025?"})
print(result["answer"])

Vì sao LangGraph (state graph) phù hợp hơn chain thông thường? Chain LangChain cổ điển là DAG một chiều: đầu vào, bước 1, bước 2, đầu ra. Agentic RAG cần cạnh ngược (viết lại truy vấn rồi truy xuất lại) và cạnh có điều kiện (đánh giá rồi rẽ nhánh). LangGraph định nghĩa state machine rõ ràng: mỗi node đọc và ghi state, mỗi cạnh có thể gắn hàm điều kiện. Có thể debug bằng cách in trace các chuyển trạng thái.

Các lựa chọn tương đương: Haystack Pipelines, QueryEngine của LlamaIndex với RouterQueryEngine, DSPy, hoặc tự xây một event loop với mẫu reducer.

Các kiến trúc agentic RAG phổ biến

Kiến trúcÝ tưởngĐánh đổi
Query rewriterLLM viết lại truy vấn trước khi tìm kiếm vectorĐơn giản, chi phí thấp; không sửa được sai sau khi truy xuất
CRAGThêm bộ đánh giá chấm tài liệu, dự phòng bằng webTăng độ chính xác, độ phức tạp vừa phải
Self-RAGMô hình tự sinh reflection tokenCần fine-tune, không cần bộ đánh giá ngoài
RATLLM viết chain-of-thought trước, truy xuất cho từng bướcPhù hợp câu nhiều bước và suy luận
Plan-and-executeLLM lập kế hoạch, agent khác thực thi từng việcDễ debug, log và cache
ReAct loopKết hợp suy luận và hành động trong từng lượtNền tảng của nhiều framework agentic

Kiểm soát chi phí

  • Ngân sách token: đặt giới hạn số vòng và tổng token; khi vượt, agent trả lời bằng thông tin đang có.
  • Cache kết quả truy xuất: theo truy vấn đã chuẩn hoá, cùng câu hỏi không truy xuất lại.
  • Prompt caching: SDK cho phép cache system prompt và schema công cụ, tiết kiệm phần lớn token đầu vào cho các lần gọi lặp lại.
  • Dừng sớm: nếu bộ đánh giá trả về đúng với độ tin cậy cao, bỏ qua kiểm chứng thêm.
  • Bộ đánh giá nhỏ: dùng mô hình nhỏ cho đánh giá, mô hình lớn chỉ cho tổng hợp cuối.

Đánh giá một hệ thống agentic RAG

Không đủ chỉ đo độ chính xác cuối. Đo từng thành phần:

  • Chất lượng truy xuất: Recall@k, MRR, nDCG trên tập truy vấn có nhãn.
  • Độ chính xác của bộ định tuyến: quyết định truy xuất hay bỏ qua có đúng không.
  • Hiệu chỉnh bộ đánh giá: nhãn đúng của bộ đánh giá có thực sự đúng không, đo bằng ma trận nhầm lẫn.
  • Tính trung thực của câu trả lời: có được tài liệu truy xuất hỗ trợ không (RAGAS, TruLens).
  • Độ chính xác trích dẫn: trích dẫn có đúng nguồn không.
  • Chi phí và độ trễ: tổng token, số lần gọi LLM, độ trễ p50 và p95.

Gắn trace_id cho mọi yêu cầu, ghi state sau mỗi node và xuất JSON để review ngoại tuyến. Số lần agent đi vòng thường nhiều hơn dự kiến.

Agentic RAG là một hướng tiếp cận, không phải một công nghệ cụ thể. Có thể bắt đầu bằng cách thêm một bước đánh giá vào basic RAG (kiểu CRAG), rồi nâng dần: truy xuất thích ứng, nhiều nguồn, và cuối cùng tự phản tư. Mỗi bước thêm vài phần trăm độ chính xác nhưng tăng đáng kể độ phức tạp; dừng khi đủ cho bài toán của bạn.

Tóm tắt

  • Agentic RAG biến pipeline một chiều thành vòng lặp Plan → Retrieve → Evaluate → Re-retrieve → Answer do agent tự điều phối.
  • Bốn năng lực cốt lõi: truy xuất thích ứng, nhiều nguồn, tự phản tư, tinh chỉnh lặp.
  • CRAG thêm bộ đánh giá chấm đúng, mơ hồ, sai; Self-RAG huấn luyện mô hình sinh reflection token để tự giám sát.
  • Truy xuất thích ứng cho phép bỏ qua truy xuất với câu kiến thức chung, tiết kiệm chi phí.
  • Định tuyến nhiều nguồn giúp chọn đúng công cụ: vector DB, SQL, web, API.
  • Đánh đổi chính: chất lượng tăng nhưng token và độ trễ tăng nhiều lần; cân nhắc theo bài toán.

Continue the module

Lesson 2 of 16