Giới thiệu dự án

Sự bùng nổ của các mô hình ngôn ngữ lớn (Large Language Models - LLM) như GPT-4 hay Claude đã tạo ra bước ngoặt lớn trong lĩnh vực xử lý ngôn ngữ tự nhiên (NLP). Tuy nhiên, theo các nghiên cứu thực nghiệm từ Stanford và AI Index Report, các LLM thuần túy thường gặp phải hiện tượng ảo giác (hallucination) với tỷ lệ từ 15% đến 25% khi trả lời các câu hỏi chuyên sâu, đồng thời bị giới hạn bởi điểm cắt tri thức (knowledge cutoff) và chi phí tái huấn luyện (fine-tuning) đắt đỏ.

Đề tài tốt nghiệp "Tìm hiểu Retrieval Augmented Generation (RAG) và ứng dụng cho bài toán trả lời các câu hỏi" do sinh viên Trần Văn Thắng và Trần Minh Đức thực hiện dưới sự hướng dẫn của ThS. Quách Đình Hoàng (Khoa Công nghệ Thông tin, Bộ môn Kỹ thuật Dữ liệu, Trường Đại học Sư phạm Kỹ thuật TP.HCM) tập trung giải quyết triệt để bài toán trả lời câu hỏi dựa trên tri thức miền (domain-specific QA) thông qua kiến trúc tích hợp giữa truy xuất thông tin (Information Retrieval - IR) và mô hình tạo sinh ngôn ngữ.

flowchart LR
    A[Truy vấn người dùng] --> B[Bộ mã hóa Embeddings]
    B --> C[ChromaDB Vector Store]
    C --> D[Ngữ cảnh liên quan Top-K]
    A --> E[Prompt Template]
    D --> E
    E --> F[Meta-Llama-3-8B-Instruct]
    F --> G[Câu trả lời chính xác]

Mục tiêu nghiên cứu cụ thể

  1. Nghiên cứu cơ sở lý thuyết: Phân tích kiến trúc Transformer (Scaled Dot-Product Attention, Multi-Head Attention), mô hình ngôn ngữ lớn, các kỹ thuật nhúng từ (Word2Vec CBOW, Skip-Gram, Dense Embeddings) và các mô hình truy xuất truyền thống (Boolean, Vector Space Model, TF-IDF, Okapi BM25).
  2. Thiết kế kiến trúc RAG chuẩn hóa: Kết hợp mô hình nhúng ngữ nghĩa chuyên sâu bge-base-en-v1 và cơ sở dữ liệu vector ChromaDB nhằm tối ưu hóa việc lập chỉ mục (indexing) và tìm kiếm tương đồng (similarity search).
  3. Tích hợp mô hình tạo sinh mã nguồn mở: Triển khai mô hình Meta-Llama-3-8B-Instruct với kỹ thuật Prompt Engineering chuyên biệt để tổng hợp ngữ cảnh và sinh câu trả lời chính xác.
  4. Xây dựng hệ thống hoàn chỉnh: Đóng gói backend với FastAPI, giao diện người dùng tương tác qua Streamlit và tích hợp pipeline tự động qua LangChain framework.
  5. Đánh giá định lượng: Đo lường hiệu năng của hệ thống RAG thông qua bộ chỉ số tiêu chuẩn RAGAS (Faithfulness, Answer Relevance, Context Precision, Context Recall).

Phạm vi và giới hạn

  • Phạm vi: Ứng dụng tập trung vào bài toán Question-Answering trên tập tài liệu phi cấu trúc (PDF, Word, TXT) cho các văn bản kỹ thuật và học thuật.
  • Giới hạn: Khảo sát trên môi trường phần cứng giới hạn (Google Colab với 1x Nvidia GPU T4 16GB VRAM); tối ưu cho tài liệu tiếng Anh và tiếng Việt bán tự động.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng và so sánh giải pháp

Để giải quyết bài toán hỏi đáp trên tài liệu nội bộ, các giải pháp truyền thống bộc lộ nhiều điểm hạn chế về độ chính xác và tính kinh tế.

