Advancing RAG for Structured Enterprise Data

# ai-service/processors/row_serializer.py
from typing import Dict, Any

def serialize_menu_row(item: Dict[str, Any]) -> str:
    """
    Tuần tự hoá 1 hàng của bảng menu_items thành chuỗi biểu diễn có cấu trúc.
    Bảo toàn toàn bộ các thuộc tính hàng - cột để lập chỉ mục véc-tơ và BM25.
    """
    category_name = item.get("category", {}).get("name") or item.get("categories", {}).get("name") or "Khác"
    ingredients = ", ".join(item.get("ingredients") or []) or "Không ghi chú"
    allergens = ", ".join(item.get("allergens") or []) or "Không có dị ứng phổ biến"
    spice = item.get("spice_level", 0)
    calories = item.get("calories", "N/A")
    price_vnd = f"{int(item.get('price', 0)):,} VND"

    serialized = (
        f"[MÓN ĂN: {item.get('name', 'Chưa rõ')}]\n"
        f"• Phân loại: {category_name}\n"
        f"• Giá bán: {price_vnd}\n"
        f"• Độ cay: {spice}/5\n"
        f"• Lượng Calo: {calories} kcal\n"
        f"• Thành phần nguyên liệu: {ingredients}\n"
        f"• Cảnh báo dị ứng: {allergens}\n"
        f"• Mô tả hương vị: {item.get('description', '')} {item.get('ai_description', '')}"
    )
    return serialized.strip()

# ai-service/processors/hybrid_retriever.py
import numpy as np
import faiss
from rank_bm25 import BM25Okapi
from sentence_transformers import SentenceTransformer
from typing import List, Dict, Any, Tuple

class HybridMenuRetriever:
    def __init__(self, dense_model_name: str = "sentence-transformers/all-mpnet-base-v2"):
        # Load mô hình Dense Embeddings
        self.encoder = SentenceTransformer(dense_model_name)
        self.dimension = 768
        
        # Cấu hình FAISS HNSW theo paper (M=32, efConstruction=200, efSearch=50)
        self.index = faiss.IndexHNSWFlat(self.dimension, 32)
        self.index.hnsw.efConstruction = 200
        self.index.hnsw.efSearch = 50
        
        self.corpus_items: List[Dict[str, Any]] = []
        self.bm25: BM25Okapi = None

    def build_index(self, serialized_rows: List[str], raw_items: List[Dict[str, Any]]):
        self.corpus_items = raw_items
        
        # 1. Xây dựng FAISS Dense Index
        embeddings = self.encoder.encode(serialized_rows, convert_to_numpy=True, normalize_embeddings=True)
        self.index.reset()
        self.index.add(embeddings)
        
        # 2. Xây dựng BM25 Sparse Index
        tokenized_corpus = [doc.lower().split() for doc in serialized_rows]
        self.bm25 = BM25Okapi(tokenized_corpus)

    def retrieve(self, query: str, top_k: int = 20) -> List[Tuple[Dict[str, Any], float]]:
        if not self.corpus_items:
            return []
            
        # A. Dense Query
        q_emb = self.encoder.encode([query], convert_to_numpy=True, normalize_embeddings=True)
        dense_distances, dense_indices = self.index.search(q_emb, len(self.corpus_items))
        
        dense_scores = {dense_indices[0][i]: float(dense_distances[0][i]) for i in range(len(dense_indices[0]))}
        
        # B. Sparse Query (BM25)
        bm25_scores_raw = self.bm25.get_scores(query.lower().split())
        max_bm25 = max(bm25_scores_raw) if max(bm25_scores_raw) > 0 else 1.0
        sparse_scores = {i: float(bm25_scores_raw[i] / max_bm25) for i in range(len(bm25_scores_raw))}
        
        # C. Weighted Score Fusion (0.6 Dense + 0.4 Sparse theo Paper 01)
        combined_results = []
        for idx in range(len(self.corpus_items)):
            d_score = dense_scores.get(idx, 0.0)
            s_score = sparse_scores.get(idx, 0.0)
            final_score = 0.6 * d_score + 0.4 * s_score
            combined_results.append((self.corpus_items[idx], final_score))
            
        # Sắp xếp giảm dần và lấy Top-K
        combined_results.sort(key=lambda x: x[1], reverse=True)
        return combined_results[:top_k]

# ai-service/processors/cross_encoder_reranker.py
from sentence_transformers import CrossEncoder
from typing import List, Dict, Any, Tuple
from processors.row_serializer import serialize_menu_row

class ContextualReranker:
    def __init__(self, model_name: str = "cross-encoder/ms-marco-MiniLM-L-12-v2"):
        self.reranker = CrossEncoder(model_name)

    def rerank(self, query: str, candidate_items: List[Dict[str, Any]], top_k: int = 5) -> List[Dict[str, Any]]:
        if not candidate_items:
            return []
            
        # Chuẩn bị cặp (query, passage)
        pairs = [(query, serialize_menu_row(item)) for item in candidate_items]
        
        # Dự đoán điểm liên quan trực tiếp
        scores = self.reranker.predict(pairs)
        
        # Ghép cặp item với điểm số và sắp xếp
        scored_candidates = list(zip(candidate_items, scores))
        scored_candidates.sort(key=lambda x: x[1], reverse=True)
        
        return [item for item, _ in scored_candidates[:top_k]]

// backend/src/services/ragService.js (Bổ sung hàm xử lý phản hồi người dùng)
async function handleUserFeedback(sessionId, messageId, feedbackType, lastQuery) {
  // Ghi nhật ký feedback (thumbs up / thumbs down)
  console.log(`[Feedback] Session: ${sessionId}, Type: ${feedbackType}, Query: "${lastQuery}"`);

  if (feedbackType === 'thumbs_down') {
    // Kích hoạt Query Reformulation trên ai-service theo Paper 01 Mục 3.7
    try {
      const response = await fetch(`${process.env.AI_SERVICE_URL || 'http://localhost:8000'}/reformulate`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ query: lastQuery, sessionId })
      });
      return await response.json();
    } catch (err) {
      console.error('[ragService] Lỗi khi kích hoạt reformulate:', err.message);
    }
  }
  return { status: 'recorded' };
}