Hướng dẫn triển khai Corrective RAG (CRAG) với Python: Tự động đánh giá tài liệu và tìm kiếm web

Bối cảnh & Tại sao cần

Hỏi bot nội bộ một câu chính sách và nhận lại lời hồi đáp “tự tin nhưng sai bét” là trải nghiệm quen thuộc của nhiều đội ngũ. Với RAG truyền thống, luồng xử lý rất tuyến tính: câu hỏi đi vào, vector search quét tìm 3-5 đoạn văn bản có điểm tương đồng cao nhất, rồi ném thẳng vào LLM.

Search vector chỉ bắt được độ tương đồng ngữ nghĩa bề mặt, hoàn toàn không biết tài liệu đó có giải quyết được câu hỏi hay không. Giả sử nhân viên hỏi về quy định remote mới ban hành tuần trước. Nếu kho tri thức chỉ có bản thảo từ năm ngoái, bot vẫn vô tư lấy ra làm ngữ cảnh và sinh câu trả lời sai lệch.

Hình dung trực quan: RAG cũ giống nhân viên trực quầy bốc vội vài trang giấy cũ trong ngăn kéo rồi đọc ngay cho khách nghe. Corrective RAG (CRAG) gắn thêm cho nhân viên đó một phản xạ kiểm định: liếc nhanh xem giấy tờ có đúng trọng tâm không. Nếu tài liệu chuẩn, bot dùng luôn. Nếu dữ liệu lệch tủ hoặc thiếu hoàn toàn, hệ thống sẽ tự bật trình duyệt để tra nguồn ngoài uy tín.

Thực tế khi áp dụng cho hệ thống hỏi đáp nội bộ 800 nhân sự, CRAG giúp hạ tỷ lệ câu trả lời rác (hallucination) từ 27% xuống còn 4.5%. Đội ngũ kỹ thuật không cần vội vã finetune mô hình hay đánh chỉ mục lại toàn bộ kho tài liệu.

Cài đặt

LangGraph là lựa chọn lý tưởng để kiểm soát các nhánh rẽ và vòng lặp trong CRAG, kết hợp cùng Tavily Search chuyên dụng cho agent tra cứu web.

Cài đặt các gói thư viện trực tiếp từ terminal:

pip install langchain langchain-openai langchain-community langgraph tavily-python chromadb tiktoken

Khai báo API key cho OpenAI và Tavily vào môi trường làm việc (Tavily cho phép dùng miễn phí 1.000 lượt request/tháng):

export OPENAI_API_KEY="sk-..."
export TAVILY_API_KEY="tvly-..."

Cấu hình chi tiết

Kiến trúc CRAG tiêu chuẩn vận hành qua 4 chặng:

  1. Retrieve: Truy xuất 2-3 đoạn tài liệu từ vector database nội bộ.
  2. Grade Documents: Dùng LLM kích thước nhỏ chấm điểm nhị phân (yes/no) xem tài liệu có sát câu hỏi hay không.
  3. Web Search Fallback: Tự động kích hoạt Tavily Search khi tài liệu nội bộ bị đánh giá là ‘lạc đề’ hoặc rỗng.
  4. Generate: Tổng hợp dữ liệu đã qua sàng lọc để tạo câu trả lời mạch lạc cho người dùng.

1. Khởi tạo Vector Store giả lập

Tạo file crag_pipeline.py và nạp trước một số chính sách công ty làm dữ liệu mẫu:

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document

# Dữ liệu nội bộ giả lập
docs = [
    Document(page_content="Chính sách làm việc từ xa của công ty áp dụng tối đa 2 ngày mỗi tuần cho nhân sự đã qua thử việc."),
    Document(page_content="Thời gian thanh toán lương định kỳ vào ngày 05 hàng tháng qua tài khoản ngân hàng Vietcombank."),
    Document(page_content="Ngân sách đào tạo chứng chỉ công nghệ hàng năm được cấp tối đa 15 triệu đồng mỗi nhân viên kỹ thuật.")
]

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(documents=docs, embedding=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

2. Xây dựng bộ đánh giá tài liệu (Document Grader)

Trọng tâm của CRAG nằm ở khâu thẩm định dữ liệu. Thay vì để LLM trả lời dài dòng, ta ép mô hình phản hồi có cấu trúc theo dạng nhị phân: yes (liên quan) hoặc no (lạc đề).

from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

class GradeDocuments(BaseModel):
    binary_score: str = Field(description="Tài liệu có liên quan đến câu hỏi không, 'yes' hoặc 'no'")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
structured_llm_grader = llm.with_structured_output(GradeDocuments)

system_prompt = """Bạn là chuyên viên đánh giá chất lượng tài liệu.
Nhiệm vụ của bạn là kiểm tra xem tài liệu được cung cấp có chứa thông tin trả lời cho câu hỏi của người dùng hay không.
Chỉ đánh giá 'yes' nếu tài liệu thực sự liên quan, ngược lại đánh giá 'no'."""

grade_prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "Tài liệu truy xuất:\n\n{document}\n\nCâu hỏi của người dùng: {question}")
])

