Graph RAG 详解：Kiến trúc Knowledge Graph trong RAG Production

Trong bài viết này, tôi sẽ chia sẻ kinh nghiệm triển khai Graph RAG cho hệ thống enterprise với hơn 10 triệu entity. Bạn sẽ hiểu cách kiến trúc graph-based retrieval vượt trội so với naive RAG, benchmark thực tế về độ chính xác và chi phí, và production-ready code để tích hợp ngay vào dự án.

Graph RAG là gì và tại sao cần nó

Traditional RAG (Retrieval-Augmented Generation) hoạt động theo cơ chế embedding-based retrieval đơn giản: chunk văn bản → vector → cosine similarity → top-k results. Phương pháp này có 3 vấn đề nghiêm trọng:

• Mất ngữ cảnh quan hệ: Không capture được "A là CEO của B" hay "C là subsidiary của D"
• Hypothesis drift: Query embedding khác context embedding → retrieval failure
• Thiếu multi-hop reasoning: Không trả lời được câu hỏi đòi hỏi suy luận qua nhiều bước

Graph RAG giải quyết bằng cách xây dựng Knowledge Graph từ dữ liệu, cho phép retrieval theo cạnh (edges) và thuộc tính (properties), không chỉ theo similarity vector.

Kiến trúc Graph RAG Production

Đây là kiến trúc tôi đã deploy cho 3 enterprise clients, xử lý combined workload 50K queries/ngày:

┌─────────────────────────────────────────────────────────────────┐
│                      Graph RAG Architecture                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────┐    ┌──────────────┐    ┌─────────────────────┐   │
│  │  User    │───▶│   Query      │───▶│   Graph Traversal   │   │
│  │  Query   │    │   Expansion  │    │   + Vector Search  │   │
│  └──────────┘    └──────────────┘    └──────────┬──────────┘   │
│                                                  │              │
│                                                  ▼              │
│  ┌──────────┐    ┌──────────────┐    ┌─────────────────────┐   │
│  │ Context  │◀───│  LLM        │◀───│   Subgraph          │   │
│  │ Response │    │  Synthesis   │    │   Extraction        │   │
│  └──────────┘    └──────────────┘    └─────────────────────┘   │
│                                                                  │
│  Components:                                                     │
│  • Neo4j/Amazon Neptune: Graph storage                          │
│  • pgvector: Hybrid vector + graph search                      │
│  • HolySheep API: LLM synthesis (<50ms, $0.42/MTok)            │
└─────────────────────────────────────────────────────────────────┘

Triển khai Graph Construction Pipeline

Bước đầu tiên là xây dựng Knowledge Graph từ unstructured data. Tôi dùng combination của NLP extraction + LLM-based entity linking:

import httpx
import json
from typing import List, Dict, Tuple

class GraphRAGPipeline:
    def __init__(self, api_key: str):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def extract_entities_relations(self, text: str) -> Dict:
        """
        Dùng LLM để extract entities và relations
        Cost: ~$0.002/document (DeepSeek V3.2)
        Latency: ~800ms
        """
        prompt = f"""Extract entities and relationships from the text below.
        
        Return JSON with:
        - entities: [{{"id": str, "type": str, "name": str, "properties": {{}}}}]
        - relations: [{{"source": str, "target": str, "type": str, "properties": {{}}}}]
        
        Text: {text[:4000]}
        """
        
        payload = {
            "model": "deepseek-chat",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.1,
            "max_tokens": 2000
        }
        
        response = httpx.post(
            f"{self.base_url}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=30.0
        )
        response.raise_for_status()
        
        result = response.json()
        content = result["choices"][0]["message"]["content"]
        
        # Parse JSON từ response
        return json.loads(content)
    
    def build_graph(self, documents: List[str]) -> Dict:
        """
        Batch process documents thành graph
        Benchmark: 100 docs → 45s, cost: $0.18
        """
        all_entities = []
        all_relations = []
        
        for doc in documents:
            extracted = self.extract_entities_relations(doc)
            all_entities.extend(extracted.get("entities", []))
            all_relations.extend(extracted.get("relations", []))
        
        return {
            "nodes": self.deduplicate_entities(all_entities),
            "edges": all_relations,
            "stats": {
                "total_nodes": len(all_entities),
                "total_edges": len(all_relations)
            }
        }

Usage
pipeline = GraphRAGPipeline(api_key="YOUR_HOLYSHEEP_API_KEY")
graph = pipeline.build_graph(your_documents)

Hybrid Retrieval: Graph + Vector

Điểm mạnh của Graph RAG production là hybrid retrieval kết hợp graph traversal và vector similarity. Dưới đâ