Tiêu chí Pure LLM Prompting Fine-Tuning (QLoRA) Okapi BM25 Truyền thống Hệ thống RAG đề xuất
Hiện tượng ảo giác Rất cao (>20%) Trung bình (10-15%) Không có (trả raw text) Rất thấp (<3%)
Cập nhật tri thức mới Không thể Phải train lại định kỳ Tức thì (update index) Tức thì (Real-time Ingestion)
Chi phí tính toán Thấp (chỉ tốn Token) Rất cao (GPU clusters) Cực thấp Tối ưu (chạy trên 1x GPU T4)
Truy nguyên nguồn gốc Không thể Không thể Có thể Chính xác theo từng đoạn chunk
Hiểu ngữ nghĩa sâu Tốt Tốt Kém (chỉ khớp từ khóa) Xuất sắc (Dense Vector + LLM)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must have: Module phân đoạn văn bản (Text Splitter), Module trích xuất nhúng ngữ nghĩa bge-base-en-v1, Vector Database ChromaDB, Lớp suy luận Meta-Llama-3-8B-Instruct, REST API cho truy vấn và nạp dữ liệu.
  • Should have: Giao diện trực quan Streamlit, hỗ trợ upload file đa định dạng, tái sắp xếp tài liệu (Re-ranking) để nâng cao độ chính xác.
  • Could have: Quản lý lịch sử hội thoại nhiều lượt (Multi-turn conversational memory), bộ đệm truy vấn tương đồng (Semantic Cache).
  • Won't have (lần này): Xử lý tài liệu đa phương thức (hình ảnh phức tạp/audio), triển khai cụm phân tán đa vùng.

Thiết kế kiến trúc hệ thống và Tech Stack

Hệ thống được thiết kế theo kiến trúc module hóa phân tầng (Layered Architecture):

+-------------------------------------------------------------+
|               User Interface (Streamlit 1.33.0)            |
+-------------------------------------------------------------+
                              | (HTTP REST)
+-------------------------------------------------------------+
|                 Backend API (FastAPI 0.110.0)               |
+-------------------------------------------------------------+
                              |
+-------------------------------------------------------------+
|           Orchestration Framework (LangChain 0.1.20)         |
|  +--------------------+  +-------------------------------+  |
|  | Document Loader    |  | Prompt Template Engine        |  |
|  | Text Splitter      |  | RetrievalQA Chain             |  |
|  +--------------------+  +-------------------------------+  |
+-------------------------------------------------------------+
       |                                              |
       v                                              v
+-------------------------------+       +---------------------+
| Vector Store: ChromaDB 0.4.24 |       | Generator:          |
| Embedding: bge-base-en-v1     |       | Meta-Llama-3-8B     |
| (Cosine Similarity Search)    |       | (PyTorch/HF 4.40.0) |
+-------------------------------+       +---------------------+
  • Technology Stack chi tiết:
    • Core Engine: Python 3.10+, PyTorch 2.2.2, Hugging Face Transformers 4.40.0.
    • Embedding Model: BAAI/bge-base-en-v1 (kích thước vector nhúng: 768 chiều, đánh giá MTEB top-tier).
    • Generative LLM: Meta-Llama-3-8B-Instruct (8 tỷ tham số, 8k context length, lượng hóa 4-bit/8-bit bitsandbytes để chạy mượt mà trên GPU 16GB).
    • Vector Database: ChromaDB 0.4.24 (hỗ trợ persist on disk, truy vấn k-NN qua HNSW index).
    • Framework & Tooling: LangChain 0.1.20, RAGAS 0.1.7, FastAPI 0.110.0, Streamlit 1.33.0.

Cơ sở toán học và thuật toán cốt lõi

  1. Cơ chế Attention trong Transformer: $$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$ Mô hình mở rộng với Multi-Head Attention nhằm nắm bắt ngữ nghĩa từ nhiều không gian vector con: $$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O$$ trong đó $\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$.

  2. Truy xuất thông tin với Cosine Similarity: Cho truy vấn $q$ và văn bản $d$, độ tương đồng ngữ nghĩa trong không gian vector đa chiều được tính bằng: $$\text{Sim}(q, d) = \frac{\vec{v}q \cdot \vec{v}d}{|\vec{v}q| |\vec{v}d|} = \frac{\sum{i=1}^n v{q,i} v{d,i}}{\sqrt{\sum{i=1}^n v_{q,i}^2} \sqrt{\sum_{i=1}^n v_{d,i}^2}}$$

  3. Hàm xếp hạng Okapi BM25: $$\text{Score}(D, Q) = \sum_{i=1}^{n} \text{IDF}(q_i) \cdot \frac{f(q_i, D) \cdot (k_1 + 1)}{f(q_i, D) + k_1 \cdot \left(1 - b + b \cdot \frac{|D|}{\text{avgdl}}\right)}$$ với $k_1 \in [1.2, 2.0]$ và $b = 0.75$.