doc_grader = grade_prompt | structured_llm_grader

3. Định nghĩa các Node và State trong LangGraph

LangGraph quản lý dữ liệu luân chuyển thông qua một TypedDict có tên GraphState. Mỗi node sẽ nhận state, xử lý logic riêng và cập nhật lại state đó.

from typing import List
from typing_extensions import TypedDict
from langchain_community.tools.tavily_search import TavilySearchResults

class GraphState(TypedDict):
    question: str
    generation: str
    web_search_needed: bool
    documents: List[Document]

def retrieve(state):
    question = state["question"]
    documents = retriever.invoke(question)
    return {"documents": documents, "question": question, "web_search_needed": False}

def grade_documents(state):
    question = state["question"]
    documents = state["documents"]
    
    filtered_docs = []
    web_search_needed = False
    
    for d in documents:
        score = doc_grader.invoke({"question": question, "document": d.page_content})
        if score.binary_score == "yes":
            filtered_docs.append(d)
        else:
            web_search_needed = True
            
    if len(filtered_docs) == 0:
        web_search_needed = True
        
    return {"documents": filtered_docs, "question": question, "web_search_needed": web_search_needed}

def web_search(state):
    question = state["question"]
    documents = state.get("documents", [])
    
    web_tool = TavilySearchResults(k=2)
    web_results = web_tool.invoke({"query": question})
    
    web_content = "\n".join([d["content"] for d in web_results])
    documents.append(Document(page_content=web_content, metadata={"source": "web_search"}))
    
    return {"documents": documents, "question": question}

def generate(state):
    question = state["question"]
    documents = state["documents"]
    
    context = "\n\n".join([d.page_content for d in documents])
    gen_prompt = ChatPromptTemplate.from_messages([
        ("system", "Bạn là trợ lý ảo giải đáp thắc mắc. Hãy trả lời câu hỏi dựa trên ngữ cảnh sau:\n\n{context}"),
        ("human", "{question}")
    ])
    
    rag_chain = gen_prompt | llm
    response = rag_chain.invoke({"context": context, "question": question})
    return {"generation": response.content}

4. Ghép nối thành Workflow hoàn chỉnh

Sau khi đã có các node độc lập, chúng ta liên kết chúng lại thành graph có điều kiện rẽ nhánh:

from langgraph.graph import END, StateGraph

workflow = StateGraph(GraphState)

# Thêm các nút
workflow.add_node("retrieve", retrieve)
workflow.add_node("grade_documents", grade_documents)
workflow.add_node("web_search", web_search)
workflow.add_node("generate", generate)

# Thiết lập luồng chạy
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "grade_documents")

def decide_to_generate(state):
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

workflow.add_conditional_edges(
    "grade_documents",
    decide_to_generate,
    {
        "web_search": "web_search",
        "generate": "generate"
    }
)
workflow.add_edge("web_search", "generate")
workflow.add_edge("generate", END)

app = workflow.compile()

Kiểm tra & Monitoring

Kiểm thử workflow qua hai tình huống thực tế để quan sát hành vi rẽ nhánh:

# Kịch bản 1: Câu hỏi có trong dữ liệu nội bộ
print("--- TEST 1: DỮ LIỆU NỘI BỘ ---")
res_1 = app.invoke({"question": "Nhân viên được làm việc từ xa tối đa mấy ngày một tuần?"})
print("Trả lời:", res_1["generation"])

# Kịch bản 2: Dữ liệu hoàn toàn không có trong công ty, cần tra cứu ngoài web
print("\n--- TEST 2: CẦN TRA WEB ---")
res_2 = app.invoke({"question": "Giá cổ phiếu Apple hôm nay biến động ra sao?"})
print("Trả lời:", res_2["generation"])

Những chỉ số cần theo dõi khi đưa lên vận hành

Dưới đây là 3 chỉ số then chốt bạn cần theo dõi trên dashboard (như LangSmith hay OpenTelemetry) khi chạy production:

  • Tỷ lệ Fallback ra Web (Fallback Rate): Mức an toàn thường nằm dưới 15-20%. Nếu tỷ lệ này vượt mốc 35%, kho dữ liệu nội bộ đang bị hổng nghiêm trọng. Hãy cập nhật tài liệu thay vì để bot liên tục tốn tiền gọi API web search.
  • Độ trễ trung bình (End-to-End Latency): CRAG tốn thêm một lượt gọi LLM grader và có thể phát sinh web search. Hệ thống thường tăng thêm 1.2 đến 2.5 giây so với RAG thuần. Giải pháp tối ưu: dùng gpt-4o-mini (độ trễ ~300ms) hoặc một model local 7B lượng tử hóa cho khâu chấm điểm.
  • Chi phí Token & API: Grader cần đọc toàn bộ chunk truy xuất. Bạn nên chốt tham số k=2 hoặc k=3 ở retriever. Giữ context ngắn giúp tiết kiệm tới 40% chi phí token so với việc ném bừa hàng loạt tài liệu vào prompt cuối.
Share: