đổi promt

core/embeddings/generator.py

@@ -13,10 +13,17 @@ SYSTEM_PROMPT = """Bạn là Trợ lý học vụ Đại học Bách khoa Hà N
 
 ## NGUYÊN TẮC:
 1. Chỉ trả lời dựa trên CONTEXT được cung cấp. Không suy đoán, không bổ sung thông tin ngoài CONTEXT.
-2. Nếu trong CONTEXT có nội dung về "Hiệu lực thi hành" hoặc "Điều khoản chuyển tiếp", hãy nêu rõ phạm vi áp dụng (theo khóa hoặc thời gian) đúng như nội dung đã nêu. Nếu CONTEXT không đề cập, không tự suy luận.
-3. Nếu CONTEXT chứa nhiều văn bản khác nhau, ưu tiên nội dung được nêu là đang áp dụng, hoặc có ghi rõ thời điểm hiệu lực. Không tự xác định văn bản mới/cũ nếu CONTEXT không nói rõ.
+2. Nếu trong CONTEXT có nội dung về "Hiệu lực thi hành" hoặc "Điều khoản chuyển tiếp", KIỂM TRA xem có ngoại lệ theo khóa/thời gian không và GHI RÕ.
+3. Nếu CONTEXT chứa nhiều văn bản khác nhau, ưu tiên nội dung mới nhất, TRỪ KHI có điều khoản chuyển tiếp nói khác.
 4. Cuối câu trả lời, trích dẫn nguồn đúng theo tài liệu xuất hiện trong CONTEXT. Không tự tạo nguồn.
-5. Nếu không tìm thấy thông tin trong CONTEXT, trả lời: "Không tìm thấy thông tin trong dữ liệu hiện có."
+5. PHÂN BIỆT RÕ các loại CTĐT:
+   - CTĐT CHUẨN: Phụ lục III (Bảng 3.x) - áp dụng cho đa số sinh viên
+   - CTĐT TÀI NĂNG: Phụ lục IV (Bảng 4.x)
+   - CTĐT ELITECH/Tiên tiến: Phụ lục V (Bảng 5.x)
+   - CTĐT HỢP TÁC QUỐC TẾ: Phụ lục VI (Bảng 6.x)
+   - CTĐT NGÔN NGỮ (FL1, FL2, FL3): Phụ lục VIII - KHÔNG ÁP DỤNG cho sinh viên thường
+   Khi người dùng nói "chương trình chuẩn", CHỈ trả lời theo Phụ lục III, KHÔNG lẫn với ngành ngôn ngữ.
+6. Nếu không tìm thấy thông tin trong CONTEXT, trả lời: "Không tìm thấy thông tin trong dữ liệu hiện có."
 """
 
 
@@ -117,3 +124,29 @@ class RAGGenerator:
             if delta:
                 acc += delta
                 yield acc
+
+    def generate_stream_from_results(
+        self, question: str, results: List[Dict[str, Any]]
+    ) -> Generator[str, None, None]:
+        """Stream generation from pre-fetched results (no retrieval)."""
+        if not results:
+            yield "Không tìm thấy thông tin trong dữ liệu hiện có."
+            return
+
+        context = build_context(results, self._max_context_chars)
+        prompt = self._build_prompt(question, context)
+
+        completion = self._groq.chat.completions.create(
+            model=self._llm_model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self._temperature,
+            max_completion_tokens=self._max_tokens,
+            stream=True,
+        )
+
+        acc = ""
+        for chunk in completion:
+            delta = getattr(chunk.choices[0].delta, "content", "") or ""
+            if delta:
+                acc += delta
+                yield acc

core/embeddings/retrival.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 import os
+import time
 import logging
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
+import re
 import requests
 from pydantic import Field
 from langchain_core.documents import Document
