update code

app.py

@@ -1,249 +1,142 @@
 """
-REST API cho Vietnam Heritage RAG System
+REST API cho Vietnam Heritage RAG System 
 """
 import uuid
-import json
 import os
 import sys
-from datetime import datetime
 
-import google.generativeai as genai
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
-# Add service directory to sys.path to allow imports
+# Thêm thư mục service vào sys.path
 sys.path.append(os.path.join(os.path.dirname(__file__), 'service'))
-from rewrite import QueryRewriter
+from service.reranking import advanced_search
+from service.rewrite import QueryRewriter
 
 app = Flask(__name__)
 CORS(app)
-# Khởi tạo QueryRewriter (chứa ask_with_context)
-rewriter = QueryRewriter()
-islog = os.getenv('islog')
-metrics_log = []  # Lưu lại các lần đánh giá để dựng biểu đồ
-
-GENAI_API_KEY = os.getenv("GEMINI_API_KEY")
-if GENAI_API_KEY:
-    genai.configure(api_key=GENAI_API_KEY)
 
+# Khởi tạo QueryRewriter (chứa toàn bộ pipeline RAG)
+rewriter = QueryRewriter()
 
-def _safe_json_parse(text):
-    """Parse chuỗi JSON, cố gắng trích block {} đầu tiên nếu có thêm text."""
-    try:
-        return json.loads(text)
-    except Exception:
-        pass
-
-    start = text.find("{")
-    end = text.rfind("}")
-    if start != -1 and end != -1 and end > start:
-        try:
-            return json.loads(text[start : end + 1])
-        except Exception:
-            return None
-    return None
-
-
-def evaluate_answer_llm(question: str, answer: str, history_message):
-    """Gọi LLM để chấm điểm mức liên quan, độ chính xác và mức độ lan man."""
-    if not GENAI_API_KEY:
-        return {
-            "status": "skipped",
-            "reason": "missing_gemini_api_key",
-        }
 
-    try:
-        model = genai.GenerativeModel("gemini-2.5-flash")
-        history_text = "\n".join([m.get("content", "") for m in history_message]) if history_message else ""
-        prompt = (
-            "You are an evaluator for a RAG chatbot."
-            " Return JSON with keys: rag_relevance (0-1), answer_accuracy (0-1), hallucination (bool), notes (string)."
-            " Evaluate strictly from question and answer (and chat history if provided)."
-            " rag_relevance measures how well retrieved context seems relevant to the question."
-            " answer_accuracy measures factual correctness and completeness."
-            " hallucination is true if the answer includes unrelated, fabricated, or off-topic info."
-            f"\nQuestion: {question}\nAnswer: {answer}\nHistory: {history_text}\nReturn JSON only."
-        )
-        resp = model.generate_content(prompt)
-        parsed = _safe_json_parse(resp.text)
-        if not parsed:
-            raise ValueError("LLM did not return valid JSON")
-
-        rag_rel = float(parsed.get("rag_relevance", 0))
-        acc = float(parsed.get("answer_accuracy", 0))
-        halluc = bool(parsed.get("hallucination", False))
-
-        return {
-            "status": "ok",
-            "timestamp": datetime.utcnow().isoformat() + "Z",
-            "rag_relevance": max(0.0, min(1.0, rag_rel)),
-            "answer_accuracy": max(0.0, min(1.0, acc)),
-            "hallucination": halluc,
-            "notes": parsed.get("notes", "") or "",
-        }
-    except Exception as e:
-        return {
-            "status": "error",
-            "error": str(e),
-        }
+# ==============================================================================
+# ENDPOINTS
+# ==============================================================================
 
 @app.route('/v1/chat/completions', methods=['POST'])
 def ask_api():
     """
-    Main endpoint - Gọi ask_with_context
-    
+    Main endpoint - Chat với AI về văn hoá Việt Nam.
+
     Request body:
     {
-        "question": "Câu hỏi của bạn"
+        "messages": [
+            {"role": "user", "content": "Câu hỏi của bạn"}
+        ]
     }
-    
+
     Response:
     {
-        "question": "Câu hỏi",
-        "answer": "Câu trả lời từ RAG"
+        "id": "uuid",
+        "object": "chat.completion",
+        "choices": [{"index": 0, "message": {"role": "assistant", "content": "..."}, "finish_reason": "stop"}],
+        "image_url": "https://..." hoặc null
     }
-    """    
+    """
     try:
         data = request.get_json()
-        all_messages = data.get("messages", [])
-        history_message = all_messages[-6:-1]
-        # if islog == "1":
-        #     for f in history_message:
-        #         print(f)
-        
+        if not data:
+            return jsonify({"error": "Request body is required"}), 400
 
-        
+        all_messages = data.get("messages", [])
+        if not all_messages:
+            return jsonify({"error": "'messages' cannot be empty"}), 400
 
-        question = all_messages[-1]["content"]
-        
+        question = all_messages[-1].get("content", "").strip()
         if not question:
-            return jsonify({
-                "error": "'question' cannot be empty"
-            }), 400
-        
-        # Gọi ask_with_context
-        answer = rewriter.ask_with_context(question, history_message)
-
-        # Đánh giá tự động bằng LLM
-        # evaluation = evaluate_answer_llm(question, answer, history_message)
-        # if evaluation:
-        #     metrics_log.append({
-        #         "question": question,
-        #         "answer": answer,
-        #         "evaluation": evaluation,
-        #     })
-        #     # Giữ kích thước log vừa phải để hiển thị biểu đồ
-        #     if len(metrics_log) > 200:
-        #         del metrics_log[:-200]
+            return jsonify({"error": "Last message content cannot be empty"}), 400
+
+        # Lấy tối đa 3 lượt hội thoại gần nhất (không tính message hiện tại)
+        history_message = all_messages[-7:-1]
+
+        # Pipeline RAG → trả về (answer_text, image_url | None)
+        answer, image_url = rewriter.ask_with_context(question, history_message)
 
         return jsonify({
             "id": str(uuid.uuid4()),
-            "object": "chat.completion",
-            "choices": [
+            "message": [
                 {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": answer
-                    },
-                    "finish_reason": "stop"
+                    "role": "assistant",
+                    "content": answer
                 }
             ],
-            "evaluation": "evaluation"
+            "image_url": image_url
         }), 200
-    
+
     except Exception as e:
         return jsonify({
             "error": str(e),
             "status": "error"
         }), 500
 
+
 @app.route('/v1/models', methods=['GET'])
-def lstmodel():
+def list_models():
     return jsonify({
         "object": "list",
         "data": [
-            {"id": "Model-1", "object": "model", "owned_by": "owner"},
-            {"id": "Model-2", "object": "model", "owned_by": "owner"}
-            ]
+            {"id": "vietnam-heritage-rag-v1", "object": "model", "owned_by": "culturebot"}
+        ]
     }), 200
-        
+
 
 @app.route('/health', methods=['GET'])
 def health_check():
     """Health check endpoint"""
+    question = "Người Ê Đê là một dân tộc thiểu số tại Việt Nam, chủ yếu sống ở vùng Tây Nguyên. Văn hóa của người Ê Đê được đặc trưng bởi các yếu tố sau:     - **Ngôn n"
+    history_message = ['người Ê Đê', 'văn hoá']
+    advanced_search(question, history_message)
     return jsonify({
         "status": "healthy",
         "service": "Vietnam Heritage RAG API"
     }), 200
 
+
 @app.route('/', methods=['GET'])
 def home():
     """API documentation"""
     return jsonify({
         "message": "Vietnam Heritage AI REST API",
-        "version": "1.0.0",
+        "version": "2.0.0",
         "endpoints": {
-            "POST /ask": {
-                "description": "Ask a question about Vietnamese heritage",
-                "body": {
-                    "question": "Your question here"
-                }
-            },
-            "GET /health": "Health check endpoint",
-            "GET /": "API documentation",
-            "GET /lstmodel": "List available models"
+            "POST /v1/chat/completions": "Chat với AI về văn hoá Việt Nam",
+            "GET /v1/models": "Danh sách model",
+            "GET /health": "Health check",
+            "GET /": "API documentation"
         },
         "example": {
-            "url": "/ask",
+            "url": "/v1/chat/completions",
             "method": "POST",
             "body": {
-                "question": "Nguyễn Trãi là ai?"
+                "messages": [
+                    {"role": "user", "content": "Giới thiệu về Vịnh Hạ Long"}
+                ]
             }
         }
     }), 200
 
 
-@app.route('/metrics', methods=['GET'])
-def get_metrics():
-    """Trả về log đánh giá để dựng biểu đồ ở frontend."""
-    # Tính trung bình nhanh để tiện hiển thị
-    rag_scores = [m["evaluation"].get("rag_relevance", 0) for m in metrics_log if m.get("evaluation", {}).get("status") == "ok"]
-    acc_scores = [m["evaluation"].get("answer_accuracy", 0) for m in metrics_log if m.get("evaluation", {}).get("status") == "ok"]
-    halluc_counts = [m["evaluation"].get("hallucination", False) for m in metrics_log if m.get("evaluation", {}).get("status") == "ok"]
-
-    summary = {
-        "total": len(metrics_log),
-        "avg_rag_relevance": sum(rag_scores) / len(rag_scores) if rag_scores else 0,
-        "avg_answer_accuracy": sum(acc_scores) / len(acc_scores) if acc_scores else 0,
-        "hallucination_rate": (sum(1 for h in halluc_counts if h) / len(halluc_counts)) if halluc_counts else 0,
-    }
-
-    return jsonify({
-        "summary": summary,
-        "data": metrics_log,
-    }), 200
-
-@app.route('/reset', methods=['POST'])
-def reset_history():
-    """Reset conversation history"""
-    global history
-    history = []
-    return jsonify({
-        "message": "History reset successfully",
-        "status": "success"
-    }), 200
-
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 5000))
     print("=" * 60)
-    print(f"🚀 Vietnam Heritage RAG API")
+    print("🚀 Vietnam Heritage RAG API")
     print("=" * 60)
     print(f"📍 Server: http://localhost:{port}")
     print(f"📝 Endpoints:")
-    print(f"   POST http://localhost:{port}/ask")
+    print(f"   POST http://localhost:{port}/v1/chat/completions")
     print(f"   GET  http://localhost:{port}/health")
     print(f"   GET  http://localhost:{port}/")
     print("=" * 60)
-    
-    app.run(host='0.0.0.0', port=port, debug=True)
+
+    app.run(host='0.0.0.0', port=port, debug=False)

requirements_rag.txt

@@ -12,4 +12,5 @@ gunicorn>=20.1.0
 flask-cors>=3.0.10
 google-generativeai>=0.3.3
 bitsandbytes>=0.39.1
-accelerate>=0.30.3
+accelerate>=0.30.3
+rank_bm25>=0.2.1

service/helper.py

@@ -18,7 +18,7 @@ def format_metadata_list_to_context(search_results: List[Dict[str, Any]]) -> str
 
         # 1. Trích xuất dữ liệu (Dùng .get để tránh lỗi nếu thiếu trường)
         ten = data.get('ten') or data.get('group', 'Không rõ tên')
-        mo_ta = data.get('mo_ta') or data.get('content', '')
+        mo_ta = data.get('mo_ta') or data.get('combined_text') or data.get('original_content') or data.get('content', '')
         
         # Nhóm thông tin phân loại
         loai_hinh = data.get('loai_hinh', 'N/A')
@@ -40,13 +40,6 @@ def format_metadata_list_to_context(search_results: List[Dict[str, Any]]) -> str
         [TỔNG QUAN]
         Tên: {ten}
         Mô tả/Nội dung: {mo_ta}
-        
-        [THÔNG TIN CHI TIẾT]
-        - Phân loại: {loai_hinh} (Chủ đề: {chu_de})
-        - Dân tộc: {dan_toc}
-        - Thời gian: {nien_dai} ({thoi_ky})
-        - Địa danh/Vùng miền: {vung_mien} - {dia_diem}
-        - Chất liệu: {chat_lieu} - Nguyên liệu chính: {nguyen_lieu_chinh}
         """
         
         # 3. Ghép vào chuỗi tổng