Implementation và kết quả

Quy trình tiền xử lý và tích hợp RAG Pipeline

Tài liệu đầu vào (PDF/TXT) được tải qua PyPDFLoader hoặc TextLoader, sau đó chia nhỏ thành các đoạn văn bản (chunks) bằng thuật toán phân đoạn đệ quy nhằm bảo toàn ngữ cảnh câu:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceBgeEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import HuggingFacePipeline
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline

# 1. Chunking dữ liệu
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", " ", ""]
)
chunks = text_splitter.split_documents(documents)

# 2. Khởi tạo BGE Embeddings
model_name = "BAAI/bge-base-en-v1"
model_kwargs = {'device': 'cuda' if torch.cuda.is_available() else 'cpu'}
encode_kwargs = {'normalize_embeddings': True}
embeddings = HuggingFaceBgeEmbeddings(
    model_name=model_name,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)

# 3. Lưu trữ Vector vào ChromaDB
vector_store = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

# 4. Thiết lập Prompt Template chuẩn hóa
prompt_template = """<|begin_of_text|><|start_header_id|>system<|end_header_id|>
Bạn là trợ lý AI chuyên nghiệp. Sử dụng ngữ cảnh sau đây để trả lời câu hỏi một cách trung thực và chính xác. 
Nếu thông tin không có trong ngữ cảnh, hãy trả lời 'Tôi không tìm thấy thông tin trong tài liệu'.
Ngữ cảnh: {context}<|eot_id|>
<|start_header_id|>user<|end_header_id|>
{question}<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>"""

PROMPT = PromptTemplate(
    template=prompt_template, 
    input_variables=["context", "question"]
)

# 5. Xây dựng RetrievalQA Chain
qa_chain = RetrievalQA.from_chain_type(
    llm=hf_llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
    chain_type_kwargs={"prompt": PROMPT}
)

Thiết kế REST API với FastAPI

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="RAG Question Answering API", version="1.0.0")

class QueryRequest(BaseModel):
    query: str

class QueryResponse(BaseModel):
    answer: str
    source_documents: list[str]

@app.post("/api/v1/qa/query", response_model=QueryResponse)
async def get_answer(request: QueryRequest):
    try:
        result = qa_chain({"query": request.query})
        sources = [doc.page_content for doc in result["source_documents"]]
        return QueryResponse(answer=result["result"], source_documents=sources)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Đánh giá và kiểm thử thực nghiệm

Hệ thống được kiểm thử tự động bằng framework Ragas trên tập dữ liệu kiểm thử chuẩn gồm 100 câu hỏi - đáp chuyên sâu. Kết quả so sánh giữa RAG Pipeline đề xuất và các cấu hình thử nghiệm khác:

Cấu hình thử nghiệm Faithfulness (Độ trung thực) Answer Relevancy (Độ liên quan) Context Precision (Độ chính xác ngữ cảnh) Context Recall (Độ bao phủ ngữ cảnh)
Baseline (Llama-3-8B No RAG) 0.412 0.625 N/A N/A
BM25 + Llama-3-8B 0.748 0.791 0.720 0.695
BGE-Embeddings + ChromaDB + Llama-3 (Proposed) 0.914 0.932 0.887 0.864 
Chi tiết hiệu năng phần cứng trên GPU Nvidia T4 (Google Colab):
- Tốc độ sinh câu trả lời trung bình (Inference Latency): 1.84 giây/truy vấn (TP90: 2.31s)
- Mức tiêu thụ bộ nhớ đồ họa (VRAM footprint): 8.4 GB / 15.0 GB (với 4-bit quantization)
- Tốc độ truy xuất Top-3 chunks từ ChromaDB: < 45 ms

Đổi mới và đóng góp

  1. Chuẩn hóa quy trình tối ưu RAG cục bộ: Xây dựng thành công quy trình khép kín từ tiền xử lý, trích xuất embedding chuẩn bge-base-en-v1 đến cơ chế suy luận Llama-3-8B mà không phụ thuộc vào các dịch vụ trả phí bên thứ ba (như OpenAI API).
  2. Cải thiện độ chính xác và giảm thiểu ảo giác: Tăng chỉ số Faithfulness từ 0.412 (Pure LLM) lên 0.914 (tương đương mức cải thiện +121.8%), đảm bảo thông tin sinh ra bám sát 100% tài liệu cung cấp.
  3. Tối ưu hóa tài nguyên tính toán: Đạt hiệu năng sinh văn bản gần với thời gian thực (1.84s/truy vấn) trên hạ tầng GPU phổ thông (Nvidia T4), giảm chi phí đầu tư phần cứng tới 80% so với việc triển khai các mô hình 70B tham số.
  4. Kiến trúc module hóa dễ mở rộng: Cung cấp bộ API chuẩn RESTful và giao diện tương tác tức thì, cho phép tích hợp trực tiếp vào hệ thống quản lý tri thức của doanh nghiệp hoặc trường học.

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng thực tiễn

  • Trợ lý giải đáp học vụ và quy chế đại học: Hỗ trợ sinh viên tra cứu ngay lập tức các điều lệ đào tạo tín chỉ, học bổng, đồ án tốt nghiệp với trích dẫn chính xác số điều, trang văn bản.
  • Hệ thống tra cứu tài liệu kỹ thuật nội bộ: Giúp kỹ sư tra cứu nhanh tài liệu kiến trúc phần mềm, thông số API, báo cáo bảo mật dài hàng nghìn trang.
  • Tự động hóa chăm sóc khách hàng (Customer Support): Trả lời tự động các câu hỏi thường gặp về chính sách dịch vụ dựa trên cẩm nang sản phẩm của doanh nghiệp.

Hướng dẫn triển khai (Deployment Guide)

# 1. Clone repository và cài đặt môi trường
git clone https://github.com/example/rag-question-answering.git
cd rag-question-answering
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt

# 2. Khởi chạy Backend API Service
uvicorn api:app --host 0.0.0.0 --port 8000 --reload

# 3. Khởi chạy Frontend Chat Interface
streamlit run app.py --server.port 8501

Yêu cầu hệ thống tối thiểu:
- CPU: 4 vCPU Intel Xeon / AMD EPYC
- RAM: 16 GB System Memory
- GPU: Nvidia T4 (16GB VRAM) hoặc RTX 3060/4060 (12GB VRAM trở lên)
- Storage: 30 GB SSD khả dụng (chứa Model weights và Vector DB)

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Độ dài ngữ cảnh: Giới hạn phân đoạn (chunking) cố định có thể làm mất tính liên tục nếu thông tin cần trả lời trải dài qua nhiều bảng biểu hoặc trang tài liệu khác nhau.
  • Ngôn ngữ hỗn hợp: Mô hình bge-base-en-v1 và Meta-Llama-3-8B được tối ưu mạnh nhất cho tiếng Anh; khi xử lý tài liệu tiếng Việt chuyên ngành sâu vẫn cần thêm module dịch thuật hoặc bộ tokenizer tiếng Việt chuyên dụng.
  • Xử lý bảng và hình ảnh: Hệ thống hiện tại chỉ trích xuất văn bản thuần túy, chưa tối ưu cho bảng biểu phức tạp hoặc biểu đồ (Multimodal data).

Hướng phát triển trong tương lai

  • Tích hợp Advanced RAG với cơ chế HyDE (Hypothetical Document Embeddings) và Cross-Encoder Re-ranker (như Cohere Rerank hoặc BGE-Reranker-Large) nhằm nâng cao độ chính xác truy xuất lên > 95%.
  • Nghiên cứu triển khai GraphRAG (Knowledge Graph RAG) nhằm trích xuất mối quan hệ thực thể phức tạp giữa các văn bản.
  • Xây dựng cơ chế Agentic RAG: Tự động phân rã câu hỏi phức tạp thành nhiều truy vấn con (Multi-step routing) và kiểm chứng tính hợp lý của câu trả lời trước khi phản hồi người dùng.

Đối tượng hưởng lợi

+-------------------+---------------------------------------------------------+
| Nhóm đối tượng    | Giá trị và lợi ích định lượng                           |
+-------------------+---------------------------------------------------------+
| Sinh viên         | Tài liệu tham khảo hoàn chỉnh về RAG pipeline, mã nguồn |
|                   | mẫu tích hợp LangChain, ChromaDB và Llama 3.           |
+-------------------+---------------------------------------------------------+
| Lập trình viên    | Kiến trúc triển khai thực tế với FastAPI & Streamlit;   |
| (AI Developers)   | các kỹ thuật lượng hóa mô hình chạy trên phần cứng nhỏ. |
+-------------------+---------------------------------------------------------+
| Doanh nghiệp      | Giải pháp tra cứu tri thức nội bộ bảo mật, tiết kiệm    |
|                   | 90% chi phí vận hành so với sử dụng dịch vụ đám mây.    |
+-------------------+---------------------------------------------------------+
| Nhà nghiên cứu    | Khung đánh giá định lượng bằng Ragas và dữ liệu thực    |
|                   | nghiệm so sánh giữa Dense vs Sparse Retrieval.          |
+-------------------+---------------------------------------------------------+

Câu hỏi thường gặp

1. Cấu hình phần cứng tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu tối thiểu 1 GPU Nvidia với 12GB–16GB VRAM (như RTX 3060, T4, A10G) để tải trọng số Meta-Llama-3-8B-Instruct ở định dạng lượng hóa 4-bit (NF4). Nếu chạy hoàn toàn trên CPU, hệ thống cần tối thiểu 16GB RAM nhưng tốc độ suy luận sẽ giảm xuống 8–15 giây/truy vấn.

2. Làm thế nào để mở rộng (scale) hệ thống khi số lượng tài liệu lên tới hàng triệu trang?

Khi cơ sở dữ liệu tài liệu tăng trưởng lớn, ChromaDB cục bộ có thể được chuyển đổi sang các Vector Database phân tán chuyên dụng như Milvus, Qdrant hoặc Pinecone, đồng thời kết hợp cơ chế chỉ mục phân tầng (HNSW Indexing) và phân cụm Sharding để đảm bảo thời gian truy vấn dưới 100ms.

3. Hệ thống có thể tích hợp với các cơ sở dữ liệu quan hệ (RDBMS) sẵn có không?

Có. Thông qua framework LangChain và backend FastAPI, hệ thống có thể kết nối với PostgreSQL (sử dụng tiện ích mở rộng pgvector) hoặc MySQL để đồng bộ hóa dữ liệu có cấu trúc và phi cấu trúc vào cùng một điểm truy xuất thống nhất.

4. Chi phí vận hành và bảo trì hệ thống ước tính như thế nào?

Nhờ sử dụng hoàn toàn các mô hình mã nguồn mở (Open-source LLM & Embedding), chi phí vận hành bản quyền API là 0 VNĐ. Chi phí duy nhất là hạ tầng máy chủ GPU (khoảng 1.000.000 – 2.500.000 VNĐ/tháng nếu thuê Cloud GPU như RunPod/AWS EC2 G4dn), giảm hơn 90% so với việc gọi API OpenAI cho khối lượng lớn.

5. Làm sao để đảm bảo an toàn và bảo mật dữ liệu doanh nghiệp?

Toàn bộ quy trình từ nhúng vector, lưu trữ dữ liệu tại ChromaDB đến suy luận mô hình Llama-3 đều diễn ra cục bộ (On-premise) trong mạng nội bộ hoặc máy chủ riêng, hoàn toàn không gửi dữ liệu ra bên ngoài, đảm bảo tuân thủ các tiêu chuẩn bảo mật dữ liệu cao nhất.

Kết luận

Đồ án tốt nghiệp "Tìm hiểu Retrieval Augmented Generation (RAG) và ứng dụng cho bài toán trả lời các câu hỏi" của sinh viên Trần Văn Thắng và Trần Minh Đức đã hiện thực hóa thành công một giải pháp toàn diện, khoa học và có tính ứng dụng cao cho bài toán truy vấn thông tin thông minh. Bằng cách kết hợp linh hoạt giữa kiến trúc Transformer, mô hình nhúng bge-base-en-v1, cơ sở dữ liệu vector ChromaDB và mô hình ngôn ngữ lớn Meta-Llama-3-8B-Instruct, hệ thống giải quyết triệt để vấn đề ảo giác và điểm cắt tri thức của các mô hình truyền thống với chỉ số độ tin cậy đạt 91.4%.

Công trình nghiên cứu không chỉ đóng góp một quy trình kỹ thuật hoàn chỉnh cho cộng đồng học thuật ngành Kỹ thuật Dữ liệu mà còn mở ra tiềm năng ứng dụng thực tiễn to lớn trong việc tự động hóa tra cứu tri thức tại các trường đại học và doanh nghiệp. Hệ thống là minh chứng rõ ràng cho tính khả thi của việc ứng dụng Generative AI nguồn mở vào các bài toán thực tế với chi phí tối ưu nhất.