@@ -18,6 +21,14 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+class RetrievalMode(str, Enum):
+    """Retrieval modes."""
+    VECTOR_ONLY = "vector_only"
+    BM25_ONLY = "bm25_only"
+    HYBRID = "hybrid"
+    HYBRID_RERANK = "hybrid_rerank"
+
+
 @dataclass
 class RetrievalConfig:
     rerank_api_base_url: str = "https://api.siliconflow.com/v1"
@@ -31,6 +42,7 @@ class RetrievalConfig:
 
 _retrieval_config: RetrievalConfig | None = None
 
+
 def get_retrieval_config() -> RetrievalConfig:
     global _retrieval_config
     if _retrieval_config is None:
@@ -53,144 +65,103 @@ class SiliconFlowReranker(BaseDocumentCompressor):
         query: str,
         callbacks: Optional[Callbacks] = None,
     ) -> Sequence[Document]:
-        if not documents:
-            return []
-        
-        if not self.api_key:
-            logger.warning("No API key, returning documents as-is")
+        if not documents or not self.api_key:
             return list(documents)
         
-        import time
-        max_retries = 3
-        
-        for attempt in range(max_retries):
+        for attempt in range(3):
             try:
-                url = f"{self.api_base_url}/rerank"
-                headers = {
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json",
-                }
-                payload = {
-                    "model": self.model,
-                    "query": query,
-                    "documents": [doc.page_content for doc in documents],
-                    "top_n": self.top_n or len(documents),
-                }
-                
-                response = requests.post(url, headers=headers, json=payload, timeout=30)
+                response = requests.post(
+                    f"{self.api_base_url}/rerank",
+                    headers={
+                        "Authorization": f"Bearer {self.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "model": self.model,
+                        "query": query,
+                        "documents": [doc.page_content for doc in documents],
+                        "top_n": self.top_n or len(documents),
+                    },
+                    timeout=30,
+                )
                 response.raise_for_status()
                 data = response.json()
                 
                 if "results" not in data:
-                    logger.warning("Unexpected rerank response format")
                     return list(documents)
                 
                 reranked: List[Document] = []
                 for result in data["results"]:
-                    idx = result["index"]
-                    score = result["relevance_score"]
-                    
-                    doc = documents[idx]
-                    new_metadata = dict(doc.metadata or {})
-                    new_metadata["rerank_score"] = score
-                    
-                    reranked.append(Document(
-                        page_content=doc.page_content,
-                        metadata=new_metadata
-                    ))
+                    doc = documents[result["index"]]
+                    meta = dict(doc.metadata or {})
+                    meta["rerank_score"] = result["relevance_score"]
+                    reranked.append(Document(page_content=doc.page_content, metadata=meta))
                 
-                logger.debug(f"Reranked {len(reranked)} documents")
                 return reranked
                 
             except Exception as e:
-                if "rate" in str(e).lower() and attempt < max_retries - 1:
-                    wait_time = 2 ** attempt
-                    logger.warning(f"Rate limit hit, waiting {wait_time}s...")
-                    time.sleep(wait_time)
+                if "rate" in str(e).lower() and attempt < 2:
+                    time.sleep(2 ** attempt)
                 else:
                     logger.error(f"Rerank error: {e}")
                     return list(documents)
-
+        
         return list(documents)
 
 
 class Retriever:
-    def __init__(
-        self,
-        vector_db: "ChromaVectorDB",
-        use_reranker: bool = True,
-    ):
+    def __init__(self, vector_db: "ChromaVectorDB", use_reranker: bool = True):
         self._vector_db = vector_db
         self._config = get_retrieval_config()
         self._reranker: Optional[SiliconFlowReranker] = None
         
-        self._vector_retriever = self._init_vector_retriever()
-        self._bm25_retriever = self._init_bm25_retriever()
-        self._ensemble_retriever = self._init_ensemble_retriever()
+        self._vector_retriever = self._vector_db.vectorstore.as_retriever(
+            search_kwargs={"k": self._config.initial_k}
+        )
+        self._bm25_retriever = self._init_bm25()
+        self._ensemble_retriever = self._init_ensemble()
         
         if use_reranker:
             self._reranker = self._init_reranker()
         