service/rag.py

@@ -1,244 +1,268 @@
 import os
 import json
+import ast
 import numpy as np
 import faiss
 from sentence_transformers import SentenceTransformer
-from datasets import load_dataset, load_from_disk
-from huggingface_hub import snapshot_download
+from datasets import load_dataset
 from typing import List, Dict, Any, Optional
-from huggingface_hub import hf_hub_download
-from helper import format_metadata_list_to_context
+from .helper import format_metadata_list_to_context
 
-# ==============================================================================
-# HỆ THỐNG RAG 1: SỬ DỤNG HUGGING FACE DATASET
-# ==============================================================================
-class HuggingFaceRAGService:
-    _instance: Optional['HuggingFaceRAGService'] = None
-    
-    # Singleton Pattern
-    def __new__(cls):
-        if cls._instance is None:
-            print("Khởi tạo HuggingFaceRAGService...")
-            cls._instance = super(HuggingFaceRAGService, cls).__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
+try:
+    from rank_bm25 import BM25Okapi
+except ImportError:
+    BM25Okapi = None
+    print("Cảnh báo: Thư viện rank_bm25 chưa được cài đặt, keyword search có thể bị ảnh hưởng.")
 
-    def __init__(self):
-        if self._initialized:
-            return
-        
-        # --- CẤU HÌNH ---
-        self.MODEL_NAME = "all-MiniLM-L6-v2"
-        
-        # ID của Repo trên Hugging Face chứa file index và data
-        # Bạn cần đảm bảo đã upload file .faiss và .json lên repo này (dạng Dataset hoặc Model)
-        self.HF_REPO_ID = "synguyen1106/vietnam_heritage_embeddings_v4"
-        self.HF_REPO_TYPE = "dataset" # Hoặc "model" hoặc "space" tùy nơi bạn để file
+class SingleDatasetRAGService:
+    """Xử lý load dữ liệu, tạo vector và tìm kiếm FAISS+BM25 cho một dataset cụ thể."""
+    def __init__(self, model: SentenceTransformer, dataset_id: str, faiss_path: str):
+        self.model = model
+        self.DATASET_ID = dataset_id
+        self.FAISS_INDEX_PATH = faiss_path
         
-        # Tên file trên repo HF
-        self.FILENAME_INDEX = "heritage.faiss"
-        self.FILENAME_META = "metadata.json"
-        # self.FILENAME_IDS = "ids.json" # Nếu bạn gộp vào metadata thì ko cần file này
+        self.dataset_records = []
+        self.image_lookup = {}
+        self.bm25_index = None
+        self.index = None
         
-        # Load model & Data
-        self._load_model()
         self._load_data()
-        
-        self._initialized = True
-        print("✅ HuggingFaceRAGService đã sẵn sàng.")
+        print(f"✅ SingleDatasetRAGService ({self.DATASET_ID}) đã sẵn sàng.")
 
-    def _load_model(self):
-        print(f"🤖 [HF RAG] Đang tải model embedding: {self.MODEL_NAME}...")
-        self.model = SentenceTransformer(self.MODEL_NAME)
+    def _parse_image_url(self, raw) -> str:
+        """Parse image_urls dù là list hay string JSON, trả về URL đầu tiên hợp lệ."""
+        if isinstance(raw, list):
+            for url in raw:
+                if isinstance(url, str) and url.startswith('http'):
+                    return url
+        elif isinstance(raw, str) and raw.strip():
+            raw = raw.strip()
+            if raw.startswith('http'):
+                return raw
+            try:
+                parsed = ast.literal_eval(raw)
+                if isinstance(parsed, list):
+                    for url in parsed:
+                        if isinstance(url, str) and url.startswith('http'):
+                            return url
+            except Exception:
+                pass
+        return None
 
     def _load_data(self):
-        """
-        Chiến lược:
-        1. Cố gắng tải file index đã build sẵn từ Hugging Face (Nhanh, tránh lỗi LFS).
-        2. Nếu không tìm thấy file trên HF, fallback về việc tải Dataset gốc và build lại index (Chậm hơn).
-        """
+        print(f"💾 [RAG {self.DATASET_ID}] Đang tải dataset...")
         try:
-            print(f"⬇️ [HF RAG] Đang thử tải Index pre-built từ HF Hub: {self.HF_REPO_ID}...")
+            dataset = load_dataset(self.DATASET_ID, split="train")
             
-            # 1. Tải file FAISS Index
-            # hf_hub_download sẽ tự xử lý caching và LFS pointer
-            index_path = hf_hub_download(
-                repo_id=self.HF_REPO_ID,
-                filename=self.FILENAME_INDEX,
-                repo_type=self.HF_REPO_TYPE
-            )
+            tokenized_corpus = []
+            texts_for_embedding = []
             
-            # 2. Tải file Metadata
-            metadata_path = hf_hub_download(
-                repo_id=self.HF_REPO_ID,
-                filename=self.FILENAME_META,
-                repo_type=self.HF_REPO_TYPE
-            )
-
-            # 3. Load vào RAM
-            print(f"📂 [HF RAG] Đang đọc file index từ: {index_path}")
-            self.index = faiss.read_index(index_path)
+            count_img = 0
+            for item in dataset:
+                group = item.get('group', '')
+                if not group:
+                    continue
+                    
+                group_str = str(group).strip()
+                group_lower = group_str.lower()
+                
+                # 1. Image lookup
+                imgs = item.get('image_urls', [])
+                if group_lower not in self.image_lookup:
+                    url = self._parse_image_url(imgs)
+                    if url:
+                        self.image_lookup[group_lower] = url
+                        count_img += 1
+                
+                # 2. Extract metadata
+                meta_raw = item.get('metadata', {})
+                if isinstance(meta_raw, str):
+                    try:
+                        meta_dict = ast.literal_eval(meta_raw)
+                    except:
+                        meta_dict = {}
+                else:
+                    meta_dict = meta_raw if isinstance(meta_raw, dict) else {}
+                
+                # Dùng combined_text nếu có
+                content = str(item.get('combined_text', ''))[:3000]
+                
+                record = {
+                    "group": group_str,
+                    "combined_text": content,
+                    "original_content": str(item.get('original_content', ''))[:3000],
+                    "image_urls": item.get('image_urls', []),
+                    "dataset_source": self.DATASET_ID, # Đánh dấu nguồn
+                    **meta_dict
+                }
+                
+                search_text = f"{group_str}. {content}"
+                
+                self.dataset_records.append(record)
+                texts_for_embedding.append(search_text)
+                
+                tokenized_corpus.append(search_text.lower().split())
+
+            print(f"🖼️  [RAG {self.DATASET_ID}] Image lookup built: {count_img} entries.")
             
-            with open(metadata_path, "r", encoding="utf-8") as f:
-                self.metadata = json.load(f)
+            if BM25Okapi is not None and tokenized_corpus:
+                print(f"🔍 [RAG {self.DATASET_ID}] Build BM25 cho {len(tokenized_corpus)} records...")
+                self.bm25_index = BM25Okapi(tokenized_corpus)
                 
-            print(f"✅ [HF RAG] Load thành công từ Cache HF! (Items: {self.index.ntotal})")
+            if os.path.exists(self.FAISS_INDEX_PATH):
+                print(f"📂 [RAG {self.DATASET_ID}] Đọc file FAISS từ: {self.FAISS_INDEX_PATH}")
+                self.index = faiss.read_index(self.FAISS_INDEX_PATH)
+                if self.index.ntotal != len(self.dataset_records):
+                    print(f"⚠️ [RAG {self.DATASET_ID}] Kích thước FAISS không khớp, build lại...")
+                    self._build_faiss(texts_for_embedding)
+            else:
+                self._build_faiss(texts_for_embedding)
 
         except Exception as e:
-            print(f"⚠️ [HF RAG] Không tải được pre-built index ({e}). \n🔄 Chuyển sang build từ Dataset gốc...")
-            self._build_from_dataset()
-
-    def _build_from_dataset(self):
-        """
-        Hàm fallback: Tải dataset thô và build index tại chỗ (Tốn RAM và CPU lúc khởi động)
-        """
-        print("💾 [HF RAG] Đang tải dataset và xây dựng FAISS index mới...")
-        dataset = load_dataset(self.HF_REPO_ID, split="train")
-        
-        # Chuẩn bị vectors
-        vectors = np.array(dataset['embedding']).astype("float32")
-        
-        # Chuẩn bị metadata (loại bỏ cột embedding để nhẹ RAM)
-        self.metadata = [{k: v for k, v in item.items() if k != 'embedding'} for item in dataset]
-        
-        # Build Index
+            import traceback
+            traceback.print_exc()
+            print(f"❌ [RAG {self.DATASET_ID}] Lỗi load dataset: {e}")
+
+    def _build_faiss(self, texts: List[str]):
+        print(f"🔨 [RAG {self.DATASET_ID}] Đang embed {len(texts)} văn bản...")
+        vectors = self.model.encode(texts, convert_to_numpy=True, show_progress_bar=True).astype("float32")
         d = vectors.shape[1]
         self.index = faiss.IndexFlatL2(d)
         self.index.add(vectors)
-        
-        print(f"🔨 [HF RAG] Đã build xong index. Số lượng vector: {self.index.ntotal}")
-        
-        # Mẹo: Ở đây bạn có thể lưu file ra đĩa và upload ngược lên HF để lần sau dùng cách 1
+        faiss.write_index(self.index, self.FAISS_INDEX_PATH)
+        print(f"✅ [RAG {self.DATASET_ID}] Build và lưu FAISS thành công.")
 
-    def search(self, query: str, k: int = 2) -> List[Dict[str, Any]]:
-        # Encode câu hỏi
-        query_vec = self.model.encode([query], convert_to_numpy=True).astype("float32")
-        
-        # Search FAISS
-        distances, indices = self.index.search(query_vec, k)
+    def get_image_for_topic(self, topic_name: str) -> str:
+        if not topic_name or not self.image_lookup:
+            return None
+        topic_lower = topic_name.strip().lower()
+        if topic_lower in self.image_lookup:
+            return self.image_lookup[topic_lower]
+        for group_key, url in self.image_lookup.items():
+            if topic_lower in group_key or group_key in topic_lower:
+                return url
+        return None
+
+    def search(self, query: str, top_k: int = 3) -> List[Dict[str, Any]]:
+        if not self.dataset_records:
+            return []
+            
+        faiss_scores = {}
+        bm25_scores = {}
+        fetch_k = min(len(self.dataset_records), 60)
         
-        # Map kết quả
+        try:
+            if self.index:
+                query_vec = self.model.encode([query], convert_to_numpy=True).astype("float32")
+                distances, indices = self.index.search(query_vec, fetch_k)
+                for rank, idx in enumerate(indices[0]):
+                    idx_int = int(idx)
+                    if 0 <= idx_int < len(self.dataset_records):
+                        faiss_scores[idx_int] = rank + 1
+        except Exception as e:
+            print(f"❌ Lỗi FAISS ({self.DATASET_ID}): {e}")
+
+        try:
+            if self.bm25_index:
+                tokenized_query = query.lower().split()
+                scores = self.bm25_index.get_scores(tokenized_query)
+                top_indexes = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:fetch_k]
+                for rank, idx in enumerate(top_indexes):
+                    if scores[idx] > 0:
+                        bm25_scores[idx] = rank + 1
+        except Exception as e:
+            print(f"❌ Lỗi BM25 ({self.DATASET_ID}): {e}")
+
+        k_rrf = 60
+        rrf_scores = {}
+        all_indices = set(list(faiss_scores.keys()) + list(bm25_scores.keys()))
+        for idx in all_indices:
+            score = 0.0
+            if idx in faiss_scores:
+                score += 1.0 / (k_rrf + faiss_scores[idx])
+            if idx in bm25_scores:
+                score += 1.0 / (k_rrf + bm25_scores[idx])
+            rrf_scores[idx] = score
+            
+        sorted_indices = sorted(rrf_scores.keys(), key=lambda idx: rrf_scores[idx], reverse=True)
         results = []
-        for i, idx in enumerate(indices[0]):
-            if idx != -1: # Kiểm tra nếu tìm thấy
-                item = {
-                    "score": float(distances[0][i]), # Distance càng nhỏ càng giống (với L2)
-                    "metadata": self.metadata[int(idx)]
-                }
-                results.append(item)
-                
+        for idx in sorted_indices[:top_k]:
+            item = {
+                "score": round(rrf_scores[idx], 4),
+                "metadata": self.dataset_records[idx]
+            }
+            results.append(item)
+            
         return results
-# ==============================================================================
-# HỆ THỐNG RAG 2: SỬ DỤNG LOCAL DISK DATASET
-# ==============================================================================
-class LocalDiskRAGService:
-    _instance: Optional['LocalDiskRAGService'] = None
 
+class MultiDatasetRAGService:
+    """Service tổng quản lý model Embedding chung và gọi search qua nhiều Dataset độc lập."""
+    _instance: Optional['MultiDatasetRAGService'] = None
+    
     def __new__(cls):
         if cls._instance is None:
-            print("\nKhởi tạo LocalDiskRAGService...")
-            cls._instance = super(LocalDiskRAGService, cls).__new__(cls)
+            print("Khởi tạo MultiDatasetRAGService...")
+            cls._instance = super(MultiDatasetRAGService, cls).__new__(cls)
             cls._instance._initialized = False
         return cls._instance
 
     def __init__(self):
         if self._initialized:
             return
+            
+        # Dùng model tiếng Việt nhẹ thay cho all-MiniLM-L6-v2 để chuẩn hóa 
+        # chung cho cả lấy Reranking (do model 1 chuyên tiếng Việt)
+        self.MODEL_NAME = "keepitreal/vietnamese-sbert"
+        print(f"🤖 [Multi RAG] Đang tải chung model embedding: {self.MODEL_NAME}...")
+        self.model = SentenceTransformer(self.MODEL_NAME)
         
-        # Cấu hình
-        self.MODEL_NAME = 'AITeamVN/Vietnamese_Embedding_v2'
-        # Thay đổi từ đường dẫn local sang ID của dataset trên Hugging Face Hub
-        self.DATASET_ID = "phongnt251199/Wiki_Culture_Vec"
-        self.MIN_CONTENT_LENGTH = 200
-        self.CANDIDATE_MULTIPLIER = 5
+        # Danh sách Dataset
+        # Lưu ý: Cập nhật tên FAISS file để tránh load nhầm file cũ không cùng dimension
+        self.datasets_config = [
+            {"id": "phongnt251199/vietnam_heritage_v3", "faiss": "heritage_v3_visbert.faiss"},
+            {"id": "phongnt251199/vietnam_heritage_wiki_chunks_v1", "faiss": "wiki_chunks_v1_visbert.faiss"}
+        ]
         
-        # Tải model và dữ liệu
-        self._load_model()
-        self._load_data()
+        self.services = []
+        for cfg in self.datasets_config:
+            svc = SingleDatasetRAGService(self.model, cfg["id"], cfg["faiss"])
+            self.services.append(svc)
+            
         self._initialized = True
-        print("✅ LocalDiskRAGService đã sẵn sàng.")
-
-    def _load_model(self):
-        print(f"🤖 [Local RAG] Đang tải model AI: {self.MODEL_NAME}...")
-        self.model = SentenceTransformer(self.MODEL_NAME)
+        print(f"✅ MultiDatasetRAGService đã sẵn sàng xử lý {len(self.services)} datasets.")
 
-    def _load_data(self):
-        print(f"💾 [Local RAG] Đang tải dữ liệu từ Hugging Face Hub: {self.DATASET_ID}...")
-        try:
-            # Tải toàn bộ dataset về và lấy đường dẫn local
-            # Hugging Face Spaces sẽ tự động sử dụng token trong secrets nếu repo là private
-            dataset_path = snapshot_download(repo_id=self.DATASET_ID, repo_type="dataset")
-            
-            self.dataset = load_from_disk(dataset_path)
-            print(f"💾 [Local RAG] Load xong! Tổng số dữ liệu: {len(self.dataset)} dòng.")
-            
-            print("🔨 [Local RAG] Đang kích hoạt bộ tìm kiếm (Re-indexing)...")
-            self.dataset.add_faiss_index(column="embeddings")
-            print("🔨 [Local RAG] Đã kích hoạt xong FAISS Index!")
-        except Exception as e:
-            print(f"❌ Lỗi: Không thể tải dataset từ Hub. Lỗi: {e}")
-            self.dataset = None
-            return
+    def get_image_for_topic(self, topic_name: str) -> str:
+        for svc in self.services:
+            url = svc.get_image_for_topic(topic_name)
+            if url: 
+                return url
+        return None
 
     def search(self, query: str, top_k: int = 3) -> List[Dict[str, Any]]:
-        if not self.dataset:
-            return []
-            
-        # print(f"\n🔎 [Local RAG] Đang tìm: '{query}'")
-        # print("-" * 50)
-
-        query_vector = self.model.encode(query)
-        candidate_k = top_k * self.CANDIDATE_MULTIPLIER
-        scores, samples = self.dataset.get_nearest_examples("embeddings", query_vector, k=candidate_k)
-
-        results = []
-        for i in range(len(samples['original_content'])):
-            if len(results) >= top_k:
-                break
-            
-            content = samples['original_content'][i]
-            if len(content) < self.MIN_CONTENT_LENGTH:
-                continue
-
-            score = scores[i]
-            metadata = samples['metadata'][i]
-            metadata['content'] = content
-            
-            results.append({
-                "metadata": metadata,
-                "score": score
-            })
+        all_results = []
+        # Lấy từ cả 2 nguồn, sau đó sort chung dựa trên Score RRF
+        for svc in self.services:
+            res = svc.search(query, top_k=top_k * 2) # Lấy dư để merge
+            all_results.extend(res)
             
-            # In ra console để debug như hàm gốc
-            # print(f"Top {len(results)} (Độ sai lệch: {score:.2f}):")
-            # print(f"Nội dung: {content[:200]}...")
-            # print("-" * 50)
-
-        if not results:
-            print(f"Không tìm thấy kết quả nào có nội dung dài hơn {self.MIN_CONTENT_LENGTH} ký tự.")
-        
-        return results
+        # Sort tổng hợp lại theo điểm tổng
+        sorted_results = sorted(all_results, key=lambda x: x['score'], reverse=True)
+        return sorted_results[:top_k]
 
 # ==============================================================================
-# KHỞI TẠO SERVICE VÀ CUNG CẤP CÁC HÀM GỐC
+# KHỞI TẠO SERVICE (SINGLETON CỦA MULTI) VÀ CUNG CẤP CÁC HÀM GỐC TƯƠNG THÍCH
 # ==============================================================================
-hf_rag_service = HuggingFaceRAGService()
-local_rag_service = LocalDiskRAGService()
+local_rag_service = MultiDatasetRAGService()
+
+# Maintain các object cũ để tương thích với các module khác
+hf_rag_service = local_rag_service
 
 def retrieve_context(query: str, k: int = 2) -> str:
-    """
-    Tìm kiếm ngữ cảnh sử dụng hệ thống RAG từ Hugging Face.
-    (Giữ nguyên hàm gốc để tương thích)
-    """
-    print("\n>>> Sử dụng hệ thống RAG 1 (HuggingFace)...")
-    results = hf_rag_service.search(query, k)
+    print(f"\n>>> [Multi RAG] Tìm kiếm: {query}")
+    results = local_rag_service.search(query, k)
     return format_metadata_list_to_context(results)
 
 def search_heritage(query: str, top_k: int = 3) -> str:
-    """
-    Tìm kiếm di sản sử dụng hệ thống RAG từ ổ đĩa cục bộ.
-    (Giữ nguyên hàm gốc để tương thích)
-    """
-    print("\n>>> Sử dụng hệ thống RAG 2 (Local Disk)...")
+    print(f"\n>>> [Multi RAG] Tìm kiếm: {query}")
     results = local_rag_service.search(query, top_k)
     return format_metadata_list_to_context(results)

service/reranking.py

@@ -1,13 +1,9 @@
-import ast
 import concurrent.futures
-from sentence_transformers import CrossEncoder
+import torch
+import torch.nn.functional as F
 
-from helper import format_metadata_list_to_context
-from rag import hf_rag_service, local_rag_service
-
-# Load model Reranker (nhẹ, chạy CPU được)
-#reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
-reranker = CrossEncoder('Alibaba-NLP/gte-multilingual-reranker-base', trust_remote_code=True)
+from .helper import format_metadata_list_to_context
+from .rag import hf_rag_service, local_rag_service
 
 def reciprocal_rank_fusion(search_results_lists: list, k_rrf: int = 60):
     """
@@ -42,11 +38,11 @@ def reciprocal_rank_fusion(search_results_lists: list, k_rrf: int = 60):
 
 def advanced_search(query, keyword):
     """
