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
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 RAG | Agentic RAG | |
|---|---|---|
| Số bước | Cố định: truy xuất rồi trả lời | Thay đổi theo câu hỏi: có thể bỏ qua truy xuất khi không cần |
| Điểm liên quan | Khô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êu | Luô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
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 rewriter | LLM 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 |
| CRAG | Thêm bộ đánh giá chấm tài liệu, dự phòng bằng web | Tăng độ chính xác, độ phức tạp vừa phải |
| Self-RAG | Mô hình tự sinh reflection token | Cần fine-tune, không cần bộ đánh giá ngoài |
| RAT | LLM viết chain-of-thought trước, truy xuất cho từng bước | Phù hợp câu nhiều bước và suy luận |
| Plan-and-execute | LLM lập kế hoạch, agent khác thực thi từng việc | Dễ debug, log và cache |
| ReAct loop | Kết hợp suy luận và hành động trong từng lượt | Nề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.