-        self._final_retriever = self._build_final_retriever()
-    
-    def _init_vector_retriever(self):
-        return self._vector_db.vectorstore.as_retriever(
-            search_kwargs={"k": self._config.initial_k}
-        )
+        self._final_retriever = self._build_final()
     
-    def _init_bm25_retriever(self) -> Optional[BM25Retriever]:
+    def _init_bm25(self) -> Optional[BM25Retriever]:
         try:
             docs = self._vector_db.get_all_documents()
             if not docs:
-                logger.warning("No documents for BM25 index")
                 return None
             
             lc_docs = [
-                Document(
-                    page_content=d["content"],
-                    metadata=d.get("metadata", {})
-                )
+                Document(page_content=d["content"], metadata=d.get("metadata", {}))
                 for d in docs
             ]
-            
             bm25 = BM25Retriever.from_documents(lc_docs)
             bm25.k = self._config.initial_k
-            logger.info(f"BM25 index built with {len(lc_docs)} documents")
             return bm25
-            
-        except Exception as e:
-            logger.error(f"Failed to build BM25 index: {e}")
+        except Exception:
             return None
     
-    def _init_ensemble_retriever(self) -> EnsembleRetriever:
-        retrievers: List[Any] = [self._vector_retriever]
-        weights: List[float] = [1.0]
-        
+    def _init_ensemble(self) -> EnsembleRetriever:
         if self._bm25_retriever:
-            retrievers.append(self._bm25_retriever)
-            weights = [self._config.vector_weight, self._config.bm25_weight]
-        
-        return EnsembleRetriever(
-            retrievers=retrievers,
-            weights=weights
-        )
+            return EnsembleRetriever(
+                retrievers=[self._vector_retriever, self._bm25_retriever],
+                weights=[self._config.vector_weight, self._config.bm25_weight]
+            )
+        return EnsembleRetriever(retrievers=[self._vector_retriever], weights=[1.0])
     
     def _init_reranker(self) -> Optional[SiliconFlowReranker]:
         api_key = os.getenv("SILICONFLOW_API_KEY", "").strip()
         if not api_key:
-            logger.warning("SILICONFLOW_API_KEY not found. Reranking disabled.")
             return None