-    Tìm kiếm nâng cao kết hợp cả 2 nguồn dữ liệu, rerank và định dạng riêng biệt.
+    Tìm kiếm nâng cao: search song song các cụm từ → RRF fusion → rerank top-K (Bằng embedding model) → format context.
+    Trả về tuple: (context_string, image_url | None)
     """
     try:
-        result_wiki = []
-        result_hf = []
+        result_all = []
         
         # 1. Tạo danh sách các cụm từ tìm kiếm
         search_terms = [query]
@@ -55,107 +51,107 @@ def advanced_search(query, keyword):
         elif isinstance(keyword, str) and keyword:
             search_terms.append(keyword)
 
-        # Tối ưu: Tìm kiếm song song trên cả 2 nguồn với mỗi cụm từ
+        # 2. Tìm kiếm song song qua Manager (chứa 2 Dataset) với mỗi cụm từ
         with concurrent.futures.ThreadPoolExecutor() as executor:
-            future_to_source = {}
+            future_to_term = {}
             for r in search_terms:
-                # HF RAG
-                future_hf = executor.submit(hf_rag_service.search, r.lower(), k=15)
-                future_to_source[future_hf] = 'hf'
-                # Local RAG
-                future_local = executor.submit(local_rag_service.search, r.lower(), top_k=15)
-                future_to_source[future_local] = 'local'
+                if not r.strip(): continue
+                future = executor.submit(local_rag_service.search, r.lower(), top_k=15)
+                future_to_term[future] = r
             
-            for future in concurrent.futures.as_completed(future_to_source):
-                source = future_to_source[future]
+            for future in concurrent.futures.as_completed(future_to_term):
                 try:
                     docs = future.result()
                     if docs:
-                        if source == 'hf':
-                            result_hf.append(docs)
-                        else:
-                            result_wiki.append(docs)
+                        result_all.append(docs)
                 except Exception as e:
-                    print(f"Lỗi tìm kiếm {source}: {e}")
+                    print(f"Lỗi tìm kiếm concurrent: {e}")
 
-        if not result_hf and not result_wiki:
-            return "Không tìm thấy thông tin phù hợp."
+        if not result_all:
+            return "Không tìm thấy thông tin phù hợp.", None
 
-        # 2. Kết hợp kết quả từ các lần tìm kiếm (Fusion) và Rerank cho từng nguồn
-        # Xử lý nguồn HF RAG
-        fused_results_hf = reciprocal_rank_fusion(result_hf)
-        # Tối ưu: Giảm số lượng ứng viên rerank xuống 15 để tăng tốc độ
-        candidates_for_rerank_hf = fused_results_hf[:15]
-        pairs_to_score_hf = []
-        for item in candidates_for_rerank_hf:
-            meta = item['metadata']
-            name = meta.get('ten','') 
-            desc = meta.get('mo_ta','')
-            loai_hinh = meta.get('loai_hinh', '')
-            chu_de = meta.get('chu_de', '')
-            y_nghia = meta.get('y_nghia', '')
-            constructed_text = f"Tên: {name}. Loại hình: {loai_hinh}. Chủ đề: {chu_de}. Mô tả: {desc}. Ý nghĩa: {y_nghia}"
-            pairs_to_score_hf.append([query, constructed_text])
+        # 3. RRF Fusion sau đó Rerank tổng cộng
+        fused_results = reciprocal_rank_fusion(result_all)
+        print("candidates_for_rerank (after deduplication):", len(fused_results))
         
-        sorted_docs_hf = []
-        if pairs_to_score_hf:
-            scores_hf = reranker.predict(pairs_to_score_hf)
-            for i, doc in enumerate(candidates_for_rerank_hf):
-                doc['rerank_score'] = scores_hf[i]
-            sorted_docs_hf = sorted(candidates_for_rerank_hf, key=lambda x: x['rerank_score'], reverse=True)
-
-        # Xử lý nguồn Local (Wiki) RAG
-        fused_results_wiki = reciprocal_rank_fusion(result_wiki)
-        # Tối ưu: Giảm số lượng ứng viên rerank xuống 40
-        candidates_for_rerank_wiki = fused_results_wiki[:40]
-        print("candidates_for_rerank_wiki:", len(candidates_for_rerank_wiki))
-        pairs_to_score_wiki = []
-        for item in candidates_for_rerank_wiki:
+        # Tối ưu: Cắt giảm xuống 20 ứng viên để Reranking
+        candidates_for_rerank = fused_results[:20]
+        
+        pairs_to_score = []
+        for item in candidates_for_rerank:
             meta = item['metadata']
-            name = meta.get('group','')
-            desc = meta.get('content','')
+            # Lấy các trường đã được đồng bộ trong dataset (group, combined_text, original_content, dataset_source)
+            name = meta.get('group', '') or meta.get('ten', '')
+            desc = meta.get('combined_text') or meta.get('original_content') or meta.get('content', '')
             constructed_text = f"Tên: {name}. Mô tả: {desc}"
-            pairs_to_score_wiki.append([query, constructed_text])
-                   
-        sorted_docs_wiki = []
-        if pairs_to_score_wiki:
-            scores_wiki = reranker.predict(pairs_to_score_wiki)
-            for i, doc in enumerate(candidates_for_rerank_wiki):
-                doc['rerank_score'] = scores_wiki[i]
-            sorted_docs_wiki = sorted(candidates_for_rerank_wiki, key=lambda x: x['rerank_score'], reverse=True)
+            pairs_to_score.append([query, constructed_text])
         
-        # 3. Lấy Top 3 từ mỗi loại và định dạng riêng biệt
-        top_3_hf = sorted_docs_hf[:3]
-        top_3_wiki = sorted_docs_wiki[:3]
+        # === MỚI: Reranking bằng Cosine Similarity của model Embedding (Bỏ Cross-Encoder) ===
+        sorted_docs = []
+        if pairs_to_score:
+            print(f"Reranking {len(pairs_to_score)} candidates bằng Embedding Model siêu nhanh...")
+            try:
+                # Trích xuất model embeddings ban đầu
+                q_text = query
+                docs_texts = [p[1] for p in pairs_to_score]
+                
+                # Encode text trực tiếp
+                q_emb = local_rag_service.model.encode([q_text], convert_to_tensor=True)
+                docs_emb = local_rag_service.model.encode(docs_texts, convert_to_tensor=True)
+                
+                # Tính khoảng cách Cosine
+                cos_scores = F.cosine_similarity(q_emb, docs_emb).cpu().tolist()
+                
+                # Gán điểm và sort
+                for i, doc in enumerate(candidates_for_rerank):
+                    doc['rerank_score'] = cos_scores[i]
+                
+                sorted_docs = sorted(candidates_for_rerank, key=lambda x: x['rerank_score'], reverse=True)
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                print(f"Lỗi khi dùng embedding model de rerank, fallback sang RRF score: {e}")
+                sorted_docs = candidates_for_rerank
+        else:
+            sorted_docs = candidates_for_rerank
+
+        # Lấy top 5 kết quả tốt nhất
+        top_5 = sorted_docs[:5]
+        
+        # 4. Định dạng lại nội dung ngữ cảnh chung (Format chung)
+        final_context = format_metadata_list_to_context(top_5)
 
-        # Định dạng kết quả từ HF RAG (sử dụng helper, định dạng đầy đủ)
-        hf_context = format_metadata_list_to_context(top_3_hf)
+        if not final_context or final_context.strip() == "Không có dữ liệu ngữ cảnh.":
+            return "Không tìm thấy thông tin phù hợp.", None
 
-        # Định dạng kết quả từ Wiki RAG (chỉ tên + mô tả)
-        wiki_context_parts = []
-        for doc in top_3_wiki:
-            metadata = doc.get('metadata', {})
-            name = metadata.get('group', 'Không rõ tên')
-            section = metadata.get('section', '')
-            description = metadata.get('content', 'Không có mô tả.')
-            wiki_context_parts.append(f"[Nguồn Wiki - Tên]: {name}\n[Nguồn Wiki - Mô tả]: {description}" + (f"\n[Nguồn Wiki - Section]: {section}" if section else ""))
+        # 5. Trích xuất image_url từ các dataset đã gộp
+        image_url = None
         
-        wiki_context = "\n\n".join(wiki_context_parts)
-
-        # 4. Kết hợp hai ngữ cảnh thành một chuỗi duy nhất
-        final_context_parts = []
+        # (a) Từ topic name của top results (Ưu tiên group name)
+        for doc in top_5:
+            topic = (doc.get('metadata', {}).get('group') or doc.get('metadata', {}).get('ten') or '').strip()
+            if topic:
+                image_url = local_rag_service.get_image_for_topic(topic)
+                if image_url:
+                    print(f"[IMAGE] Found via topic: '{topic}'")
+                    break
+
+        # (b) Fallback: từ search terms
+        if not image_url:
+            for term in search_terms:
+                if term and len(term) > 2:
+                    image_url = local_rag_service.get_image_for_topic(term)
+                    if image_url:
+                        print(f"[IMAGE] Found via keyword: '{term}'")
+                        break
         
-        if wiki_context:
-            final_context_parts.append(wiki_context)
-
-
-        if hf_context and hf_context.strip() != "Không có dữ liệu ngữ cảnh.": 
-            final_context_parts.append(hf_context)
+        if image_url:
+            print(f"[IMAGE] final: {image_url}")
         
-        if not final_context_parts:
-            return "Không tìm thấy thông tin phù hợp."
+        return final_context, image_url
 
-        return "\n\n".join(final_context_parts).strip()
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         print(f"Lỗi trong advanced_search: {e}")
-        return "Đã xảy ra lỗi trong quá trình tìm kiếm nâng cao."
+        return "Đã xảy ra lỗi trong quá trình tìm kiếm nâng cao.", None

service/rewrite.py

@@ -1,14 +1,14 @@
 from groq import Groq
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-from reranking import advanced_search
+from .reranking import advanced_search
 import os
 from dotenv import load_dotenv
 
 load_dotenv()
 
 #groq_api_key = os.environ.get("GROQ_API_KEY")
-groq_api_key = os.getenv('GROQ_API_KEY')
+groq_api_key = "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"
 
 if not groq_api_key:
     raise ValueError("GROQ_API_KEY environment variable is not set")
@@ -244,6 +244,49 @@ class QueryRewriter:
         hypothetical_answer = completion.choices[0].message.content.strip()
         return hypothetical_answer
 
+    def detect_image_intent(self, query: str, history: list) -> bool:
+        """Phát hiện xem câu hỏi có ý định muốn xem hình ảnh/minh họa không."""
+        conversation_str = ""
+        for turn in history:
+            conversation_str += f"{turn['role'].capitalize()}: {turn['content']}\n"
+
+        IMAGE_INTENT_PROMPT = """Bạn là một API phân loại ý định (Intent Classifier). Nhiệm vụ duy nhất của bạn là xác định xem câu hỏi của người dùng có muốn xem HÌNH ẢNH, MINH HỌA hay không.
+
+Các ý định MUỐN XEM ẢNH bao gồm:
+- Yêu cầu trực tiếp: "cho tôi xem ảnh", "hình ảnh", "ảnh", "photo", "picture"
+- Câu hỏi ngoại hình/hình thức: "trông như thế nào", "có hình dạng gì", "diện mạo", "nhìn như thế nào"
+- Câu hỏi giới thiệu tổng quát: "giới thiệu về", "tìm hiểu về", "cho tôi biết về", "kể về"
+- Câu hỏi mô tả: "mô tả", "đặc điểm", "trình bày"
+
+Các ý định KHÔNG muốn xem ảnh:
+- Hỏi sự kiện/năm tháng: "được công nhận năm nào", "xảy ra khi nào"
+- Hỏi so sánh hàm ý trừu tượng: "khác nhau ở điểm nào", "ý nghĩa là gì"
+- Hỏi lý do/nguyên nhân: "tại sao", "vì sao"
+- Chào hỏi xã giao: "xin chào", "cảm ơn"
+
+QUY TẮC OUTPUT:
+- Chỉ trả về một từ duy nhất: YES hoặc NO
+- KHÔNG giải thích"""
+
+        user_content = f"""Lịch sử:\n{conversation_str}\nCâu hỏi: \"{query}\"\nOutput:"""
+
+        try:
+            completion = client.chat.completions.create(
+                model="meta-llama/llama-4-scout-17b-16e-instruct",
+                messages=[
+                    {"role": "system", "content": IMAGE_INTENT_PROMPT},
+                    {"role": "user", "content": user_content}
+                ],
+                max_tokens=5,
+                temperature=0.0
+            )
+            result = completion.choices[0].message.content.strip().upper()
+            print(f"\n--- image_intent: {result} ---")
+            return result.startswith("YES")
+        except Exception as e:
+            print(f"\n--- image_intent error: {e} ---")
+            return False
+
     def chain_of_thought(self,question,ans):
         COT_SYSTEM_PROMPT = """Bạn là một trợ lý AI chuyên biên tập và kiểm tra tính liên quan của câu trả lời (Relevance-Checking Editor) chuyên về văn hoá, lịch sử và địa điểm Việt Nam.
         NHIỆM VỤ CỐT LÕI: Dựa vào "Câu hỏi gốc", hãy lọc lại "Câu trả lời được tạo ra" để đảm bảo mọi thông tin trong câu trả lời cuối cùng đều liên quan trực tiếp đến chủ thể trong câu hỏi.
@@ -252,7 +295,7 @@ class QueryRewriter:
         1.  **Nếu câu trả lời mang ý nghĩa xã giao (chào hỏi, cảm ơn, v.v...) hoặc tôi không tìm thấy thông tin về vấn đề này trong tài liệu được cung cấp. **, hãy trả về nguyên văn câu trả lời ban đầu mà không chỉnh sửa gì.
         2.  **Xác định chủ thể chính**: Đọc kỹ "Câu hỏi gốc" để xác định đối tượng, địa danh, hoặc khái niệm chính mà người dùng đang hỏi.
         3.  **Kiểm tra và lọc**: Rà soát từng câu, từng ý trong "Câu trả lời được tạo ra".
-            *   **Giữ lại**: Chỉ giữ lại những thông tin mô tả, giải thích, hoặc liệt kê các chi tiết liên quan đến chủ thể chính của câu hỏi.
+            *   **Giữ lại**: Chỉ giữ lại những thông tin mô tả, giải thích, hoặc liệt kê các chi tiết liên quan, url hình ảnh (https://raw.githubusercontent.com/T-Phong/WikiImage/main/Aodai_%C3%81o%20d%C3%A0i_Introduction_2.png), v.v. liên quan đến chủ thể chính của câu hỏi.
             *   **Loại bỏ**: Xóa bỏ hoàn toàn bất kỳ thông tin nào nói về một chủ thể khác, không liên quan.
         4.  **Tổng hợp lại**: Viết lại câu trả lời cuối cùng một cách mạch lạc, tự nhiên từ những thông tin đã được lọc.
 
@@ -288,92 +331,95 @@ class QueryRewriter:
                 {"role": "user", "content": user_content}
             ]
         )
-        print("answer before cot:",ans)
+        
         return completion.choices[0].message.content.strip()
     
-    def ask_with_context(self,question,history):
-        
-        # get key word
-        keyword = self.keyword(question,history)
+    def ask_with_context(self, question, history):
+        """Pipeline chính: trả về tuple (answer_text, image_url | None)"""
+
+        # 1. Trích xuất keyword
+        keyword = self.keyword(question, history)
         print(f"\n--- keyword: {keyword} ---")
-        print(type(keyword))
-        # rewrite question with key word
-        q_rewrite = self.rewrite_query(question,history)
+
+        # 2. Viết lại câu hỏi
+        q_rewrite = self.rewrite_query(question, history)
         print(f"\n--- q_rewrite: {q_rewrite} ---")
+
+        # 3. Tạo câu trả lời giả định (HyDE)
+        # HyDE chỉ dùng làm keyword PHỤ để mở rộng search — KHÔNG làm query chính
+        # vì embedding của HyDE dài không match với chunk ngắn trong vector DB
         fake_answer = self.generate_hypothetical_answer(q_rewrite)
-        print(f"\n--- fake_answer: {fake_answer} ---")
-        # get top 30 RAG and reranking by question rewrite and keyword then get 5
-        p = advanced_search(fake_answer,keyword) 
-        print(f"\n--- context p: {p} ---")
-        RAG_SYSTEM_PROMPT = """Bạn là một trợ lý AI chuyên trả lời các câu hỏi về văn hóa các dân tộc Việt Nam.
-        NHIỆM VỤ CỐT LÕI: Trả lời câu hỏi của người dùng CHỈ DỰA VÀO thông tin được cung cấp trong phần "Dữ liệu Ngữ cảnh" (Context).
-        
-        Dữ liệu ngữ cảnh bao gồm các nguồn:
-        - [Nguồn Wiki]: Thông tin chi tiết, mô tả sâu.
-        - [TỔNG QUAN]: Thông tin tóm tắt, định danh.
+        print(f"\n--- fake_answer (first 150): {str(fake_answer)[:150]} ---")
+
+        # 4. Tìm kiếm nâng cao
+        # Query chính = q_rewrite (ngắn gọn, khớp embedding DB tốt hơn)
+        # Keywords = keyword (từ LLM extractor) + đầu HyDE (150 ký tự) làm term mở rộng
+        hyde_snippet = (fake_answer or '').strip()[:150]
+        search_keywords = keyword + ([hyde_snippet] if hyde_snippet else [])
+        context, candidate_image_url = advanced_search(q_rewrite, search_keywords)
+        print(f"\n--- context (200 chars): {str(context)[:200]} ---")
+        print(f"\n--- candidate_image_url: {candidate_image_url} ---")
+
+        # 5. Phát hiện intent xem ảnh SỚM (trước khi gọi LLM)
+        wants_image = self.detect_image_intent(question, history)
+        print(f"\n--- image_intent: {'YES' if wants_image else 'NO'} ---")
+        image_url = candidate_image_url if (wants_image and candidate_image_url) else None
 
-        HƯỚNG DẪN XỬ LÝ:
-        1. **Đọc hiểu ngữ cảnh**: Bạn cần đọc kỹ cả thông tin từ [Nguồn Wiki] và [TỔNG QUAN] (nếu có) để có cái nhìn toàn diện.
-        2. **Tổng hợp câu trả lời**:
-           - Kết hợp thông tin từ cả hai nguồn để câu trả lời đầy đủ và chính xác nhất.
-           - Nếu [TỔNG QUAN] cung cấp thông tin cơ bản (tên, địa điểm, thời gian), hãy dùng nó để giới thiệu.
-           - Nếu [Nguồn Wiki] cung cấp chi tiết mô tả, lịch sử, ý nghĩa, hãy dùng nó để giải thích sâu hơn.
-        3. **Xử lý câu hỏi cụ thể**:
-           - Với câu hỏi so sánh: Tìm điểm giống và khác nhau trong ngữ cảnh của các đối tượng.
-           - Với câu hỏi liệt kê: Liệt kê các đối tượng có trong ngữ cảnh phù hợp với câu hỏi.
+        RAG_SYSTEM_PROMPT = """Bạn là một trợ lý AI chuyên trả lời các câu hỏi về văn hóa các dân tộc Việt Nam.
 
-        QUY TẮC BẮT BUỘC:
-        - TUYỆT ĐỐI KHÔNG sử dụng kiến thức bên ngoài ngữ cảnh.
-        - Nếu không có thông tin trong ngữ cảnh, hãy trả lời: "Xin lỗi, tôi không tìm thấy thông tin về vấn đề này trong tài liệu được cung cấp."
-        - Trả lời bằng tiếng Việt có dấu, văn phong lịch sự, rõ ràng.
+        NGUỒN DỮ LIỆU DUY NHẤT: Chỉ được dùng thông tin nằm trong thẻ <context>...</context> bên dưới.
+        TUYỆT ĐỐI KHÔNG dùng kiến thức ngoài context, kể cả khi bạn biết câu trả lời.
+
+        QUY TẮC XỬ LÝ:
+        1. Đọc kỹ toàn bộ <context>.
+        2. Kiểm tra xem context có đề cập đến chủ thể trong câu hỏi không:
+           - NẾU CÓ → tổng hợp từ [TỔNG QUAN] để trả lời đầy đủ, chính xác.
+           - NẾU KHÔNG CÓ hoặc thông tin không liên quan → trả lời ngay: "Xin lỗi, tôi không tìm thấy thông tin về vấn đề này trong tài liệu được cung cấp." — KHÔNG được suy luận hay bổ sung thêm.
+        3. Xử lý câu hỏi cụ thể:
+           - So sánh: tìm điểm gi���ng/khác trong context.
+           - Liệt kê: liệt kê đúng những gì context đề cập.
+        4. Hình ảnh: nếu context có "### Hình ảnh minh họa", nhúng ảnh: ![mô tả](URL). Không đề cập ảnh nếu không có.
+
+        FORMAT MARKDOWN:
+        - **in đậm** cho tên riêng, địa danh, khái niệm quan trọng.
+        - `##` tiêu đề chính, `###` tiêu đề phụ (chỉ khi câu trả lời dài, nhiều phần).
+        - Danh sách `-` khi liệt kê. Câu trả lời ngắn/xã giao: chỉ text thuần, không heading.
+        - TUYỆT ĐỐI KHÔNG đề cập đến việc tìm kiếm ảnh trên internet.
         """
-            
-        # Tạo nội dung user prompt: Ghép context và câu hỏi gốc
-        user_content = f"""### Context:
-    {p}
 
-    ### User Question:
-    {q_rewrite}
-    """
-
-        # pull model
-        # messages = [
-        #         {"role": "system", "content": RAG_SYSTEM_PROMPT},
-        #         {"role": "user", "content": user_content}
-        #     ]
-
-        # # Format prompt theo chuẩn của Qwen
-        # text = self.tokenizer.apply_chat_template(
-        #     messages,
-        #     tokenize=False,
-        #     add_generation_prompt=True
-        # )
-
-        # # Đưa input vào đúng device của model_base
-        # model_inputs = self.tokenizer([text], return_tensors="pt").to(self.model.device)
-
-        # # --- SỬA LỖI TẠI ĐÂY ---
-        # # Dùng model_base (Qwen) thay vì model (SentenceTransformer)
-        # generated_ids = self.model.generate(
-        #     **model_inputs,  # Lưu ý: sửa cả tên biến input cho khớp (model_inputs thay vì model_base1 cho rõ nghĩa)
-        #     max_new_tokens=512,
-        #     temperature=0.1, 
-        #     top_p=0.9
-        # )
-
-        # generated_ids = [
-        #     output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
-        # ]
-
-        # answer_bot = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
-        
+        # 6. Build user_content — wrap context trong thẻ XML để model phân biệt rõ ranh giới
+        image_section = ""
+        if image_url:
+            image_section = f"\n\n### Hình ảnh minh họa\n![]({image_url})\n"
+
+        user_content = f"""<context>
+{context}{image_section}
+</context>
+
+### Câu hỏi:
+{q_rewrite}
+"""
+        print(f"\n--- ---")
+        print(f"\n--- user_content: {str(user_content)} ---")
+        print(f"\n--- ---")
+        # 7. Sinh câu trả lời
         completion = client.chat.completions.create(
             model="meta-llama/llama-4-scout-17b-16e-instruct",
-            messages = [
+            messages=[
                 {"role": "system", "content": RAG_SYSTEM_PROMPT},
                 {"role": "user", "content": user_content}
             ]
         )
         answer_bot = completion.choices[0].message.content.strip()
-        return self.chain_of_thought(q_rewrite,answer_bot)
-        #return completion.choices[0].message.content.strip() 
+        print(f"\n--- ---")
+        print("answer before cot:",answer_bot)
+        print(f"\n--- ---")
+        # 8. Lọc câu trả lời qua CoT
+        
+        final_answer = self.chain_of_thought(q_rewrite, answer_bot)
+        print(f"\n--- ---")
+        print("answer:", answer_bot)
+        print(f"\n--- ---")
+        return final_answer, image_url
+
+