-        
-        reranker = SiliconFlowReranker(
+        return SiliconFlowReranker(
             api_key=api_key,
             api_base_url=self._config.rerank_api_base_url,
             model=self._config.rerank_model,
             top_n=self._config.rerank_top_n,
         )
-        logger.info(f"Reranker initialized: {self._config.rerank_model}")
-        return reranker
     
-    def _build_final_retriever(self):
+    def _build_final(self):
         if self._reranker:
             return ContextualCompressionRetriever(
                 base_compressor=self._reranker,
@@ -202,94 +173,165 @@ class Retriever:
     def has_reranker(self) -> bool:
         return self._reranker is not None
     
-    def query(
-        self,
-        text: str,
-        *,
-        k: int | None = None,
-        where: Optional[Dict[str, Any]] = None,
+    def _to_result(self, doc: Document, rank: int, **extra) -> Dict[str, Any]:
+        return {
+            "id": (doc.metadata or {}).get("id"),
+            "content": doc.page_content,
+            "metadata": doc.metadata,
+            "final_rank": rank,
+            **extra,
+        }
+
+    
+    def vector_search(
+        self, text: str, *, k: int | None = None, where: Optional[Dict[str, Any]] = None
     ) -> List[Dict[str, Any]]:
         if not text.strip():
             return []
-        
         k = k or self._config.top_k
-        vectorstore = self._vector_db.vectorstore
-        results = vectorstore.similarity_search_with_score(text, k=k, filter=where)
+        results = self._vector_db.vectorstore.similarity_search_with_score(text, k=k, filter=where)
+        return [self._to_result(doc, i + 1, distance=score) for i, (doc, score) in enumerate(results)]
+    
+    def bm25_search(self, text: str, *, k: int | None = None) -> List[Dict[str, Any]]:
+        if not text.strip():
+            return []
+        if not self._bm25_retriever:
+            return self.vector_search(text, k=k)
         
-        return [
-            {
-                "id": (doc.metadata or {}).get("id"),
-                "content": doc.page_content,
-                "metadata": doc.metadata,
-                "distance": score,
-            }
-            for doc, score in results
-        ]
+        k = k or self._config.top_k
+        self._bm25_retriever.k = k
+        results = self._bm25_retriever.invoke(text)
+        return [self._to_result(doc, i + 1) for i, doc in enumerate(results[:k])]
     
     def hybrid_search(
+        self, text: str, *, k: int | None = None, initial_k: int | None = None
+    ) -> List[Dict[str, Any]]:
+        """Hybrid search (Vector + BM25) WITHOUT reranking."""
+        if not text.strip():
+            return []
+        
+        k = k or self._config.top_k
+        if initial_k:
+            self._vector_retriever.search_kwargs["k"] = initial_k
+            if self._bm25_retriever:
+                self._bm25_retriever.k = initial_k
+        
+        # Dùng ensemble_retriever (KHÔNG có reranker) thay vì final_retriever
+        results = self._ensemble_retriever.invoke(text)
+        return [self._to_result(doc, i + 1) for i, doc in enumerate(results[:k])]
+    
+    def search_with_rerank(
         self,
         text: str,
         *,
         k: int | None = None,
+        where: Optional[Dict[str, Any]] = None,
         initial_k: int | None = None,
     ) -> List[Dict[str, Any]]:
+        """Hybrid search (Vector + BM25) WITH reranking."""
         if not text.strip():
             return []
         
         k = k or self._config.top_k
+        initial_k = initial_k or self._config.initial_k
+        
+        # Có filter -> dùng vector search + manual rerank
+        if where:
+            results = self._vector_db.vectorstore.similarity_search(text, k=initial_k, filter=where)
+            if self._reranker:
+                results = self._reranker.compress_documents(results, text)
+            return [
+                self._to_result(doc, i + 1, rerank_score=doc.metadata.get("rerank_score"))
+                for i, doc in enumerate(results[:k])
+            ]
         
+        # _final_retriever (ensemble + reranker)
         if initial_k:
             self._vector_retriever.search_kwargs["k"] = initial_k
             if self._bm25_retriever:
                 self._bm25_retriever.k = initial_k
         
         results = self._final_retriever.invoke(text)
-        
-        out: List[Dict[str, Any]] = []
-        for i, doc in enumerate(results[:k]):
-            out.append({
-                "id": (doc.metadata or {}).get("id"),
-                "content": doc.page_content,
-                "metadata": doc.metadata,
-                "rerank_score": doc.metadata.get("rerank_score"),
-                "final_rank": i + 1,
-            })
-        
-        return out
+        return [
+            self._to_result(doc, i + 1, rerank_score=doc.metadata.get("rerank_score"))
+            for i, doc in enumerate(results[:k])
+        ]
     
-    def search_with_rerank(
+    def flexible_search(
         self,
         text: str,
         *,
+        mode: RetrievalMode | str = RetrievalMode.HYBRID_RERANK,
         k: int | None = None,
-        where: Optional[Dict[str, Any]] = None,
         initial_k: int | None = None,
+        where: Optional[Dict[str, Any]] = None,
+        auto_detect_cohort: bool = False,
     ) -> List[Dict[str, Any]]:
         if not text.strip():
             return []
         
+        if isinstance(mode, str):
+            try:
+                mode = RetrievalMode(mode.lower())
+            except ValueError:
+                mode = RetrievalMode.HYBRID_RERANK
+        
         k = k or self._config.top_k
         initial_k = initial_k or self._config.initial_k
         
-        # If filter is provided, use vector-only search (BM25 doesn't support filters)
-        if where:
-            vectorstore = self._vector_db.vectorstore
-            results = vectorstore.similarity_search(text, k=initial_k, filter=where)
-            
-            # Apply reranker if available
-            if self._reranker:
-                results = self._reranker.compress_documents(results, text)
-            
-            out: List[Dict[str, Any]] = []
-            for i, doc in enumerate(results[:k]):
-                out.append({
-                    "id": (doc.metadata or {}).get("id"),
-                    "content": doc.page_content,
-                    "metadata": doc.metadata,
-                    "rerank_score": doc.metadata.get("rerank_score"),
-                    "final_rank": i + 1,
-                })
-            return out
+        # Auto-detect cohort và tạo filter nếu enabled
+        if auto_detect_cohort and where is None:
+            where = auto_filter_by_cohort(text)
         
-        # No filter - use hybrid search
-        return self.hybrid_search(text, k=k, initial_k=initial_k)
+        if mode == RetrievalMode.VECTOR_ONLY:
+            return self.vector_search(text, k=k, where=where)
+        elif mode == RetrievalMode.BM25_ONLY:
+            return self.bm25_search(text, k=k)
+        elif mode == RetrievalMode.HYBRID:
+            if where:
+                return self.vector_search(text, k=k, where=where)
+            return self.hybrid_search(text, k=k, initial_k=initial_k)
+        else:  # HYBRID_RERANK
+            return self.search_with_rerank(text, k=k, where=where, initial_k=initial_k)
+
+    # Legacy alias
+    query = vector_search
+
+NGOAI_NGU_KEYWORDS = ["tiếng anh", "toeic", "ielts", "ngoại ngữ", "english", "chuẩn đầu ra"]
+
+
+def detect_cohort(text: str) -> Optional[str]:
+    patterns = [
+        r'\bK(\d{2})\b',
+        r'\bkhóa\s*(\d{2})\b',
+        r'\bkhoá\s*(\d{2})\b',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            return f"K{match.group(1)}"
+    return None
+
+
+def cohort_to_filter(cohort: str) -> Optional[Dict[str, Any]]:
+    if not cohort:
+        return None
+    try:
+        num = int(cohort.replace("K", "").replace("k", ""))
+    except ValueError:
+        return None
+    
+    if num >= 70:
+        return {"applicable_cohorts": ">=K70"}
+    elif num >= 68:
+        return {"applicable_cohorts": ">=K68"}
+    elif num >= 65:
+        return {"applicable_cohorts": ">=K65"}
+    return None
+
+
+def auto_filter_by_cohort(text: str) -> Optional[Dict[str, Any]]:
+    cohort = detect_cohort(text)
+    if cohort and any(kw in text.lower() for kw in NGOAI_NGU_KEYWORDS):
+        return cohort_to_filter(cohort)
+    return None

core/embeddings/vector_store.py

@@ -58,22 +58,45 @@ class ChromaVectorDB:
             else:
                 out[str(k)] = str(v)
         return out
+    
+    def _normalize_doc(self, doc: Any) -> Dict[str, Any]:
+        # Nếu đã là dict
+        if isinstance(doc, dict):
+            return doc
+        
+        # Nếu là TextNode/BaseNode từ llama_index
+        if hasattr(doc, "get_content") and hasattr(doc, "metadata"):
+            return {
+                "content": doc.get_content(),
+                "metadata": dict(doc.metadata) if doc.metadata else {},
+            }
+        
+        # Nếu là Document từ langchain
+        if hasattr(doc, "page_content") and hasattr(doc, "metadata"):
+            return {
+                "content": doc.page_content,
+                "metadata": dict(doc.metadata) if doc.metadata else {},
+            }
+        
+        raise TypeError(f"Unsupported document type: {type(doc)}")
 
-    def _to_documents(self, docs: Sequence[Dict[str, Any]], ids: Sequence[str]) -> List[Document]:
+    def _to_documents(self, docs: Sequence[Any], ids: Sequence[str]) -> List[Document]:
         out: List[Document] = []
         for d, doc_id in zip(docs, ids):
-            md = self._flatten_metadata(d.get("metadata", {}) or {})
+            normalized = self._normalize_doc(d)
+            md = self._flatten_metadata(normalized.get("metadata", {}) or {})
             md.setdefault("id", doc_id)
-            out.append(Document(page_content=d.get("content", ""), metadata=md))
+            out.append(Document(page_content=normalized.get("content", ""), metadata=md))
         return out
 
-    def _doc_id(self, doc: Dict[str, Any]) -> str:
-        md = doc.get("metadata") or {}
+    def _doc_id(self, doc: Any) -> str:
+        normalized = self._normalize_doc(doc)
+        md = normalized.get("metadata") or {}
         key = {
             "source_file": md.get("source_file"),
             "header_path": md.get("header_path"),
             "chunk_index": md.get("chunk_index"),
-            "content": doc.get("content"),
+            "content": normalized.get("content"),
         }
         return self._hasher.get_string_hash(str(key))
 

core/gradio/gradio_rag_qwen.py

@@ -29,10 +29,14 @@ def _load_env() -> None:
 
 from core.embeddings.embedding_model import EmbeddingConfig, QwenEmbeddings
 from core.embeddings.vector_store import ChromaConfig, ChromaVectorDB
-from core.embeddings.retrival import Retriever, get_retrieval_config
+from core.embeddings.retrival import Retriever, RetrievalMode, get_retrieval_config
+from core.embeddings.generator import RAGGenerator
 
 _load_env()
 
+RETRIEVAL_MODE = RetrievalMode.HYBRID_RERANK 
+
+
 # Load all configs
 GRADIO_CFG = GradioConfig(
     llm_model="qwen/qwen3-32b",
@@ -48,6 +52,7 @@ class AppState:
     def __init__(self) -> None:
         self.db: Optional[ChromaVectorDB] = None
         self.retriever: Optional[Retriever] = None
+        self.generator: Optional[RAGGenerator] = None
         self.groq: Optional[Groq] = None
 
 
@@ -58,7 +63,8 @@ def _init_resources() -> None:
     if STATE.db is not None:
         return
 
-    print(" Đang khởi tạo Database & Re-ranker...")
+    print(f" Đang khởi tạo Database & Re-ranker...")
+    print(f" Retrieval Mode: {RETRIEVAL_MODE.value}")
 
     emb = QwenEmbeddings(EmbeddingConfig())
 
@@ -75,6 +81,15 @@ def _init_resources() -> None:
         raise RuntimeError("Missing GROQ_API_KEY")
     STATE.groq = Groq(api_key=api_key)
     
+    # Initialize RAGGenerator with shared retriever and groq client
+    STATE.generator = RAGGenerator(
+        retriever=STATE.retriever,
+        llm_model=GRADIO_CFG.llm_model,
+        temperature=GRADIO_CFG.llm_temperature,
+        max_tokens=GRADIO_CFG.llm_max_tokens,
+        groq_client=STATE.groq,
+    )
+    
     print(" Đã sẵn sàng!")
 
 
@@ -83,92 +98,48 @@ def rag_chat(message: str, history: List[Dict[str, str]] | None = None):
 
     assert STATE.db is not None
     assert STATE.groq is not None
-
-    # Vector Search + Re-ranking (use config values)
     assert STATE.retriever is not None
-    results = STATE.retriever.search_with_rerank(
-        message, 
+    assert STATE.generator is not None
+
+    # Flexible search với auto_detect_cohort để tự động filter theo khóa
+    results = STATE.retriever.flexible_search(
+        message,
+        mode=RETRIEVAL_MODE,
         k=RETRIEVAL_CFG.top_k, 
-        initial_k=RETRIEVAL_CFG.initial_k
+        initial_k=RETRIEVAL_CFG.initial_k,
+        auto_detect_cohort=True,
     )
 
     if not results:
         yield "Xin lỗi, tôi không tìm thấy thông tin phù hợp trong dữ liệu."
         return
 
-    # Build context from results
-    structured_context = ""
-    for i, r in enumerate(results, 1):
-        md = r.get("metadata", {})
-        program = md.get("program_name", "")
-        doc_type = md.get("type", md.get("document_type", ""))
-        section = md.get("section", "")
-        source = md.get("source_file", "")
-        content = r.get("content", "").strip()
-        is_injected = r.get("_injected", False)
-        
-        if is_injected or "hiệu lực" in section.lower() or "chuyển tiếp" in section.lower():
-            display_content = content
-        else:
-            display_content = content[:600]
-
-        structured_context += f"""
----
-[TÀI LIỆU {i}]{' [ĐIỀU KHOẢN HIỆU LỰC]' if is_injected else ''}
-- Phần/Điều: {section if section else 'N/A'}
-- Nguồn: {source if source else 'N/A'}
-{display_content}
-"""
-
-    max_context_chars = 5000
-    if len(structured_context) > max_context_chars:
-        structured_context = structured_context[:max_context_chars] + "\n\n[...truncated...]"
-
-    prompt = f"""Bạn là Trợ lý học vụ ĐHBK Hà Nội.
-
-## NGUYÊN TẮC:
-1. Chỉ trả lời dựa trên CONTEXT. Không bịa thông tin.
-2. Nếu thấy "Hiệu lực thi hành" hoặc "Điều khoản chuyển tiếp", KIỂM TRA xem có ngoại lệ theo khóa/thời gian không và GHI RÕ.
-3. Ưu tiên văn bản mới nhất, TRỪ KHI có điều khoản chuyển tiếp nói khác.
-4. Trích nguồn cuối câu trả lời.
-
-## CONTEXT:
-{structured_context}
-
-## CÂU HỎI: {message}
-
-## TRẢ LỜI:"""
-
-    completion = STATE.groq.chat.completions.create(
-        model=GRADIO_CFG.llm_model,
-        messages=[{"role": "user", "content": prompt}],
-        temperature=GRADIO_CFG.llm_temperature,
-        max_completion_tokens=GRADIO_CFG.llm_max_tokens,
-        stream=True,
-    )
-
+    # Use RAGGenerator for streaming response
     acc = ""
-    for chunk in completion:
-        try:
-            delta = chunk.choices[0].delta.content or ""
-        except Exception:
-            delta = ""
-        if not delta:
-            continue
-        acc += delta
+    for partial in STATE.generator.generate_stream_from_results(message, results):
+        acc = partial
         yield acc
 
-    # Debug info
-    debug_info = f"\n\n---\n\n**Retrieved (Top {len(results)} | Vector + Re-rank)**\n\n"
+    # Debug info with mode indicator
+    debug_info = f"\n\n---\n\n**Retrieved (Top {len(results)} | Mode: {RETRIEVAL_MODE.value})**\n\n"
     for i, r in enumerate(results, 1):
         md = r.get("metadata", {})
         content = r.get("content", "").strip()
-        rerank_score = r.get("rerank_score", 0)
-        vector_dist = r.get("vector_distance", 999.0)
+        rerank_score = r.get("rerank_score")
+        distance = r.get("distance")
         section = md.get("section", "N/A")
         doc_type = md.get("type", md.get("document_type", "N/A"))
 
-        debug_info += f"**#{i}** | Rerank: `{rerank_score:.4f}` | VecDist: `{vector_dist:.3f}`\n"
+        # Show relevant scores based on mode
+        score_info = ""
+        if rerank_score is not None:
+            score_info += f"Rerank: `{rerank_score:.4f}` "
+        if distance is not None:
+            score_info += f"Distance: `{distance:.4f}`"
+        if not score_info:
+            score_info = f"Rank: `{r.get('final_rank', i)}`"
+
+        debug_info += f"**#{i}** | {score_info}\n"
         debug_info += f"   - **Type:** {doc_type} | **Section:** {section[:60]}{'...' if len(section) > 60 else ''}\n"
         debug_info += f"   - **Content:** {content[:200]}{'...' if len(content) > 200 else ''}\n\n"
 
@@ -178,8 +149,8 @@ def rag_chat(message: str, history: List[Dict[str, str]] | None = None):
 # Create Gradio interface
 demo = gr.ChatInterface(
     fn=rag_chat,
-    title="HUST RAG Assistant",
-    description="Trợ lý học vụ Đại học Bách khoa Hà Nội",
+    title=f"HUST RAG Assistant",
+    description=f"Trợ lý học vụ Đại học Bách khoa Hà Nội",
     examples=[
         "Điều kiện tốt nghiệp đại học là gì?",
         "Yêu cầu TOEIC của ngành Toán tin là bao nhiêu?",
@@ -188,6 +159,9 @@ demo = gr.ChatInterface(
 )
 
 if __name__ == "__main__":
+    print(f"\n{'='*60}")
+    print(f"Starting HUST RAG Assistant")
+    print(f"{'='*60}\n")
     demo.launch(
         server_name=GRADIO_CFG.server_host, 
         server_port=GRADIO_CFG.server_port

scripts/rag.py

@@ -33,7 +33,7 @@ def main():
     args = parser.parse_args()
     
     print("=" * 60)
-    print("REBUILD HUST RAG DATABASE")
+    print("BUILD HUST RAG DATABASE")
     print("=" * 60)
     
     print("\n[1/4] Initializing embedder...")
@@ -93,18 +93,24 @@ def main():
     print("TESTING QUERY")
     print("=" * 60)
     
-    from core.embeddings.retrival import Retriever
+    from core.embeddings.retrival import Retriever, RetrievalMode
+    
+    # Test với mode VECTOR_ONLY
+    test_mode = RetrievalMode.VECTOR_ONLY
     retriever = Retriever(vector_db=db, use_reranker=False)
     
     test_query = "Yêu cầu TOEIC của ngành Toán tin là bao nhiêu?"
     print(f"Query: {test_query}")
-    results = retriever.query(test_query, k=3)
+    print(f"Mode: {test_mode.value}")
+    
+    results = retriever.flexible_search(test_query, mode=test_mode, k=3)
     
     if results:
         print(f"\nTop {len(results)} results:")
         for i, r in enumerate(results, 1):
-            print(f"\n[{i}] Distance: {r['distance']:.4f}")
-            print(f"  Program: {r['metadata'].get('program_name', 'N/A')}")
+            score = r.get('distance') or r.get('rerank_score') or r.get('final_rank')
+            print(f"\n[{i}] Score: {score}")
+            print(f"  Source: {r['metadata'].get('source_file', 'N/A')}")
             print(f"  Section: {r['metadata'].get('section', 'N/A')}")
             print(f"  Content: {r['content'][:150]}...")
     else:

test/test_chunk.py

@@ -3,7 +3,7 @@ sys.path.insert(0, "/home/bahung/DoAn")
 
 from core.embeddings.chunk import chunk_markdown_file
 
-test_file = "data/data_process/chuong_trinh_dao_tao/1.1. Kỹ thuật Cơ điện tử.md"
+test_file = "data/data_process/quyet_dinh/tieng_anh/06_ Quy định ngoại ngữ từ K70_chính quy_final.md"
 
 print("=" * 70)
 print(f" File: {test_file}")