fix chunking

config/docling.yaml

@@ -1,9 +0,0 @@
-output_dir: data/docling_output
-use_ocr: false
-timeout: 300
-
-# PDF pipeline options
-pdf_pipeline:
-	do_table_structure: true
-	do_picture_classification: false
-	do_picture_description: false

config/embedding.yaml

@@ -1,9 +0,0 @@
-# SiliconFlow Embedding Configuration
-api_base_url: https://api.siliconflow.com/v1
-
-# Embedding Model (Qwen3-Embedding-4B)
-# Rate limit L0: 2000 RPM, 1M TPM
-embedding:
-  model_name: Qwen/Qwen3-Embedding-4B
-  dimension: 2048
-  batch_size: 16    # Giảm từ 32 → 16 để tránh rate limit

config/evaluation.yaml

@@ -1,22 +0,0 @@
-# Evaluation Configuration
-
-# LLM model for generating answers and scoring metrics
-llm:
-  model: qwen/qwen3-32b
-  temperature: 0
-  timeout: 30
-  max_retries: 2
-
-# Retrieval settings
-retrieval:
-  top_k: 5
-  initial_k: 100
-
-# Test data
-data:
-  csv_path: data/data.csv
-  sample_size: 0  # 0 = all samples
-
-# Output
-output:
-  dir: evaluation/results

config/gradio.yaml

@@ -1,12 +0,0 @@
-# Gradio App Configuration
-
-# LLM settings (Groq API)
-llm:
-  model: llama-3.1-8b-instant
-  temperature: 0.0
-  max_tokens: 4096
-
-# Server settings
-server:
-  host: "0.0.0.0"
-  port: 7860

config/retrieval.yaml

@@ -1,15 +0,0 @@
-# Retrieval Configuration
-
-# Reranker (SiliconFlow Qwen3-Reranker-4B)
-# Rate limit L0: 2000 RPM, 1M TPM
-reranker:
-  api_base_url: https://api.siliconflow.com/v1
-  model_name: Qwen/Qwen3-Reranker-4B
-  top_n: 5
-
-# Hybrid Search Settings
-hybrid:
-  initial_k: 50           
-  top_k: 5                # Số docs cuối cùng trả về
-  vector_weight: 0.5      # Trọng số cho vector search
-  bm25_weight: 0.5        # Trọng số cho BM25

config/vector_db.yaml

@@ -1,2 +0,0 @@
-persist_dir: data/chroma
-collection_name: hust_rag_collection

core/embeddings/chunk.py

@@ -3,148 +3,498 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Tuple
+from typing import List, Tuple
 
-import frontmatter
-from langchain_text_splitters import RecursiveCharacterTextSplitter
+from dotenv import load_dotenv
+from llama_index.core import Document
+from llama_index.core.node_parser import MarkdownNodeParser, SentenceSplitter
+from llama_index.core.schema import BaseNode, TextNode
+
+# Load environment variables
+load_dotenv()
+
+# Regex pattern for extracting course information
+COURSE_INFO_PATTERN = re.compile(
+    r"Học\s*phần\s+(.+?)\s*\(\s*m[ãa]\s+([^\)]+)\)",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+# Chunking configuration
+CHUNK_SIZE = 1500
+CHUNK_OVERLAP = 150
+MIN_CHUNK_SIZE = 50
+TABLE_ROWS_PER_CHUNK = 15  # Max rows per table chunk (excluding header)
 
 
 @dataclass
-class ChunkConfig:
-    max_chars: int = 1300
-    overlap: int = 250
-    min_chars: int = 100
+class TableBlock:
+    """Represents a markdown table with its position in text."""
+    start_idx: int
+    end_idx: int
+    header_lines: str  # First 2 lines: header + separator
+    data_rows: List[str]  # All data rows
+    
+    @property
+    def full_table(self) -> str:
+        return self.header_lines + "\n".join(self.data_rows)
+    
+    def get_chunks(self, max_rows: int = TABLE_ROWS_PER_CHUNK) -> List[str]:
+        """Split table into chunks, each containing header + subset of rows."""
+        if len(self.data_rows) <= max_rows:
+            return [self.full_table]
+        
+        chunks = []
+        for i in range(0, len(self.data_rows), max_rows):
+            rows_subset = self.data_rows[i:i + max_rows]
+            chunk = self.header_lines + "\n".join(rows_subset)
+            chunks.append(chunk)
+        return chunks
+
 
+def _is_table_row(line: str) -> bool:
+    """Check if a line is a markdown table row."""
+    stripped = line.strip()
+    return stripped.startswith("|") and stripped.endswith("|") and stripped.count("|") >= 2
 
-def _extract_sections(body: str) -> List[Tuple[str, str, List[str]]]:
-    heading_re = re.compile(r"^(#+)\s+(.+?)\s*$", re.MULTILINE)
+
+def _is_separator_row(line: str) -> bool:
+    """Check if a line is a table separator (|---|---|)."""
+    stripped = line.strip()
+    if not _is_table_row(line):
+        return False
+    # Remove pipes and check if remaining is mostly dashes/colons
+    content = stripped.replace("|", "").replace("-", "").replace(":", "").replace(" ", "")
+    return len(content) == 0
+
+
+def _is_real_header_row(line: str) -> bool:
+    """
+    Check if a table row is a real header (contains text labels) vs data row (contains numbers).
+    Real headers typically have column names like 'TT', 'MÃ SỐ', 'TÊN', etc.
+    Data rows typically start with numbers like '1', '26', '64'.
+    """
+    stripped = line.strip()
+    if not _is_table_row(line):
+        return False
     
-    headings = [(m.start(), len(m.group(1)), m.group(2).strip()) for m in heading_re.finditer(body)]
+    # Get first cell content
+    cells = [c.strip() for c in stripped.split("|") if c.strip()]
+    if not cells:
+        return False
     
-    if not headings:
-        return [("General", body.strip(), [])]
+    first_cell = cells[0]
     
-    sections = []
-    stack: List[Tuple[int, str]] = []
+    # If first cell is purely numeric, it's likely a data row
+    if first_cell.isdigit():
+        return False
     
-    for i, (pos, level, title) in enumerate(headings):
-        start = pos
-        end = headings[i + 1][0] if i + 1 < len(headings) else len(body)
-        
-        heading_line_end = body.find("\n", pos)
-        if heading_line_end == -1:
-            heading_line_end = len(body)
-        content = body[heading_line_end:end].strip()
-        
-        while stack and stack[-1][0] >= level:
-            stack.pop()
-        
-        breadcrumbs = [s[1] for s in stack]
-        stack.append((level, title))
-        
-        sections.append((title, content, breadcrumbs))
+    # If first cell contains common header keywords, it's a header
+    header_keywords = ['TT', 'STT', 'MÃ', 'TÊN', 'KHỐI', 'SỐ', 'ID', 'NO', '#']
+    first_cell_upper = first_cell.upper()
+    for keyword in header_keywords:
+        if keyword in first_cell_upper:
+            return True
     
-    return sections
+    # If first cell is short text (1-3 words) and not a number, likely header
+    if len(first_cell.split()) <= 3 and not any(c.isdigit() for c in first_cell[:2]):
+        return True
+    
+    return False
 
 
-def chunk_markdown(
-    md_text: str,
-    *,
-    source_path: str | Path | None = None,
-    config: ChunkConfig | None = None,
-) -> List[Dict[str, Any]]:
+def _extract_tables(text: str) -> Tuple[List[TableBlock], str]:
+    """
+    Extract all markdown tables from text.
+    Tables without proper headers inherit header from previous table.
+    Returns: (list of TableBlock, text with tables replaced by placeholders)
+    """
+    lines = text.split("\n")
+    tables: List[TableBlock] = []
+    last_valid_header: str | None = None
     
-    cfg = config or ChunkConfig()
+    i = 0
+    while i < len(lines):
+        # Look for table: either header+separator or data+separator pattern
+        if i + 1 < len(lines) and _is_table_row(lines[i]) and _is_separator_row(lines[i + 1]):
+            table_start_line = i
+            potential_header = lines[i]
+            separator_row = lines[i + 1]
+            
+            # Check if this is a real header or a data row
+            if _is_real_header_row(potential_header):
+                # This is a proper header
+                header_lines = potential_header + "\n" + separator_row + "\n"
+                last_valid_header = header_lines
+                data_start = i + 2
+            else:
+                # This row looks like data, not header
+                # Use last valid header if available, otherwise create generic one
+                if last_valid_header:
+                    header_lines = last_valid_header
+                else:
+                    # Create a generic header based on column count
+                    col_count = potential_header.count("|") - 1
+                    generic_header = "| " + " | ".join([f"Col{j+1}" for j in range(col_count)]) + " |"
+                    generic_sep = "| " + " | ".join(["---"] * col_count) + " |"
+                    header_lines = generic_header + "\n" + generic_sep + "\n"
+                
+                # Include the "header" row as first data row since it's actually data
+                data_start = i
+            
+            # Collect all data rows (including separator if we started from data row)
+            data_rows = []
+            j = data_start
+            while j < len(lines):
+                if _is_table_row(lines[j]) and not _is_separator_row(lines[j]):
+                    data_rows.append(lines[j])
+                    j += 1
+                elif _is_separator_row(lines[j]):
+                    # Skip separator rows in the middle of table
+                    j += 1
+                else:
+                    break
+            
+            if data_rows:  # Valid table with at least one data row
+                # Calculate character positions
+                start_idx = sum(len(lines[k]) + 1 for k in range(table_start_line))
+                end_idx = sum(len(lines[k]) + 1 for k in range(j))
+                
+                tables.append(TableBlock(
+                    start_idx=start_idx,
+                    end_idx=end_idx,
+                    header_lines=header_lines,
+                    data_rows=data_rows,
+                ))
+                i = j
+            else:
+                i += 1
+        else:
+            i += 1
     
-    # Parse frontmatter
-    post = frontmatter.loads(md_text or "")
-    base_meta = dict(post.metadata or {})
-    body = post.content or ""
+    # Create text with placeholders
+    if not tables:
+        return tables, text
     
-    # Add source info
+    result_lines = []
+    table_idx = 0
+    i = 0
+    
+    while i < len(lines):
+        if table_idx < len(tables):
+            # Check if we're at a table start (header+sep or data+sep)
+            if i + 1 < len(lines) and _is_table_row(lines[i]) and _is_separator_row(lines[i + 1]):
+                # Skip all table rows (including separators in the middle)
+                j = i
+                while j < len(lines):
+                    if _is_table_row(lines[j]) or _is_separator_row(lines[j]):
+                        j += 1
+                    else:
+                        break
+                
+                # Add placeholder
+                result_lines.append(f"__TABLE_PLACEHOLDER_{table_idx}__")
+                table_idx += 1
+                i = j
+                continue
+        
+        result_lines.append(lines[i])
+        i += 1
+    
+    return tables, "\n".join(result_lines)
+
+
+def _get_markdown_parser() -> MarkdownNodeParser:
+    return MarkdownNodeParser()
+
+
+def _get_sentence_splitter() -> SentenceSplitter:
+    return SentenceSplitter(
+        chunk_size=CHUNK_SIZE,
+        chunk_overlap=CHUNK_OVERLAP,
+    )
+
+
+def _extract_course_metadata(text: str) -> dict[str, str]:
+    """Extract course name and code from Vietnamese text."""
+    metadata: dict[str, str] = {}
+    
+    if "Học phần" in text:
+        match = COURSE_INFO_PATTERN.search(text)
+        if match:
+            metadata["course_name"] = " ".join(match.group(1).split())
+            metadata["course_code"] = " ".join(match.group(2).split())
+    
+    return metadata
+
+
+def _enrich_node_metadata(
+    node: BaseNode,
+    source_path: str | Path | None = None,
+) -> None:
+    """Add source and course metadata to node."""
     if source_path:
         p = Path(source_path)
-        base_meta.setdefault("source_path", str(p))
-        base_meta.setdefault("source_file", base_meta.get("source_file") or p.name)
-        base_meta.setdefault("source_basename", p.name)
-    
-    doc_type = str(base_meta.get("document_type") or "").strip()
-    if doc_type:
-        base_meta.setdefault("type", doc_type)
-    
-    text_splitter = RecursiveCharacterTextSplitter(
-        chunk_size=cfg.max_chars,
-        chunk_overlap=cfg.overlap,
-        separators=["\n\n", "\n", ". ", "; ", ", ", " ", ""],
-        length_function=len,
-    )
+        node.metadata["source_path"] = str(p)
+        node.metadata["source_file"] = p.name
     
-    sections = _extract_sections(body)
-    raw_chunks: List[Dict[str, Any]] = []
+    text = node.get_content()
+    course_meta = _extract_course_metadata(text)
+    node.metadata.update(course_meta)
+
+
+def _has_markdown_table(text: str) -> bool:
+    """Check if text contains a markdown table."""
+    lines = text.split("\n")
+    for i in range(len(lines) - 1):
+        if _is_table_row(lines[i]) and _is_separator_row(lines[i + 1]):
+            return True
+    return False
+
+
+def _merge_small_nodes(nodes: List[BaseNode]) -> List[BaseNode]:
+    """Merge nodes smaller than MIN_CHUNK_SIZE with next node."""
+    if not nodes:
+        return []
     
-    for title, content, breadcrumbs in sections:
-        section_title = " > ".join(breadcrumbs + [title]) if breadcrumbs else title
+    merged_nodes: List[BaseNode] = []
+    i = 0
+    
+    while i < len(nodes):
+        current = nodes[i]
+        current_content = current.get_content()
+        current_len = len(current_content)
         
-        if len(content) > cfg.max_chars:
-            sub_texts = text_splitter.split_text(content)
+        if current_len < MIN_CHUNK_SIZE and i + 1 < len(nodes):
+            next_node = nodes[i + 1]
+            next_content = next_node.get_content()
+            merged_content = current_content + "\n\n" + next_content
+            merged_metadata = current.metadata.copy()
+            merged_metadata.update(next_node.metadata)
+            
+            merged_node = TextNode(
+                text=merged_content,
+                metadata=merged_metadata,
+            )
+            merged_nodes.append(merged_node)
+            i += 2
         else:
-            sub_texts = [content] if content else []
+            merged_nodes.append(current)
+            i += 1
+    
+    return merged_nodes
+
+
+def _chunk_text_section(text: str, metadata: dict) -> List[BaseNode]:
+    """Chunk a text section (no tables) using SentenceSplitter."""
+    if len(text) <= CHUNK_SIZE:
+        return [TextNode(text=text, metadata=metadata.copy())]
+    
+    splitter = _get_sentence_splitter()
+    doc = Document(text=text, metadata=metadata.copy())
+    nodes = splitter.get_nodes_from_documents([doc])
+    return nodes
+
+
+def _chunk_with_table_awareness(
+    doc: Document,
+    source_path: str | Path | None = None,
+) -> List[BaseNode]:
+    """
+    Chunk markdown with table boundary awareness.
+    
+    Strategy:
+    1. Extract all tables from document
+    2. Split remaining text by markdown headings
+    3. Further split large text sections with SentenceSplitter
+    4. Split large tables by rows (keeping header in each chunk)
+    5. Reassemble in original order
+    """
+    text = doc.get_content()
+    base_metadata = doc.metadata.copy()
+    
+    # Step 1: Extract tables
+    tables, text_with_placeholders = _extract_tables(text)
+    
+    if not tables:
+        # No tables - use simple chunking
+        return _chunk_simple(doc, source_path)
+    
+    # Step 2: Split text by markdown headings
+    md_parser = _get_markdown_parser()
+    placeholder_doc = Document(text=text_with_placeholders, metadata=base_metadata.copy())
+    heading_nodes = md_parser.get_nodes_from_documents([placeholder_doc])
+    
+    # Step 3: Process each heading node
+    all_nodes: List[BaseNode] = []
+    
+    for node in heading_nodes:
+        node_text = node.get_content()
+        node_metadata = node.metadata.copy()
         
-        for text in sub_texts:
-            text = text.strip()
-            if not text:
-                continue
-                
-            md = dict(base_meta)
-            md["section"] = section_title
+        # Check if this node contains table placeholders
+        placeholder_pattern = re.compile(r"__TABLE_PLACEHOLDER_(\d+)__")
+        matches = list(placeholder_pattern.finditer(node_text))
+        
+        if not matches:
+            # No tables in this node - chunk normally
+            if len(node_text) > CHUNK_SIZE:
+                sub_nodes = _chunk_text_section(node_text, node_metadata)
+                all_nodes.extend(sub_nodes)
+            else:
+                all_nodes.append(TextNode(text=node_text, metadata=node_metadata))
+        else:
+            # Has tables - split around placeholders
+            last_end = 0
             
-            if "Học phần" in text:
-                match = re.search(
-                    r"Học\s*phần\s+(.+?)\s*\(\s*m[ãa]\s+([^\)]+)\)",
-                    text, flags=re.IGNORECASE | re.DOTALL,
-                )
-                if match:
-                    md["course_name"] = " ".join(match.group(1).split())
-                    md["course_code"] = " ".join(match.group(2).split())
+            for match in matches:
+                # Text before placeholder
+                text_before = node_text[last_end:match.start()].strip()
+                if text_before:
+                    if len(text_before) > CHUNK_SIZE:
+                        sub_nodes = _chunk_text_section(text_before, node_metadata)
+                        all_nodes.extend(sub_nodes)
+                    elif len(text_before) >= MIN_CHUNK_SIZE:
+                        all_nodes.append(TextNode(text=text_before, metadata=node_metadata.copy()))
+                
+                # Table chunks
+                table_idx = int(match.group(1))
+                if table_idx < len(tables):
+                    table = tables[table_idx]
+                    table_chunks = table.get_chunks(TABLE_ROWS_PER_CHUNK)
+                    
+                    for i, chunk in enumerate(table_chunks):
+                        table_metadata = node_metadata.copy()
+                        table_metadata["is_table"] = True
+                        if len(table_chunks) > 1:
+                            table_metadata["table_part"] = f"{i + 1}/{len(table_chunks)}"
+                        all_nodes.append(TextNode(text=chunk, metadata=table_metadata))
+                
+                last_end = match.end()
             
-            raw_chunks.append({"content": text, "metadata": md})
+            # Text after last placeholder
+            text_after = node_text[last_end:].strip()
+            if text_after:
+                if len(text_after) > CHUNK_SIZE:
+                    sub_nodes = _chunk_text_section(text_after, node_metadata)
+                    all_nodes.extend(sub_nodes)
+                elif len(text_after) >= MIN_CHUNK_SIZE:
+                    all_nodes.append(TextNode(text=text_after, metadata=node_metadata.copy()))
     
-    chunks: List[Dict[str, Any]] = []
+    # Step 4: Merge small nodes (but not tables)
+    final_nodes: List[BaseNode] = []
     i = 0
-    while i < len(raw_chunks):
-        current = raw_chunks[i]
+    while i < len(all_nodes):
+        current = all_nodes[i]
+        is_table = current.metadata.get("is_table", False)
         
-        if len(current["content"]) < cfg.min_chars and i + 1 < len(raw_chunks):
-            next_chunk = raw_chunks[i + 1]
-            merged_content = current["content"] + "\n\n" + next_chunk["content"]
-            
-            # Combine section names if different
-            if current["metadata"]["section"] != next_chunk["metadata"]["section"]:
-                merged_section = f"{current['metadata']['section']} + {next_chunk['metadata']['section']}"
-            else:
-                merged_section = current["metadata"]["section"]
-            
-            merged_md = dict(next_chunk["metadata"])
-            merged_md["section"] = merged_section
-            
-            chunks.append({"content": merged_content, "metadata": merged_md})
-            i += 2  # Skip next chunk since we merged it
+        if not is_table and len(current.get_content()) < MIN_CHUNK_SIZE:
+            # Try to merge with next non-table node
+            if i + 1 < len(all_nodes):
+                next_node = all_nodes[i + 1]
+                next_is_table = next_node.metadata.get("is_table", False)
+                
+                if not next_is_table:
+                    merged_content = current.get_content() + "\n\n" + next_node.get_content()
+                    merged_metadata = current.metadata.copy()
+                    merged_metadata.update(next_node.metadata)
+                    final_nodes.append(TextNode(text=merged_content, metadata=merged_metadata))
+                    i += 2
+                    continue
+        
+        final_nodes.append(current)
+        i += 1
+    
+    # Step 5: Enrich metadata
+    for node in final_nodes:
+        _enrich_node_metadata(node, source_path)
+    
+    return final_nodes
+
+
+def _chunk_simple(doc: Document, source_path: str | Path | None = None) -> List[BaseNode]:
+    """Simple chunking for documents without tables."""
+    md_parser = _get_markdown_parser()
+    heading_nodes = md_parser.get_nodes_from_documents([doc])
+    
+    sentence_splitter = _get_sentence_splitter()
+    split_nodes: List[BaseNode] = []
+    
+    for node in heading_nodes:
+        content_len = len(node.get_content())
+        if content_len > CHUNK_SIZE:
+            sub_nodes = sentence_splitter.get_nodes_from_documents(
+                [Document(text=node.get_content(), metadata=node.metadata.copy())]
+            )
+            split_nodes.extend(sub_nodes)
         else:
-            chunks.append(current)
-            i += 1
+            split_nodes.append(node)
+    
+    merged_nodes = _merge_small_nodes(split_nodes)
+    
+    for node in merged_nodes:
+        _enrich_node_metadata(node, source_path)
+    
+    return merged_nodes
+
+
+def chunk_markdown(
+    text: str,
+    source_path: str | Path | None = None,
+) -> List[BaseNode]:
+    """
+    Chunk markdown text with table-aware splitting.
     
-    # Add chunk indices
-    for idx, chunk in enumerate(chunks):
-        chunk["metadata"]["chunk_index"] = idx
+    Features:
+    - Preserves complete tables in chunks
+    - Splits large tables by rows while keeping headers
+    - Uses markdown heading structure for text sections
+    - Merges small chunks for better context
+    
+    Args:
+        text: Markdown text to chunk
+        source_path: Optional source file path for metadata
+        
+    Returns:
+        List of TextNode chunks with metadata
+    """
+    if not text or not text.strip():
+        return []
     
-    return chunks
+    doc = Document(text=text)
+    
+    if source_path:
+        p = Path(source_path)
+        doc.metadata["source_path"] = str(p)
+        doc.metadata["source_file"] = p.name
+    
+    # Use table-aware chunking
+    if _has_markdown_table(text):
+        all_nodes = _chunk_with_table_awareness(doc, source_path)
+    else:
+        all_nodes = _chunk_simple(doc, source_path)
+    
+    # Add chunk index
+    for idx, node in enumerate(all_nodes):
+        node.metadata["chunk_index"] = idx
+    
+    return all_nodes
 
 
-def chunk_markdown_file(
-    path: str | Path, 
-    *, 
-    config: ChunkConfig | None = None
-) -> List[Dict[str, Any]]:
-    """Chunk a Markdown file."""
+def chunk_markdown_file(path: str | Path) -> List[BaseNode]:
+    """
+    Chunk a markdown file with table-aware splitting.
+    
+    Args:
+        path: Path to markdown file
+        
+    Returns:
+        List of TextNode chunks with metadata
+    """
     p = Path(path)
-    return chunk_markdown(p.read_text(encoding="utf-8"), source_path=p, config=config)
+    if not p.exists():
+        raise FileNotFoundError(f"File not found: {p}")
+    if not p.is_file():
+        raise ValueError(f"Path is not a file: {p}")
+    
+    text = p.read_text(encoding="utf-8")
+    return chunk_markdown(text, source_path=p)

core/embeddings/embedding_model.py

@@ -2,39 +2,20 @@ from __future__ import annotations
 import os
 import logging
 from dataclasses import dataclass
-from pathlib import Path
 from typing import List, Sequence
 import numpy as np
 from openai import OpenAI
 from langchain_core.embeddings import Embeddings
-from utils.helpers import read_yaml
 import time
 logger = logging.getLogger(__name__)
 
 
 @dataclass
 class EmbeddingConfig:
-    api_base_url: str
-    model: str
-    dimension: int
-    batch_size: int
-
-    @staticmethod
-    def default_yaml_path() -> Path:
-        return Path(__file__).resolve().parents[2] / "config" / "embedding.yaml"
-    
-    @classmethod
-    def from_yaml(cls, path: str | Path | None = None) -> "EmbeddingConfig":
-        cfg_path = Path(path) if path is not None else cls.default_yaml_path()
-        data = read_yaml(cfg_path)
-        emb = data["embedding"]
-        
-        return cls(
-            api_base_url=data["api_base_url"],
-            model=emb["model_name"],
-            dimension=emb["dimension"],
-            batch_size=emb["batch_size"],
-        )
+    api_base_url: str = "https://api.siliconflow.com/v1"
+    model: str = "Qwen/Qwen3-Embedding-4B"
+    dimension: int = 2048
+    batch_size: int = 16
 
 
 _embed_config: EmbeddingConfig | None = None
@@ -42,7 +23,7 @@ _embed_config: EmbeddingConfig | None = None
 def get_embedding_config() -> EmbeddingConfig:
     global _embed_config
     if _embed_config is None:
-        _embed_config = EmbeddingConfig.from_yaml()
+        _embed_config = EmbeddingConfig()
     return _embed_config
 
 

core/embeddings/generator.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+from typing import Any, Dict, Generator, List, Optional, TYPE_CHECKING
+
+from groq import Groq
+
+if TYPE_CHECKING:
+    from core.embeddings.retrival import Retriever
+
+
+SYSTEM_PROMPT = """Bạn là Trợ lý học vụ Đại học Bách khoa Hà Nội.
+
+## 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õ.
+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ó."
+"""
+
+
+def build_context(results: List[Dict[str, Any]], max_chars: int = 5000) -> str:
+    """Build context string from retrieval results."""
+    parts = []
+    for i, r in enumerate(results, 1):
+        section = r.get("metadata", {}).get("section", "N/A")
+        content = r.get("content", "").strip()[:600]
+        parts.append(f"[TÀI LIỆU {i}]\n- Phần/Điều: {section}\n{content}")
+
+    context = "\n---\n".join(parts)
+    return context[:max_chars] if len(context) > max_chars else context
+
+
+class RAGGenerator:
+    """RAG Answer Generator using Groq LLM."""
+
+    def __init__(
+        self,
+        retriever: "Retriever",
+        llm_model: str = "qwen/qwen3-32b",
+        temperature: float = 0.0,
+        max_tokens: int = 4096,
+        max_context_chars: int = 5000,
+        groq_client: Optional[Groq] = None,
+    ):
+        self._retriever = retriever
+        self._llm_model = llm_model
+        self._temperature = temperature
+        self._max_tokens = max_tokens
+        self._max_context_chars = max_context_chars
+        api_key = (os.getenv("GROQ_API_KEY") or "").strip()
+        if not api_key and groq_client is None:
+            raise RuntimeError("Missing GROQ_API_KEY")
+        self._groq = groq_client or Groq(api_key=api_key)
+
+    def _build_prompt(self, question: str, context: str) -> str:
+        """Build prompt with system prompt, context, and question."""
+        return f"{SYSTEM_PROMPT}\n\n## CONTEXT:\n{context}\n\n## CÂU HỎI: {question}\n\n## TRẢ LỜI:"
+
+    def generate(self, question: str, k: int = 5, initial_k: int = 20) -> Dict[str, Any]:
+        """Generate answer (non-streaming, for evaluation)."""
+        results = self._retriever.search_with_rerank(question, k=k, initial_k=initial_k)
+
+        if not results:
+            return {
+                "answer": "Không tìm thấy thông tin trong dữ liệu hiện có.",
+                "contexts": [],
+                "results": [],
+            }
+
+        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,
+        )
+
+        return {
+            "answer": completion.choices[0].message.content or "",
+            "contexts": [r.get("content", "")[:1000] for r in results],
+            "results": results,
+        }
+
+    def generate_stream(
+        self, question: str, k: int = 5, initial_k: int = 20
+    ) -> Generator[str, None, None]:
+        """Generate answer with streaming (for Gradio)."""
+        results = self._retriever.search_with_rerank(question, k=k, initial_k=initial_k)
+
+        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

@@ -2,7 +2,6 @@ from __future__ import annotations
 import os
 import logging
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
 import requests
 from pydantic import Field
@@ -12,7 +11,6 @@ from langchain_core.documents.compressor import BaseDocumentCompressor
 from langchain_classic.retrievers import ContextualCompressionRetriever
 from langchain_classic.retrievers.ensemble import EnsembleRetriever
 from langchain_community.retrievers import BM25Retriever
-from utils.helpers import read_yaml
 
 if TYPE_CHECKING:
     from core.embeddings.vector_store import ChromaVectorDB
@@ -22,34 +20,13 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class RetrievalConfig:
-    rerank_api_base_url: str
-    rerank_model: str
-    rerank_top_n: int
-    initial_k: int
-    top_k: int
-    vector_weight: float
-    bm25_weight: float
-
-    @staticmethod
-    def default_yaml_path() -> Path:
-        return Path(__file__).resolve().parents[2] / "config" / "retrieval.yaml"
-    
-    @classmethod
-    def from_yaml(cls, path: str | Path | None = None) -> "RetrievalConfig":
-        cfg_path = Path(path) if path is not None else cls.default_yaml_path()
-        data = read_yaml(cfg_path)
-        rerank = data["reranker"]
-        hybrid = data["hybrid"]
-        
-        return cls(
-            rerank_api_base_url=rerank["api_base_url"],
-            rerank_model=rerank["model_name"],
-            rerank_top_n=rerank["top_n"],
-            initial_k=hybrid["initial_k"],
-            top_k=hybrid["top_k"],
-            vector_weight=hybrid["vector_weight"],
-            bm25_weight=hybrid["bm25_weight"],
-        )
+    rerank_api_base_url: str = "https://api.siliconflow.com/v1"
+    rerank_model: str = "Qwen/Qwen3-Reranker-4B"
+    rerank_top_n: int = 5
+    initial_k: int = 50
+    top_k: int = 5
+    vector_weight: float = 0.5
+    bm25_weight: float = 0.5
 
 
 _retrieval_config: RetrievalConfig | None = None
@@ -57,7 +34,7 @@ _retrieval_config: RetrievalConfig | None = None
 def get_retrieval_config() -> RetrievalConfig:
     global _retrieval_config
     if _retrieval_config is None:
-        _retrieval_config = RetrievalConfig.from_yaml()
+        _retrieval_config = RetrievalConfig()
     return _retrieval_config
 
 
@@ -134,6 +111,8 @@ class SiliconFlowReranker(BaseDocumentCompressor):
                     logger.error(f"Rerank error: {e}")
                     return list(documents)
 
+        return list(documents)
+
 
 class Retriever:
     def __init__(
@@ -184,8 +163,8 @@ class Retriever:
             return None
     
     def _init_ensemble_retriever(self) -> EnsembleRetriever:
-        retrievers = [self._vector_retriever]
-        weights = [1.0]
+        retrievers: List[Any] = [self._vector_retriever]
+        weights: List[float] = [1.0]
         
         if self._bm25_retriever:
             retrievers.append(self._bm25_retriever)

core/embeddings/vector_store.py

@@ -1,49 +1,24 @@
 from __future__ import annotations
 import json
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence
 from langchain_core.documents import Document
 from langchain_chroma import Chroma
 from core.hash_file.hash_file import HashProcessor
-from utils.helpers import read_yaml
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass
 class ChromaConfig:
-    persist_dir: str
-    collection_name: str
-
-    @staticmethod
-    def default_yaml_path() -> Path:
-        return Path(__file__).resolve().parents[2] / "config" / "vector_db.yaml"
-
-    @classmethod
-    def from_yaml(cls, path: str | Path | None = None) -> "ChromaConfig":
-        cfg_path = Path(path) if path is not None else cls.default_yaml_path()
-        if not cfg_path.exists():
-            raise FileNotFoundError(f"Vector DB config not found: {cfg_path}")
-        
-        data = read_yaml(cfg_path) or {}
-        if not isinstance(data, dict):
-            raise ValueError(f"Invalid config format: {cfg_path}")
-
-        required = {"persist_dir", "collection_name"}
-        missing = [k for k in required if k not in data]
-        if missing:
-            raise KeyError(f"Missing keys in {cfg_path}: {', '.join(missing)}")
-
-        cfg = cls(
-            persist_dir=str(data["persist_dir"]),
-            collection_name=str(data["collection_name"]),
-        )
-        p = Path(cfg.persist_dir)
-        if not p.is_absolute():
-            cfg.persist_dir = str((cfg_path.parent.parent / p).resolve())
-        return cfg
+    def _default_persist_dir() -> str:
+        repo_root = Path(__file__).resolve().parents[2]
+        return str((repo_root / "data" / "chroma").resolve())
+
+    persist_dir: str = field(default_factory=_default_persist_dir)
+    collection_name: str = "hust_rag_collection"
 
 
 class ChromaVectorDB:
@@ -53,7 +28,7 @@ class ChromaVectorDB:
         config: ChromaConfig | None = None,
     ):
         self.embedder = embedder
-        self.config = config or ChromaConfig.from_yaml()
+        self.config = config or ChromaConfig()
         self._hasher = HashProcessor(verbose=False)
 
         self._vs = Chroma(

core/gradio/gradio_rag_qwen.py

@@ -12,8 +12,6 @@ REPO_ROOT = Path(__file__).resolve().parents[2]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.helpers import read_yaml
-
 
 @dataclass
 class GradioConfig:
@@ -23,23 +21,6 @@ class GradioConfig:
     server_host: str
     server_port: int
 
-    @staticmethod
-    def default_yaml_path() -> Path:
-        return Path(__file__).resolve().parents[2] / "config" / "gradio.yaml"
-    
-    @classmethod
-    def from_yaml(cls, path: str | Path | None = None) -> "GradioConfig":
-        cfg_path = Path(path) if path is not None else cls.default_yaml_path()
-        data = read_yaml(cfg_path)
-        
-        return cls(
-            llm_model=data["llm"]["model"],
-            llm_temperature=data["llm"]["temperature"],
-            llm_max_tokens=data["llm"]["max_tokens"],
-            server_host=data["server"]["host"],
-            server_port=data["server"]["port"],
-        )
-
 
 def _load_env() -> None:
     dotenv_path = find_dotenv(usecwd=True) or ""
@@ -53,7 +34,13 @@ from core.embeddings.retrival import Retriever, get_retrieval_config
 _load_env()
 
 # Load all configs
-GRADIO_CFG = GradioConfig.from_yaml()
+GRADIO_CFG = GradioConfig(
+    llm_model="qwen/qwen3-32b",
+    llm_temperature=0.0,
+    llm_max_tokens=4096,
+    server_host="127.0.0.1",
+    server_port=7860,
+)
 RETRIEVAL_CFG = get_retrieval_config()
 
 
@@ -73,12 +60,9 @@ def _init_resources() -> None:
 
     print(" Đang khởi tạo Database & Re-ranker...")
 
-    cfg = EmbeddingConfig.from_yaml()
-    emb = QwenEmbeddings(cfg)
+    emb = QwenEmbeddings(EmbeddingConfig())
 
-    db_cfg = ChromaConfig.from_yaml()
-    db_cfg.persist_dir = os.getenv("PERSIST_DIR", db_cfg.persist_dir)
-    db_cfg.collection_name = os.getenv("COLLECTION", db_cfg.collection_name)
+    db_cfg = ChromaConfig()
     
     STATE.db = ChromaVectorDB(
         embedder=emb,
@@ -194,7 +178,7 @@ 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",
+    title="HUST RAG Assistant",
     description="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ì?",

data/data_process/quyet_dinh/{06_ Quy định ngoại ngữ từ K70_chính quy_final.md → tieng_anh/06_ Quy định ngoại ngữ từ K70_chính quy_final.md}

@@ -29,39 +29,32 @@ Việc lựa chọn tiêu chí phân loại trong số các tiêu chí trên do
 ## Điều 3 . Công nhận, xét miễn học phần ngoại ngữ cơ bản
 
 1. Các học phần NNCB của các CTĐT được xếp vào khối kiến thức ngoại ngữ bổ trợ tăng cường và không tính tín chỉ trong CTĐT chính khóa . Danh sách các học phần NNCB của các CTĐT được quy định tại các Phụ lục tương ứng kèm theo Quy định này .
-2. 2 . Trong quá trình học tập, nếu sinh viên đạt được chứng chỉ ngoại ngữ theo quy định sẽ được xét miễn các học phần NNCB tương ứng với trình độ đạt được. Kết quả miễn học được ghi bằng ký hiệu "R" trong dữ liệu học tập và có giá trị toàn khóa kể từ ngày nhập điểm R.
+2. Trong quá trình học tập, nếu sinh viên đạt được chứng chỉ ngoại ngữ theo quy định sẽ được xét miễn các học phần NNCB tương ứng với trình độ đạt được. Kết quả miễn học được ghi bằng ký hiệu "R" trong dữ liệu học tập và có giá trị toàn khóa kể từ ngày nhập điểm R.
 3. Chứng chỉ ngoại ngữ để xét miễn học phần NNCB phải còn hạn theo quy định tính tới thời điểm nộp đơn xét miễn. Danh mục chứng chỉ và học phần NNCB được miễn tương ứng được quy định tại các Phụ lục tương ứng kèm theo Quy định này .
-4. 4 . Các chứng chỉ ngoại ngữ quốc gia, quốc tế phải được thẩm định nguồn gốc và cập nhật mức điểm lên hệ thống phần mềm quản lý đào tạo trước thời điểm nộp đơn đề nghị xét miễn học phần NNCB .
-5. 5 . Thời gian tiếp nhận đơn đề nghị xét miễn học phần NNCB muộn nhất là 2 tuần trước khi bắt đầu học kỳ theo Khung kế hoạch năm học .
+4. Các chứng chỉ ngoại ngữ quốc gia, quốc tế phải được thẩm định nguồn gốc và cập nhật mức điểm lên hệ thống phần mềm quản lý đào tạo trước thời điểm nộp đơn đề nghị xét miễn học phần NNCB .
+5. Thời gian tiếp nhận đơn đề nghị xét miễn học phần NNCB muộn nhất là 2 tuần trước khi bắt đầu học kỳ theo Khung kế hoạch năm học .
 
 ## Điều 4 . Lộ trình học tập các học phần ngoại ngữ cơ bản
-
 Lộ trình học tập đối với các học phần NNCB được áp dụng để đảm bảo năng lực ngoại ngữ của sinh viên được tăng cường dần qua các học kỳ và được quy định như sau:
-
-- 1 . Trong học kỳ 1 và học kỳ 2, Ban Đào tạo xếp lớp học các học phần NNCB cho sinh viên dựa trên kết quả phân loại trình độ ngoại ngữ đầu vào theo quy định tại Điều 2.
-- 2 . Từ học kỳ 3 trở đi, sinh viên tự đăng ký học song hành các học phần NNCB cùng v ới các học phần khác trong CTĐT, bảo đảm tiến độ đáp ứng chuẩn ngoại ngữ theo từng học kỳ quy định tại các Phụ lục tương ứng kèm theo Quy định này.
+1. Trong học kỳ 1 và học kỳ 2, Ban Đào tạo xếp lớp học các học phần NNCB cho sinh viên dựa trên kết quả phân loại trình độ ngoại ngữ đầu vào theo quy định tại Điều 2.
+2. Từ học kỳ 3 trở đi, sinh viên tự đăng ký học song hành các học phần NNCB cùng v ới các học phần khác trong CTĐT, bảo đảm tiến độ đáp ứng chuẩn ngoại ngữ theo từng học kỳ quy định tại các Phụ lục tương ứng kèm theo Quy định này.
 3. Việc đăng ký học song hành các học phần NNCB tương ứng ở mỗi kỳ kể từ kỳ 3 trở đi (trừ trường hợp đã học hoặc được miễn học phần) là điều kiện bắt buộc để được đăng ký học tập các học phần khác trong CTĐT.
 4. Sinh viên không được phép hủy các học phần NNCB đã đăng ký học song hành, trừ trường hợp xin rút hoặc chủ động rút toàn bộ đăng ký học tập trong học kỳ .
 
 ## Điều 5. Yêu cầu về chuẩn ngoại ngữ đầu ra
-
 1. Yêu cầu về chuẩn ngoại ngữ đầu ra được quy định cụ thể cho từng CTĐT tại các Phụ lục tương ứng kèm theo Quy định này.
-
 2. Chứng chỉ tiếng Anh phải đánh giá đầy đủ 4 kỹ năng nghe, nói, đọc , viết; đồng thời phải được cấp trong vòng 2 năm tính đến thời điểm xét chuẩn ngoại ngữ đầu ra và còn hiệu lực tại thời điểm xét.
 
 ## Điều 6. Các trường hợp ngoại lệ
-
 Các trường hợp ngoại lệ sẽ do Ban Đào tạo đề xuất Giám đốc Đại học Bách khoa Hà Nội xem xét quyết định .
 
 ## Điều 7. Hiệu lực thi hành
-
 1. Quy định này được áp dụng từ học kỳ 1 năm học 2025-2026 đối với sinh viên đại học hình thức chính quy và các CTĐT kể từ khóa 70 trở về sau, trừ các quy định sau:
 - a) Bảng quy đổi tương đương các chứng chỉ ngoại ngữ áp dụng cho toàn bộ sinh viên các khóa, đối với các chứng chỉ được cấp kể từ ngày Quy định này có hiệu lực;
 - b) Đối với sinh viên các khóa từ 69 trở về trước, nếu mức quy đổi tương đương cùng một chứng chỉ ngoại ngữ theo Quy định này khác với mức quy đổi theo quy định trước đây thì áp dụng mức quy đổi cao hơn trong hai quy định; mức cao hơn được xác định theo Khung năng lực ngoại ngữ 6 bậc dùng cho Việt Nam.
-2. Các quy định hiện hành về ngoại ngữ đối với sinh viên và CTĐT từ khóa 69 trở v ề trước (trừ quy định về quy đổi tương đương chứng chỉ) vẫn tiếp tục có hiệu lực thi hành cho đến thời điểm kết thúc khóa đào tạo.
+2. Các quy định hiện hành về ngoại ngữ đối với sinh viên và CTĐT từ khóa 69 trở về trước (trừ quy định về quy đổi tương đương chứng chỉ) vẫn tiếp tục có hiệu lực thi hành cho đến thời điểm kết thúc khóa đào tạo.
 
 ## Phụ lục I
-
 ## DANH MỤC CÁC CHƯƠNG TRÌNH ĐÀO TẠO VÀ NGOẠI NGỮ CHÍNH YÊU CẦU
 
 1. Các chương trình đào tạo chuẩn

data/data_process/quyet_dinh/tieng_anh/QD_ngoai_ngu_tu_K65_CQ_final.md

@@ -0,0 +1,41 @@
+# QUY ĐỊNH  Phân loại trình độ đầu vào, chương trình môn học và chuẩn ngoại ngữ yêu cầu đối với sinh viên đại học hệ chính quy
+
+## Điều 1. Phạm vi và đối tượng áp dụng
+1. Văn bản này quy định về công tác tổ chức đánh giá và phân loại trình độ ngoại ngữ đầu vào; chương trình môn học ngoại ngữ; điều kiện được miễn học các học phần ngoại ngữ; chuẩn ngoại ngữ yêu cầu theo tín chỉ lũy tích và chuẩn ngoại ngữ đầu ra.
+2. Quy định này áp dụng cho sinh viên đại học hệ chính quy, không thuộc ngành Ngôn ngữ Anh của Trường Đại học Bách khoa Hà Nội.
+3. Quy định này không áp dụng cho sinh viên là người nước ngoài đang học tại Trường Đại học Bách khoa Hà Nội.
+
+## Điều 2. Phân loại trình độ đầu vào và phân lớp học ngoại ngữ
+1. Căn cứ phân loại trình độ ngoại ngữ đầu vào với sinh viên thuộc chương trình đào tạo có yêu cầu chuẩn đầu ra là tiếng Anh:
+   - a) Đối với các sinh viên thuộc chương trình đào tạo chuẩn: phân loại dựa trên điểm thi môn tiếng Anh của kỳ thi tốt nghiệp THPT tại năm nhập học hoặc chứng chỉ tiếng Anh quốc tế.
+   - b) Đối với các sinh viên thuộc các chương trình đào tạo tiên tiến, tài năng và chương trình hợp tác quốc tế: phân loại dựa trên kết quả kiểm tra tiếng Anh nội bộ đầu khóa học hoặc chứng chỉ tiếng Anh quốc tế.
+2. Căn cứ phân loại trình độ ngoại ngữ đầu vào với sinh viên thuộc chương trình đào tạo có yêu cầu chuẩn đầu ra là ngoại ngữ khác tiếng Anh: phân loại dựa trên điểm thi môn ngoại ngữ tương ứng của kỳ thi tốt nghiệp THPT tại năm nhập học hoặc chứng chỉ quốc tế của ngôn ngữ tương ứng.
+3. Căn cứ trên kết quả phân loại trình độ ngoại ngữ đầu vào, sinh viên được xét miễn các học phần theo quy định và được xếp lớp học ngoại ngữ tương ứng.
+4. Sinh viên không đáp ứng đủ điều kiện phân loại trình độ ngoại ngữ theo mục 1 hoặc mục 2 của điều này sẽ phải học toàn bộ chương trình ngoại ngữ theo quy định.
+
+## Điều 3. Công nhận, xét miễn học phần ngoại ngữ
+1. Tất cả các học phần ngoại ngữ tương ứng với từng chương trình đào tạo là các học phần bắt buộc. Nhà trường sẽ đăng ký các học phần ngoại ngữ theo kế hoạch học tập chuẩn cho các sinh viên.
+2. Trong quá trình học tập, nếu sinh viên đạt được chứng chỉ ngoại ngữ theo quy định sẽ được xét miễn các học phần ngoại ngữ tương ứng với trình độ đạt được. Các học phần được miễn sẽ ghi điểm R trong bảng điểm.
+3. Chứng chỉ ngoại ngữ để xét miễn học phần phải còn hạn theo quy định tính tới thời điểm nộp đơn xét miễn. Danh sách chứng chỉ và các học phần được miễn được ghi trong các phụ lục tương ứng.
+4. Toàn bộ các chứng chỉ ngoại ngữ quốc tế phải được thẩm định nguồn gốc và cập nhật mức điểm lên hệ thống phần mềm lý đào tạo trước thời điểm nộp đơn xét miễn học phần.
+5. Thời gian tiếp nhận đơn xét miễn học phần ngoại ngữ muộn nhất là 2 tuần trước khi học kỳ bắt đầu theo Biểu đồ kế hoạch học tập của năm học.
+
+## Điều 4. Yêu cầu về chuẩn ngoại ngữ theo tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra
+1. Yêu cầu về chuẩn ngoại ngữ theo số lượng tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra được quy định cụ thể cho từng chương trình đào tạo tại các phụ lục tương ứng, được ban hành kèm quy định này.
+2. Kết quả thi các kỳ thi ngoại ngữ nội bộ của Trường Đại học Bách khoa Hà Nội được công nhận để xét điều kiện chuẩn ngoại ngữ theo tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra. Riêng với các sinh viên thuộc chương trình đào tạo tiên tiến, chương trình đào tạo tài năng và chương trình đào tạo hợp tác quốc tế phải có chứng chỉ ngoại ngữ quốc tế để được xét công nhận đạt chuẩn ngoại ngữ đầu ra.
+3. Sinh viên được tham dự các kỳ thi Tiếng Anh nội bộ của Trường nhiều lần và được công nhận điểm thi cao nhất trong các lần thi. Kết quả này có giá trị công nhận trong vòng 2 năm kể từ ngày thi.
+
+## Điều 5. Hạn chế khối lượng học tập trong trường hợp không đạt chuẩn ngoại ngữ theo tín chỉ tích lũy và điều kiện gỡ bỏ hạn chế
+1. Sinh viên không đạt chuẩn ngoại ngữ quy định theo số tín chỉ tích lũy sẽ chỉ được đăng ký tối đa 14 TC và tối thiểu 8 TC cho một học kỳ chính, tương ứng với quy định tại Điều 19 của Quy chế đào tạo chính quy.
+2. Điều kiện gỡ bỏ hạn chế khối lượng học tập:
+a) Chỉ áp dụng với sinh viên các chương trình đào tạo chuẩn, đào tạo tài năng, đào tạo tiên tiến và quốc tế với chuẩn ngoại ngữ đầu ra là tiếng Anh và đang ở trạng thái bị hạn chế khối lượng học tập theo quy định tại mục 1 của điều này.
+b) Sinh viên được gỡ bỏ mức hạn chế khối lượng học tập hoặc được tiếp tục học tập nếu đã đăng ký học tại Trường ít nhất 90 tiết học các học phần tiếng Anh bổ trợ. Các học phần tiếng Anh bổ trợ được đăng ký học phải đảm bảo tương đương với trình độ tiếng Anh yêu cầu trong học kỳ cần gỡ bỏ hạn chế khối lượng học tập.
+c) Yêu cầu về chuyên cần khi tham gia học các học phần tiếng Anh bổ trợ: sinh viên cần đảm bảo tham dự tối thiểu 80% số tiết học theo yêu cầu của mỗi học phần. Những sinh viên không đảm bảo điều kiện chuyên cần với bất cứ học phần tiếng Anh bổ trợ nào đã đăng ký sẽ bị áp dụng mức hạn chế khối lượng học tập ở học kỳ kế tiếp.
+d) Điều kiện gỡ bỏ giới hạn khối lượng học tập không áp dụng cho các trường hợp sinh viên bị cảnh báo học tập, xét nhận đồ án tốt nghiệp/khóa luận tốt nghiệp, xét tốt nghiệp.
+
+## Điều 6. Các trường hợp ngoại lệ
+Các trường hợp ngoại lệ sẽ do đơn vị chức năng quản lý đào tạo đề xuất để Hiệu trưởng quyết định, căn cứ các quy định hiện hành của Bộ Giáo dục và Đào tạo.
+
+## Điều 7. Hiệu lực thi hành
+1. Quy định này được áp dụng từ năm học 2020–2021 đối với các chương trình đào tạo kể từ khóa 65 trở về sau.
+2. Quy định hiện hành về ngoại ngữ đối với các chương trình đào tạo từ khóa 64 trở về trước vẫn tiếp tục còn hiệu lực thi hành cho đến thời điểm kết thúc khóa đào tạo.

data/data_process/quyet_dinh/{QD_ngoai_ngu_tu_K68_CQ_final.md → tieng_anh/QD_ngoai_ngu_tu_K68_CQ_final.md}

@@ -2,18 +2,17 @@
 document_type: "quyet_dinh"
 title: "QUYẾT ĐỊNH Về việc ban hành Quy định về phân loại trình độ đầu vào, chương trình môn học và chuẩn ngoại ngữ yêu cầu đối với sinh viên đại học hệ chính quy từ k68"
 issued_year: "2024"
+
 ---
 
 # QUYẾT ĐỊNH Về việc ban hành Quy định về phân loại trình độ đầu vào, chương trình môn học và chuẩn ngoại ngữ yêu cầu đối với sinh viên đại học hệ chính quy từ k68
 
 ## Điều 1. Phạm vi và đối tượng áp dụng
-
 1. Văn bản này quy định về công tác tổ chức đánh giá và phân loại trình độ ngoại ngữ đầu vào; chương trình môn học ngoại ngữ; điều kiện được miễn học các học phần ngoại ngữ; chuẩn ngoại ngữ yêu cầu theo số lượng tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra.
 2. Quy định này áp dụng cho sinh viên đại học hệ chính quy , không thuộc ngành Ngôn ngữ Anh của Đại học Bách khoa Hà Nội .
 3. Quy định này không áp dụng cho sinh viên là người nước ngoài đang học tại Đại học Bách khoa Hà Nội.
 
 ## Điều 2. Phân loại trình độ đầu vào và phân lớp học ngoại ngữ
-
 1. Căn cứ phân loại trình độ ngoại ngữ đầu vào với sinh viên thuộc chương trình đào tạo có yêu cầu chuẩn đầu ra là tiếng Anh dựa trên một hoặc nhiều tiêu chí, bao gồm:
 + Dựa trên kết quả kiểm tra tiếng Anh đầu khóa;
 + Hoặc dựa trên chứng chỉ tiếng Anh quốc gia, quốc tế;
@@ -26,21 +25,19 @@ Việc lựa chọn tiêu chí phân loại cụ thể trong số các tiêu ch
 4. Sinh viên không đáp ứng điều kiện phân loại trình độ ngoại ngữ theo khoản 1 hoặc khoản 2 của điều này sẽ phải học toàn bộ các học phần ngoại ngữ tương ứng với từng chương trình đào tạo theo lộ trình quy định.
 
 ## Điều 3 . Công nhận, xét miễn học phần ngoại ngữ
-
 1. Tất cả các học phần ngoại ngữ tương ứng với từng chương trình đào tạo là các học phần bắt buộc. Lộ trình học tập đối với các học phần ngoại ngữ được quy định như sau:
-
 - a. Ban Đào tạo sẽ đăng ký các học phần ngoại ngữ đối với 2 học kỳ đầu cho sinh viên dựa theo kết quả phân loại trình độ ngoại ngữ đầu vào .
 - b. Học kỳ thứ 3: dành cho sinh viên để tự đăng ký học lại các học phần ngoại ngữ không đạt ở 2 học kỳ đầu (nếu có) và chủ động thi chứng chỉ ngoại ngữ.
 - c. Từ kỳ thứ 4 trở đi: Ban Đào tạo sẽ thực hiện việc đăng ký bắt buộc các học phần ngoại ngữ đối với các sinh viên không đạt chuẩn ngoại ngữ theo số lượng tín chỉ tích lũy .
-4. 2 . Trong quá trình học tập, nếu sinh viên đạt được chứng chỉ ngoại ngữ theo quy định sẽ được xét miễn các học phần ngoại ngữ tương ứng với trình độ đạt được. Các học phần được miễn sẽ được ghi điểm R trong bảng điểm.
+2. Trong quá trình học tập, nếu sinh viên đạt được chứng chỉ ngoại ngữ theo quy định sẽ được xét miễn các học phần ngoại ngữ tương ứng với trình độ đạt được. Các học phần được miễn sẽ được ghi điểm R trong bảng điểm.
 3. Chứng chỉ ngoại ngữ để xét miễn học phần phải còn hạn theo quy định tính tới thời điểm nộp đơn xét miễn. Danh sách chứng chỉ và các học phần được miễn được ghi trong các phụ lục tương ứng kèm theo Quy định này .
-6. 4 . Toàn bộ các chứng chỉ ngoại ngữ quốc gia, quốc tế phải được thẩm định nguồn g ốc và cập nhật mức điểm lên hệ thống phần mềm quản lý đào tạo trước thời điểm nộp đơn đề nghị xét miễn học phần ngoại ngữ .
-7. 5 . Thời gian tiếp nhận đơn đề nghị xét miễn học phần ngoại ngữ muộn nhất là 2 tu ần trước khi bắt đầu học kỳ theo Khung kế hoạch thời gian của năm học .
+4. Toàn bộ các chứng chỉ ngoại ngữ quốc gia, quốc tế phải được thẩm định nguồn g ốc và cập nhật mức điểm lên hệ thống phần mềm quản lý đào tạo trước thời điểm nộp đơn đề nghị xét miễn học phần ngoại ngữ .
+5. Thời gian tiếp nhận đơn đề nghị xét miễn học phần ngoại ngữ muộn nhất là 2 tu ần trước khi bắt đầu học kỳ theo Khung kế hoạch thời gian của năm học .
 
 ## Điều 4. Yêu cầu về chuẩn ngoại ngữ theo tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra
 
 1. Yêu cầu về chuẩn ngoại ngữ theo số lượng tín chỉ tích lũy và chuẩn ngoại ngữ đầu ra được quy định cụ thể cho từng chương trình đào tạo tại các phụ lục tương ứng kèm theo Quy định này .
-2. Kết quả thi các kỳ thi ngoại ngữ nội bộ của Đại học Bách khoa Hà Nội được công nhận để xét điều kiện chuẩn ngoại ngữ theo số lượng tín chỉ tích lũy .
+2. Kết quả thi các kỳ thi ngoại ngữ nội bộ của Đại học Bách khoa Hà Nội được công n hận để xét điều kiện chuẩn ngoại ngữ theo số lượng tín chỉ tích lũy .
 3. Sinh viên được tham dự các kỳ thi tiếng Anh nội bộ của Đại học Bách khoa Hà Nội nhiều lần và được công nhận điểm thi cao nhất trong các lần thi. Kết quả thi này có giá trị công nhận trong vòng 2 năm kể từ ngày thi.
 4. 4 . Sinh viên thuộc các chương trình đào tạo Elitech (bao gồm chương trình tiên tiến, chương trình đào tạo tài năng và chương trình đào tạo hợp tác quốc tế) có ngoại ngữ yêu cầu là tiếng Anh và sinh viên thuộc các chương trình đào tạo chuẩn phải có chứng chỉ tiếng Anh quốc tế 4 kỹ năng hoặc chứng chỉ VSTEP tương đương để được xét công nhận đạt chuẩn ngoại ngữ đầu ra. Các chứng chỉ tiếng Anh có giá trị công nhận trong vòng 2 năm kể từ ngày cấp .
 

data/data_raw/quyet_dinh/quy-dinh-chuan-ngoai-ngu-2021.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1529ce07003568dd8458b84b149d0d681eb1b35ab485e0c3e61ca931b0a0223
+size 12550193

evaluation/eval_utils.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+import os
+import re
+import sys
+import csv
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Any
+from dotenv import find_dotenv, load_dotenv
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+load_dotenv(find_dotenv(usecwd=True))
+
+from core.embeddings.embedding_model import SiliconFlowConfig, QwenEmbeddings
+from core.embeddings.vector_store import ChromaConfig, ChromaVectorDB
+from core.embeddings.retrival import Retriever
+from core.embeddings.generator import RAGGenerator
+
+
+def strip_thinking(text: str) -> str:
+    """Remove <think>...</think> tags from model output."""
+    return re.sub(r'<think>.*?</think>\s*', '', text, flags=re.DOTALL).strip()
+
+
+def load_config() -> dict:
+    return {
+        "llm": {
+            "model": os.getenv("EVAL_LLM_MODEL", "nex-agi/DeepSeek-V3.1-Nex-N1"),
+            "temperature": float(os.getenv("EVAL_LLM_TEMPERATURE", "0")),
+            "timeout": int(os.getenv("EVAL_LLM_TIMEOUT", "30")),
+            "max_retries": int(os.getenv("EVAL_LLM_MAX_RETRIES", "2")),
+            "max_tokens": int(os.getenv("EVAL_LLM_MAX_TOKENS", "4096")),
+        },
+        "retrieval": {
+            "top_k": int(os.getenv("EVAL_TOP_K", "5")),
+            "initial_k": int(os.getenv("EVAL_INITIAL_K", "100")),
+        },
+        "data": {
+            "csv_path": os.getenv("EVAL_CSV_PATH", "data/data.csv"),
+            "sample_size": int(os.getenv("EVAL_SAMPLE_SIZE", "0")),
+        },
+        "output": {
+            "dir": os.getenv("EVAL_OUTPUT_DIR", "evaluation/results"),
+        },
+    }
+
+
+def load_csv_data(csv_path: str, sample_size: int = 0) -> tuple[list, list]:
+    questions, ground_truths = [], []
+    
+    with open(csv_path, 'r', encoding='utf-8') as f:
+        for row in csv.DictReader(f):
+            if row.get('question') and row.get('ground_truth'):
+                questions.append(row['question'])
+                ground_truths.append(row['ground_truth'])
+    
+    if sample_size > 0:
+        questions = questions[:sample_size]
+        ground_truths = ground_truths[:sample_size]
+    
+    return questions, ground_truths
+
+
+def init_rag_components(config: dict) -> tuple[RAGGenerator, dict]:
+    emb_cfg = SiliconFlowConfig()
+    qwen_embeddings = QwenEmbeddings(emb_cfg)
+    
+    db_cfg = ChromaConfig()
+    db = ChromaVectorDB(embedder=qwen_embeddings, config=db_cfg)
+    retriever = Retriever(vector_db=db)
+    
+    # RAGGenerator uses Groq with llama-3.1-8b-instant (default)
+    rag_generator = RAGGenerator(retriever=retriever)
+    
+    info = {
+        "gen_model": rag_generator._llm_model,  # Get actual model from RAGGenerator
+        "eval_model": config["llm"]["model"],  
+        "embed_model": emb_cfg.model,
+        "collection": db_cfg.collection_name,
+        "doc_count": db.count(),
+        "embeddings": qwen_embeddings,
+    }
+    
+    return rag_generator, info
+
+
+def generate_answers(
+    rag_generator: RAGGenerator,
+    questions: list,
+    top_k: int = 5,
+    initial_k: int = 100,
+) -> tuple[list, list]:
+    answers, contexts = [], []
+    
+    for i, q in enumerate(questions):
+        try:
+            result = rag_generator.generate(q, k=top_k, initial_k=initial_k)
+            # Strip <think>...</think> tags from answer
+            answer = strip_thinking(result["answer"])
+            answers.append(answer)
+            contexts.append(result["contexts"])
+        except Exception as e:
+            print(f"  Error at {i+1}: {e}")
+            answers.append("Không thể trả lời.")
+            contexts.append([])
+        print(f"  [{i+1}/{len(questions)}] Done")
+    
+    return answers, contexts
+
+
+def save_eval_report(
+    output_dir: Path,
+    eval_type: str,
+    questions: list,
+    answers: list,
+    ground_truths: list,
+    contexts: list,
+    scores_per_sample: list,
+    avg_scores: dict,
+    config: dict,
+) -> Path:
+    """Save evaluation report to JSON."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    json_path = output_dir / f"{eval_type}_eval_{timestamp}.json"
+    
+    data = {
+        "timestamp": timestamp,
+        "eval_type": eval_type,
+        "config": config,
+        "avg_scores": avg_scores,
+        "samples": [
+            {
+                "idx": i + 1,
+                "question": q,
+                "answer": a,
+                "ground_truth": gt[0] if isinstance(gt, list) else gt,
+                "contexts": ctx,
+                "scores": scores,
+            }
+            for i, (q, a, gt, ctx, scores) in enumerate(
+                zip(questions, answers, ground_truths, contexts, scores_per_sample)
+            )
+        ],
+    }
+    
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    print(f" Saved: {json_path}")
+    return json_path
+
+
+def print_scores(title: str, scores: dict, metrics: list | None = None):
+    """Print scores with progress bar."""
+    import math
+    print(f"\n[{title}]")
+    
+    metrics = metrics or list(scores.keys())
+    for metric in metrics:
+        if metric not in scores:
+            print(f"  {metric:25} [N/A]")
+            continue
+        
+        score = float(scores[metric])
+        if math.isnan(score):
+            print(f"  {metric:25} [FAILED - NaN]")
+        else:
+            bar = "#" * int(score * 20) + "-" * (20 - int(score * 20))
+            print(f"  {metric:25} [{bar}] {score:.4f}")

evaluation/ragas_eval.py

@@ -2,358 +2,110 @@ from __future__ import annotations
 import os
 import sys
 import json
-import csv
 from pathlib import Path
 from datetime import datetime
+from typing import Optional
 from dotenv import find_dotenv, load_dotenv
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 load_dotenv(find_dotenv(usecwd=True))
+
 from datasets import Dataset
-from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
 from ragas import evaluate
 from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall
 from ragas.llms import LangchainLLMWrapper
 from ragas.embeddings import LangchainEmbeddingsWrapper
 from ragas.run_config import RunConfig
-from core.embeddings.embedding_model import SiliconFlowConfig, QwenEmbeddings
-from core.embeddings.vector_store import ChromaConfig, ChromaVectorDB
-from core.embeddings.retrival import Retriever
-from utils.helpers import read_yaml
-from rouge_score import rouge_scorer
-
 
-def load_config():
-    cfg_path = REPO_ROOT / "config" / "evaluation.yaml"
-    return read_yaml(cfg_path)
+from evaluation.eval_utils import load_config, load_csv_data, init_rag_components, generate_answers
 
 
-def create_dataset_from_csv(csv_path: str, sample_size: int = 0) -> tuple:
-    """Load test data và tạo RAGAS dataset."""
-    questions = []
-    ground_truths = []
+def run_ragas_evaluation(sample_size: int = 10, output_dir: Optional[str] = None) -> dict:
+    config = load_config()
+    out_path = Path(output_dir) if output_dir else REPO_ROOT / config["output"]["dir"]
     
-    with open(csv_path, 'r', encoding='utf-8') as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            if row.get('question') and row.get('ground_truth'):
-                questions.append(row['question'])
-                ground_truths.append([row['ground_truth']])  # RAGAS expects list
+    # Init components
+    rag_gen, info = init_rag_components(config)
     
-    if sample_size > 0:
-        questions = questions[:sample_size]
-        ground_truths = ground_truths[:sample_size]
+    # LLM for RAGAS evaluation
+    api_key = os.getenv("SILICONFLOW_API_KEY", "")
+    if not api_key:
+        raise ValueError("Missing SILICONFLOW_API_KEY")
+    
+    evaluator_llm = LangchainLLMWrapper(ChatOpenAI(
+        model=config["llm"]["model"],
+        api_key=lambda: api_key,  # type: ignore
+        base_url="https://api.siliconflow.com/v1",
+        temperature=config["llm"]["temperature"],
+    ))
+    evaluator_embeddings = LangchainEmbeddingsWrapper(info["embeddings"])
+    
+    # Load data & generate answers
+    questions, ground_truths = load_csv_data(
+        str(REPO_ROOT / config["data"]["csv_path"]),
+        sample_size or config["data"]["sample_size"]
+    )
+    answers, contexts = generate_answers(
+        rag_gen, questions,
+        config["retrieval"]["top_k"],
+        config["retrieval"]["initial_k"]
+    )
     
-    dataset = Dataset.from_dict({
+    # Run RAGAS
+    ragas_dataset = Dataset.from_dict({
         "question": questions,
+        "answer": answers,
+        "contexts": contexts,
         "ground_truth": ground_truths,
     })
     
-    return dataset, questions, ground_truths
-
-
-def calculate_rouge_scores(answers: list, ground_truths: list) -> tuple:
-    """Tính ROUGE-1, ROUGE-2, ROUGE-L scores cho từng sample và trung bình."""
-    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=False)
-    
-    per_sample_scores = []
-    
-    for answer, gt_list in zip(answers, ground_truths):
-        gt = gt_list[0] if isinstance(gt_list, list) else gt_list
-        if not answer.strip() or not gt.strip():
-            per_sample_scores.append({"rouge1": 0.0, "rouge2": 0.0, "rougeL": 0.0})
-            continue
-        
-        scores = scorer.score(gt, answer)
-        per_sample_scores.append({
-            "rouge1": scores['rouge1'].fmeasure,
-            "rouge2": scores['rouge2'].fmeasure,
-            "rougeL": scores['rougeL'].fmeasure,
-        })
-    
-    # Tính trung bình
-    avg_scores = {
-        "rouge1": sum(s["rouge1"] for s in per_sample_scores) / len(per_sample_scores) if per_sample_scores else 0.0,
-        "rouge2": sum(s["rouge2"] for s in per_sample_scores) / len(per_sample_scores) if per_sample_scores else 0.0,
-        "rougeL": sum(s["rougeL"] for s in per_sample_scores) / len(per_sample_scores) if per_sample_scores else 0.0,
-    }
+    results = evaluate(
+        dataset=ragas_dataset,
+        metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
+        llm=evaluator_llm,
+        embeddings=evaluator_embeddings,
+        raise_exceptions=False,
+        run_config=RunConfig(max_workers=2, timeout=300),  # Reduced workers, increased timeout
+    )
     
-    return avg_scores, per_sample_scores
-
-
-def save_detailed_report(
-    output_dir: Path,
-    questions: list,
-    answers: list,
-    ground_truths: list,
-    contexts: list,
-    ragas_results,
-    rouge_per_sample: list,
-    avg_scores: dict,
-    config: dict,
-):
-    """Lưu báo cáo chi tiết từng câu hỏi."""
+    # Save JSON
+    out_path.mkdir(parents=True, exist_ok=True)
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    # 1. Lưu CSV chi tiết từng câu
-    csv_path = output_dir / f"eval_details_{timestamp}.csv"
-    with open(csv_path, 'w', encoding='utf-8', newline='') as f:
-        writer = csv.writer(f)
-        writer.writerow([
-            "idx", "question", "answer", "ground_truth", 
-            "contexts_count", "rouge1", "rouge2", "rougeL"
-        ])
-        
-        for i, (q, a, gt, ctx, rouge) in enumerate(zip(
-            questions, answers, ground_truths, contexts, rouge_per_sample
-        )):
-            gt_str = gt[0] if isinstance(gt, list) else gt
-            writer.writerow([
-                i + 1,
-                q[:200],  # Truncate for readability
-                a[:200],
-                gt_str[:200],
-                len(ctx),
-                f"{rouge['rouge1']:.4f}",
-                f"{rouge['rouge2']:.4f}",
-                f"{rouge['rougeL']:.4f}",
-            ])
-    
-    print(f" CSV details: {csv_path}")
-    
-    # 2. Lưu JSON đầy đủ
-    json_path = output_dir / f"eval_full_{timestamp}.json"
-    full_data = {
-        "timestamp": timestamp,
-        "config": config,
-        "avg_scores": avg_scores,
-        "samples": []
-    }
-    
-    for i, (q, a, gt, ctx, rouge) in enumerate(zip(
-        questions, answers, ground_truths, contexts, rouge_per_sample
-    )):
-        full_data["samples"].append({
-            "idx": i + 1,
-            "question": q,
-            "answer": a,
-            "ground_truth": gt[0] if isinstance(gt, list) else gt,
-            "contexts": ctx,
-            "rouge": rouge,
-        })
+    json_path = out_path / f"ragas_{timestamp}.json"
+    
+    # Convert results to dict
+    scores: dict = {}
+    if hasattr(results, "scores"):
+        scores = results.scores  # type: ignore
+    elif hasattr(results, "__getitem__"):
+        for k in ["faithfulness", "answer_relevancy", "context_precision", "context_recall"]:
+            try:
+                scores[k] = float(results[k])  # type: ignore
+            except (KeyError, TypeError):
+                pass
     
     with open(json_path, 'w', encoding='utf-8') as f:
-        json.dump(full_data, f, ensure_ascii=False, indent=2)
-    
-    print(f" JSON full: {json_path}")
-    
-    # 3. Lưu summary scores
-    summary_path = output_dir / f"eval_summary_{timestamp}.json"
-    with open(summary_path, 'w', encoding='utf-8') as f:
         json.dump({
             "timestamp": timestamp,
-            "sample_count": len(questions),
-            "scores": avg_scores,
-            "config": config,
+            "config": {"sample_size": len(questions), **{k: v for k, v in info.items() if k != "embeddings"}},
+            "scores": scores,
+            "samples": [
+                {"question": q, "answer": a, "ground_truth": gt, "contexts": ctx}
+                for q, a, gt, ctx in zip(questions, answers, ground_truths, contexts)
+            ]
         }, f, ensure_ascii=False, indent=2)
     
-    print(f" Summary: {summary_path}")
-    
-    return csv_path, json_path, summary_path
-
-
-def run_ragas_evaluation(sample_size: int = 10, output_dir: str = None):
-    """Main RAGAS evaluation function."""
-    print("=" * 60)
-    print("RAGAS + ROUGE EVALUATION")
-    print("=" * 60)
-    
-    # Load config
-    config = load_config()
-    llm_config = config["llm"]
-    retrieval_config = config["retrieval"]
-    data_config = config["data"]
-    output_config = config.get("output", {})
-    
-    output_dir = Path(output_dir or REPO_ROOT / output_config.get("dir", "evaluation/results"))
-    
-    print(f"\n[Config]")
-    print(f"  LLM: {llm_config['model']}")
-    print(f"  Top-K: {retrieval_config['top_k']}")
-    print(f"  Initial-K: {retrieval_config['initial_k']}")
-    print(f"  Output: {output_dir}")
-    
-    # Initialize LLM
-    api_key = os.getenv("GROQ_API_KEY")
-    if not api_key:
-        raise ValueError("Missing GROQ_API_KEY in .env")
-    
-    chat_groq = ChatGroq(
-        model=llm_config["model"],
-        api_key=api_key,
-        temperature=llm_config["temperature"],
-        timeout=llm_config["timeout"],
-        max_retries=llm_config["max_retries"],
-    )
-    
-    evaluator_llm = LangchainLLMWrapper(chat_groq)
-    print(f"  LLM initialized: {llm_config['model']}")
-    
-    # Initialize Embeddings
-    emb_cfg = SiliconFlowConfig.from_yaml()
-    qwen_embeddings = QwenEmbeddings(emb_cfg)
-    evaluator_embeddings = LangchainEmbeddingsWrapper(qwen_embeddings)
-    print(f"  Embeddings: {emb_cfg.embed_model}")
-    
-    # Initialize Retriever
-    db_cfg = ChromaConfig.from_yaml()
-    db = ChromaVectorDB(embedder=qwen_embeddings, config=db_cfg)
-    retriever = Retriever(vector_db=db)
-    print(f"  Vector DB: {db_cfg.collection_name} ({db.count()} docs)")
-    
-    # Load test data
-    csv_path = str(REPO_ROOT / data_config["csv_path"])
-    sample_size = sample_size or data_config.get("sample_size", 10)
-    
-    base_dataset, questions, ground_truths = create_dataset_from_csv(csv_path, sample_size)
-    print(f"\n[Data]")
-    print(f"  Loaded {len(base_dataset)} samples from {csv_path}")
-    
-    # Generate answers and retrieve contexts
-    print("\n[Generating answers and retrieving contexts...]")
-    
-    answers = []
-    contexts = []
-    
-    for i, question in enumerate(questions):
-        # Retrieve contexts
-        results = retriever.search_with_rerank(
-            question, 
-            k=retrieval_config["top_k"], 
-            initial_k=retrieval_config["initial_k"]
-        )
-        ctx_list = [r.get("content", "")[:1000] for r in results if r.get("content")]
-        contexts.append(ctx_list)
-        
-        # Generate answer
-        context_str = "\n\n".join([f"[{j+1}] {ctx[:500]}" for j, ctx in enumerate(ctx_list)])
-        prompt = f"""Bạn là Trợ lý học vụ của HUST. Trả lời ngắn gọn dựa trên CONTEXT.
-
-CONTEXT:
-{context_str}
-
-CÂU HỎI: {question}
-
-TRẢ LỜI:"""
-        
-        try:
-            response = chat_groq.invoke(prompt)
-            answers.append(response.content)
-        except Exception as e:
-            print(f"  Error at {i+1}: {e}")
-            answers.append("Không thể trả lời.")
-        
-        print(f"  [{i+1}/{len(questions)}] Done")
-    
-    ragas_dataset = Dataset.from_dict({
-        "question": questions,                          # Tên cột chuẩn
-        "answer": answers,                              # Tên cột chuẩn
-        "contexts": contexts,                           # Tên cột chuẩn
-        "ground_truth": [gt[0] for gt in ground_truths],  # Tên cột chuẩn - QUAN TRỌNG cho context_recall
-    })
-    
-    metrics = [faithfulness, answer_relevancy, context_precision, context_recall]
-    
-    print(f"\n[Running RAGAS evaluation...]")
-    print(f"  Metrics: faithfulness, answer_relevancy, context_precision, context_recall")
-    print(f"  max_workers=4 (để tránh Groq rate limit)")
-    
-    try:
-        run_config = RunConfig(
-            max_workers=4,  # Giới hạn concurrent requests
-            timeout=120,    # Tăng timeout
-        )
-        
-        results = evaluate(
-            dataset=ragas_dataset,
-            metrics=metrics,
-            llm=evaluator_llm,
-            embeddings=evaluator_embeddings,
-            raise_exceptions=False,
-            run_config=run_config,
-        )
-        
-        # Tính ROUGE scores
-        print("\n[Calculating ROUGE scores...]")
-        rouge_avg, rouge_per_sample = calculate_rouge_scores(answers, ground_truths)
-        
-        # Merge all scores
-        all_avg_scores = dict(results)
-        all_avg_scores.update(rouge_avg)
-        
-        # In kết quả
-        print("\n" + "=" * 60)
-        print("EVALUATION RESULTS")
-        print("=" * 60)
-        
-        print("\n[RAGAS Metrics - LLM-based]")
-        for metric in ["faithfulness", "answer_relevancy", "context_precision", "context_recall"]:
-            if metric in results:
-                score = float(results[metric])
-                bar = "#" * int(score * 20) + "-" * (20 - int(score * 20))
-                print(f"  {metric:25} [{bar}] {score:.4f}")
-        
-        print("\n[ROUGE Metrics - Text-based]")
-        for metric, score in rouge_avg.items():
-            bar = "#" * int(float(score) * 20) + "-" * (20 - int(float(score) * 20))
-            print(f"  {metric:25} [{bar}] {score:.4f}")
-        
-        print("\n" + "=" * 60)
-        
-        # Lưu báo cáo chi tiết
-        print("\n[Saving detailed reports...]")
-        save_detailed_report(
-            output_dir=output_dir,
-            questions=questions,
-            answers=answers,
-            ground_truths=ground_truths,
-            contexts=contexts,
-            ragas_results=results,
-            rouge_per_sample=rouge_per_sample,
-            avg_scores=all_avg_scores,
-            config={
-                "llm_model": llm_config["model"],
-                "embed_model": emb_cfg.embed_model,
-                "top_k": retrieval_config["top_k"],
-                "initial_k": retrieval_config["initial_k"],
-                "sample_size": len(questions),
-            },
-        )
-        
-        print("\n Evaluation complete!")
-        
-        return all_avg_scores
-        
-    except Exception as e:
-        print(f"\nRAGAS evaluation error: {e}")
-        print("\nTroubleshooting:")
-        print("1. pip install ragas --upgrade")
-        print("2. Check Groq API key and rate limits")
-        print("3. Try reducing --samples")
-        import traceback
-        traceback.print_exc()
-        return None
+    print(f"Saved: {json_path}")
+    return scores
 
 
 if __name__ == "__main__":
     import argparse
-    
-    parser = argparse.ArgumentParser(description="RAGAS + ROUGE Evaluation")
-    parser.add_argument("--samples", type=int, default=10, help="Number of samples")
-    parser.add_argument("--output", type=str, default=None, help="Output directory")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--samples", type=int, default=10)
+    parser.add_argument("--output", type=str, default=None)
     args = parser.parse_args()
-    
-    run_ragas_evaluation(sample_size=args.samples, output_dir=args.output)
+    run_ragas_evaluation(args.samples, args.output)

evaluation/results/ragas_20260103_223452.json

@@ -0,0 +1,51 @@
+{
+  "timestamp": "20260103_223452",
+  "config": {
+    "sample_size": 2,
+    "gen_model": "qwen/qwen3-32b",
+    "eval_model": "nex-agi/DeepSeek-V3.1-Nex-N1",
+    "embed_model": "Qwen/Qwen3-Embedding-4B",
+    "collection": "hust_rag_collection",
+    "doc_count": 1908
+  },
+  "scores": [
+    {
+      "faithfulness": 0.75,
+      "answer_relevancy": 0.5568355005961533,
+      "context_precision": 0.99999999995,
+      "context_recall": 1.0
+    },
+    {
+      "faithfulness": 1.0,
+      "answer_relevancy": 0.7365395710155277,
+      "context_precision": 0.99999999998,
+      "context_recall": 1.0
+    }
+  ],
+  "samples": [
+    {
+      "question": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng dựa trên những cơ sở nào?",
+      "answer": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử năm 2009, kết hợp với sự tham khảo chương trình đào tạo ngành Cơ điện tử của các trường đại học nổi tiếng như Stanford, Chico (Mỹ), Sibaura (Nhật Bản), Đại học Quốc gia Đài Loan (NTU)... và đã được kiểm định theo tiêu chuẩn AUN-QA năm 2017. \n\nNguồn: [TÀI LIỆU 1]",
+      "ground_truth": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình năm 2009, kết hợp tham khảo chương trình đào tạo của các trường đại học nổi tiếng trên thế giới như Stanford, Chico (Hoa Kỳ), Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU), đồng thời được kiểm định theo tiêu chuẩn AUN-QA năm 2017.",
+      "contexts": [
+        "Chương trình đào tạo ngành Cơ điện tử hiện nay được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử năm 2009 kết hợp với sự tham khảo chương trình đào tạo ngành Cơ điện tử của các trường đại học nổi tiếng trên thế giới như Stanford, Chico (Koa Kỳ), Sibaura (Nhật Bản), Đại học Quốc gia Đài Loan (NTU)…; Chương trình được kiểm định theo tiêu chuẩn AUN -QA năm 2017;\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến nghiên cứu thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành các hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.",
+        "Chương trình tiên tiến Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử của Trường Đại học Chico (Mỹ) kết hợp với sự tham khảo chương trình đào tạo của Đại học Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU). Chương trình đào tạo đã được kiểm định theo tiêu chuẩn AUN -QA năm 2017.\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.\nNgôn ngữ đào tạo chính: Tiếng Anh.",
+        "Chương trình đào tạo được xây và dựng phát triển theo các chương trình đào tạo của Mỹ phù hợp với thực tiễn Việt Nam. Sinh viên có thể chọn 1 trong hai hướng: Kỹ thuật điều khiển và tự động hóa hoặc Hệ thống điện.\n\nTheo học chương trình tiên tiến Kỹ thuật điều khiển -Tự động hóa và Hệ thống điện Lý thuyết mạch điện – – điện tử, sinh viên được trang bị kiến thức về: Kỹ thuật đo lường và các hệ thống cảm biến thông minh; Các hệ thống mạng truyền thông công nghiệp; Kỹ thuật lập trình các chip vi điều khiển, vi xử lý; Các phương pháp điều khiển truyền thống và hiện đại; Lập trình tự động hóa các dây chuyền sản xuất công nghiệp; Điều khiển điện tử công suất và truyền động điện; Kỹ thuật điều khiển Robot; Kỹ thuật mạng nơron và trí tuệ nhân tạo (AI); Lưới điện và hệ thống điện; Bảo vệ và ổn định hệ thống điện.\n\nNgôn ng��� giảng dạy: Tiếng Anh",
+        "Với chương trình đào tạo linh hoạt, mềm dẻo, được xây dựng trên cơ sở tham khảo chương trình đào tạo ngành Kỹ thuật Y sinh của trường Đại học Wisconsin, một trong các trường có uy tín hàng đầu của Hoa Kỳ về đào tạo kỹ sư Kỹ thuật Y sinh, Chương trình Tiên tiến Kỹ thuật Y sinh cho phép sinh viên tiếp cận được các thành tựu phát triển mới nhất trong lĩnh vực Kỹ thuật Y sinh; cung cấp cho sinh viên các kiến thức kỹ thuật cơ bản và chuyên sâu, phát triển suy luận, nghiên cứu giải quyết các vấn đề chung của khoa học kỹ thuật và Y sinh.\n\nChương trình tiên tiến Kỹ thuật Y sinh được giảng dạy hoàn toàn bằng tiếng Anh và do các giảng viên của trường ĐHBK Hà Nội và các giảng viên nước ngoài tham gia giảng dạy.",
+        "1. Ngành đào tạo (sau đây gọi tắt là ngành) là một lĩnh vực chuyên môn rộng, có mã số trong Danh mục thống kê ngành đào tạo của giáo dục đại học do Bộ GDĐT quản lý 4 .\n2. Chương trình đào tạo (CTĐT) được xây dựng theo đơn vị tín chỉ (TC) và là bản thiết kế cho toàn bộ quá trình đào tạo của một ngành. Chương trình thể hiện rõ trình độ đào tạo; đối tượng đào tạo, điều kiện nhập học và điều kiện tốt nghiệp; mục tiêu đào tạo, chuẩn kiến thức, kỹ năng, mức tự chủ và trách nhiệm của người học khi tốt nghiệp; nội dung (chương trình giảng dạy); kế hoạch đào tạo theo thời gian học tập chuẩn; phương pháp và hình thức đào tạo; cách thức đánh giá kết quả học tập; các điều kiện thực hiện chương trình."
+      ]
+    },
+    {
+      "question": "Sinh viên tốt nghiệp ngành Kỹ thuật Cơ điện tử đạt được những kiến thức chuyên môn gì?",
+      "answer": "Sinh viên tốt nghiệp ngành Kỹ thuật Cơ điện tử đạt được các kiến thức chuyên môn sau:  \n1. Có kiến thức chuyên môn rộng và vững chắc, thích ứng tốt với công việc phù hợp, chú trọng khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành hệ thống/quá trình/sản phẩm Cơ điện tử.  \n2. Có cơ sở kỹ thuật vững chắc và kiến thức chuyên môn sâu, kỹ năng thực hành nghề nghiệp, đủ năng lực thiết kế, chế tạo trong lĩnh vực sản xuất thiết bị, phương tiện động lực, hệ thống và thiết bị năng lượng, điều khiển thủy lực.  \n3. Có năng lực thiết kế, chế tạo trong lĩnh vực sản xuất ô tô, máy động lực, xe chuyên dụng thế hệ mới (ô tô điện, hybrid điện - động cơ đốt trong, pin nhiên liệu, ô tô thông minh) và hình thành ý tưởng, thiết kế, thực hiện, vận hành hệ thống trong doanh nghiệp và xã hội.  \n\nChương trình đào tạo được xây dựng dựa trên sự kết hợp từ các chương trình của Đại học Chico (Mỹ), Đại học Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU), kiểm định theo tiêu chuẩn AUN-QA năm 2017.  \n\nNguồn: [TÀI LIỆU 1], [TÀI LIỆU 2], [TÀI LIỆU 3], [TÀI LIỆU 4], [TÀI LIỆU 5].",
+      "ground_truth": "Sinh viên tốt nghiệp có kiến thức chuyên môn rộng và vững chắc, có khả năng áp dụng kiến thức cơ sở và cốt lõi của ngành Cơ điện tử kết hợp với việc sử dụng các công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống, quá trình và sản phẩm Cơ điện tử.",
+      "contexts": [
+        "Có kiến thức chuyên môn rộng và vững chắc, thích ứng tốt với những công việc phù hợp với ngành, chú trọng khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp khả năng sử dụng công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống/quá trình/sản phẩm cơ điện tử.",
+        "Có kiến thức chuyên môn rộng và vững chắc, thích ứng tốt với những công việc phù hợp với ngành, chú trọng khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp khả năng sử dụng công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống/quá trình/sản phẩm Cơ điện tử.",
+        "Sinh viên có cơ sở kỹ thuật vững chắc và kiến thức chuyên môn sâu, có kỹ năng thực hành nghề nghiệp, đủ năng lực thiết kế, chế tạo trong lĩnh vực sản xuất thiết bị, phương tiện động lực, hệ thống và thiết bị năng lượng, điều khiển thủy lực.",
+        "Chương trình tiên tiến Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử của Trường Đại học Chico (Mỹ) kết hợp với sự tham khảo chương trình đào tạo của Đại học Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU). Chương trình đào tạo đã được kiểm định theo tiêu chuẩn AUN -QA năm 2017.\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.\nNgôn ngữ đào tạo chính: Tiếng Anh.",
+        "Sinh viên tốt nghiệp có kiến thức cơ sở kỹ thuật vững chắc và kiến thức chuyên môn sâu, có kỹ năng thực hành nghề nghiệp, đủ năng lực thiết kế, chế tạo trong lĩnh vực sản xuất ô tô, máy động lực, xe chuyên dụng thế hệ mới như ô tô điện, hybrid điện -động cơ đốt trong, pin nhiên liệu và ô tô thông minh; Có năng lực hình thành ý tưởng, thiết kế, thực hiện và vận hành các hệ thống trong doanh nghiệp và xã hội."
+      ]
+    }
+  ]
+}

evaluation/results/rouge_eval_20260103_222829.json

@@ -0,0 +1,54 @@
+{
+  "timestamp": "20260103_222829",
+  "eval_type": "rouge",
+  "config": {
+    "gen_model": "qwen/qwen3-32b",
+    "eval_model": "nex-agi/DeepSeek-V3.1-Nex-N1",
+    "embed_model": "Qwen/Qwen3-Embedding-4B",
+    "collection": "hust_rag_collection",
+    "doc_count": 1908
+  },
+  "avg_scores": {
+    "rouge1": 0.7116580310880829,
+    "rouge2": 0.6484613914373089,
+    "rougeL": 0.6656146961846444
+  },
+  "samples": [
+    {
+      "idx": 1,
+      "question": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng dựa trên những cơ sở nào?",
+      "answer": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử năm 2009, kết hợp với sự tham khảo chương trình đào tạo của các trường đại học nổi tiếng như Stanford, Chico (Mỹ), Sibaura (Nhật Bản), Đại học Quốc gia Đài Loan (NTU)... và đã được kiểm định theo tiêu chuẩn AUN-QA năm 2017. \n\nNguồn: [TÀI LIỆU 1]",
+      "ground_truth": "Chương trình đào tạo ngành Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình năm 2009, kết hợp tham khảo chương trình đào tạo của các trường đại học nổi tiếng trên thế giới như Stanford, Chico (Hoa Kỳ), Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU), đồng thời được kiểm định theo tiêu chuẩn AUN-QA năm 2017.",
+      "contexts": [
+        "Chương trình đào tạo ngành Cơ điện tử hiện nay được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử năm 2009 kết hợp với sự tham khảo chương trình đào tạo ngành Cơ điện tử của các trường đại học nổi tiếng trên thế giới như Stanford, Chico (Koa Kỳ), Sibaura (Nhật Bản), Đại học Quốc gia Đài Loan (NTU)…; Chương trình được kiểm định theo tiêu chuẩn AUN -QA năm 2017;\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến nghiên cứu thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành các hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.",
+        "Chương trình tiên tiến Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử của Trường Đại học Chico (Mỹ) kết hợp với sự tham khảo chương trình đào tạo của Đại học Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU). Chương trình đào tạo đã được kiểm định theo tiêu chuẩn AUN -QA năm 2017.\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.\nNgôn ngữ đào tạo chính: Tiếng Anh.",
+        "Chương trình đào tạo được xây và dựng phát triển theo các chương trình đào tạo của Mỹ phù hợp với thực tiễn Việt Nam. Sinh viên có thể chọn 1 trong hai hướng: Kỹ thuật điều khiển và tự động hóa hoặc Hệ thống điện.\n\nTheo học chương trình tiên tiến Kỹ thuật điều khiển -Tự động hóa và Hệ thống điện Lý thuyết mạch điện – – điện tử, sinh viên được trang bị kiến thức về: Kỹ thuật đo lường và các hệ thống cảm biến thông minh; Các hệ thống mạng truyền thông công nghiệp; Kỹ thuật lập trình các chip vi điều khiển, vi xử lý; Các phương pháp điều khiển truyền thống và hiện đại; Lập trình tự động hóa các dây chuyền sản xuất công nghiệp; Điều khiển điện tử công suất và truyền động điện; Kỹ thuật điều khiển Robot; Kỹ thuật mạng nơron và trí tuệ nhân tạo (AI); Lưới điện và hệ thống điện; Bảo vệ và ổn định hệ thống điện.\n\nNgôn ngữ giảng dạy: Tiếng Anh",
+        "Với chương trình đào tạo linh hoạt, mềm dẻo, được xây dựng trên cơ sở tham khảo chương trình đào tạo ngành Kỹ thuật Y sinh của trường Đại học Wisconsin, một trong các trường có uy tín hàng đầu của Hoa Kỳ về đào tạo kỹ sư Kỹ thuật Y sinh, Chương trình Tiên tiến Kỹ thuật Y sinh cho phép sinh viên tiếp cận được các thành tựu phát triển mới nhất trong lĩnh vực Kỹ thuật Y sinh; cung cấp cho sinh viên các kiến thức kỹ thuật cơ bản và chuyên sâu, phát triển suy luận, nghiên cứu giải quyết các vấn đề chung của khoa học kỹ thuật và Y sinh.\n\nChương trình tiên tiến Kỹ thuật Y sinh được giảng dạy hoàn toàn bằng tiếng Anh và do các giảng viên của trường ĐHBK Hà Nội và các giảng viên nước ngoài tham gia giảng dạy.",
+        "1. Ngành đào tạo (sau đây gọi tắt là ngành) là một lĩnh vực chuyên môn rộng, có mã số trong Danh mục thống kê ngành đào tạo của giáo dục đại học do Bộ GDĐT quản lý 4 .\n2. Chương trình đào tạo (CTĐT) được xây dựng theo đơn vị tín chỉ (TC) và là bản thiết kế cho toàn bộ quá trình đào tạo của một ngành. Chương trình thể hiện rõ trình độ đào tạo; đối tượng đào tạo, điều kiện nhập học và điều kiện tốt nghiệp; mục tiêu đào tạo, chuẩn kiến thức, kỹ năng, mức tự chủ và trách nhiệm của người học khi tốt nghiệp; nội dung (chương trình giảng dạy); kế hoạch đào tạo theo thời gian học tập chuẩn; phương pháp và hình thức đào tạo; cách thức đánh giá kết quả học tập; các điều kiện thực hiện chương trình."
+      ],
+      "scores": {
+        "rouge1": 0.8999999999999999,
+        "rouge2": 0.8073394495412844,
+        "rougeL": 0.8545454545454546
+      }
+    },
+    {
+      "idx": 2,
+      "question": "Sinh viên tốt nghiệp ngành Kỹ thuật Cơ điện tử đạt được những kiến thức chuyên môn gì?",
+      "answer": "Sinh viên tốt nghiệp ngành Kỹ thuật Cơ điện tử đạt được các kiến thức chuyên môn sau:  \n1. Kiến thức cơ sở kỹ thuật vững chắc và chuyên môn sâu, có khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp với công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống/quá trình/sản phẩm Cơ điện tử (Tài liệu 1, 2, 3, 4).  \n2. Năng lực thiết kế, chế tạo trong lĩnh vực sản xuất thiết bị, phương tiện động lực, hệ thống và thiết bị năng lượng, điều khiển thủy lực (Tài liệu 3).  \n3. Khả năng hình thành ý tưởng, thiết kế, thực hiện và vận hành hệ thống trong lĩnh vực sản xuất ô tô, máy động lực, xe chuyên dụng thế hệ mới (ô tô điện, hybrid điện - động cơ đốt trong, pin nhiên liệu, ô tô thông minh) (Tài liệu 5).  \n\nChương trình đào tạo đã được kiểm định theo tiêu chuẩn AUN-QA năm 2017 (Tài liệu 4).",
+      "ground_truth": "Sinh viên tốt nghiệp có kiến thức chuyên môn rộng và vững chắc, có khả năng áp dụng kiến thức cơ sở và cốt lõi của ngành Cơ điện tử kết hợp với việc sử dụng các công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống, quá trình và sản phẩm Cơ điện tử.",
+      "contexts": [
+        "Có kiến thức chuyên môn rộng và vững chắc, thích ứng tốt với những công việc phù hợp với ngành, chú trọng khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp khả năng sử dụng công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống/quá trình/sản phẩm cơ điện tử.",
+        "Có kiến thức chuyên môn rộng và vững chắc, thích ứng tốt với những công việc phù hợp với ngành, chú trọng khả năng áp dụng kiến thức cơ sở và cốt lõi ngành Cơ điện tử kết hợp khả năng sử dụng công cụ hiện đại để nghiên cứu, thiết kế, chế tạo, xây dựng và vận hành các hệ thống/quá trình/sản phẩm Cơ điện tử.",
+        "Sinh viên có cơ sở kỹ thuật vững chắc và kiến thức chuyên môn sâu, có kỹ năng thực hành nghề nghiệp, đủ năng lực thiết kế, chế tạo trong lĩnh vực sản xuất thiết bị, phương tiện động lực, hệ thống và thiết bị năng lượng, điều khiển thủy lực.",
+        "Chương trình tiên tiến Kỹ thuật Cơ điện tử được xây dựng trên cơ sở phát triển chương trình đào tạo ngành Cơ điện tử của Trường Đại học Chico (Mỹ) kết hợp với sự tham khảo chương trình đào tạo của Đại học Sibaura (Nhật Bản) và Đại học Quốc gia Đài Loan (NTU). Chương trình đào tạo đã được kiểm định theo tiêu chuẩn AUN -QA năm 2017.\nSinh viên theo học ngành này sẽ được trang bị các kiến thức cơ sở và chuyên ngành vững chắc, có kỹ năng nghề nghiệp và năng lực nghiên cứu, khả năng làm việc và sáng tạo trong mọi môi trường lao động để giải quyết những vấn đề liên quan đến thiết kế, chế tạo thiết bị, hệ thống cơ điện tử và vận hành hệ thống sản xuất công nghiệp, nhanh chóng thích ứng với môi trường làm việc của cuộc cách mạng công nghiệp 4.0.\nNgôn ngữ đào tạo chính: Tiếng Anh.",
+        "Sinh viên tốt nghiệp có kiến thức cơ sở kỹ thuật vững chắc và kiến thức chuyên môn sâu, có kỹ năng thực hành nghề nghiệp, đủ năng lực thiết kế, chế tạo trong lĩnh vực sản xuất ô tô, máy động lực, xe chuyên dụng thế hệ mới như ô tô điện, hybrid điện -động cơ đốt trong, pin nhiên liệu và ô tô thông minh; Có năng lực hình thành ý tưởng, thiết kế, thực hiện và vận hành các hệ thống trong doanh nghiệp và xã hội."
+      ],
+      "scores": {
+        "rouge1": 0.5233160621761658,
+        "rouge2": 0.4895833333333333,
+        "rougeL": 0.4766839378238343
+      }
+    }
+  ]
+}

evaluation/rouge_eval.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+import argparse
+from pathlib import Path
+from typing import Optional
+
+from rouge_score import rouge_scorer
+
+from evaluation.eval_utils import (
+    REPO_ROOT, load_config, load_csv_data, init_rag_components,
+    generate_answers, save_eval_report, print_scores,
+)
+
+
+def calculate_rouge_scores(answers: list, ground_truths: list) -> tuple[dict, list]:
+    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=False)
+    per_sample = []
+    
+    for answer, gt in zip(answers, ground_truths):
+        gt = gt[0] if isinstance(gt, list) else gt
+        if not answer.strip() or not gt.strip():
+            per_sample.append({"rouge1": 0.0, "rouge2": 0.0, "rougeL": 0.0})
+            continue
+        
+        scores = scorer.score(gt, answer)
+        per_sample.append({k: scores[k].fmeasure for k in ['rouge1', 'rouge2', 'rougeL']})
+    
+    avg = {k: sum(s[k] for s in per_sample) / len(per_sample) for k in ['rouge1', 'rouge2', 'rougeL']} if per_sample else {}
+    return avg, per_sample
+
+
+def run_rouge_evaluation(sample_size: int = 10, output_dir: Optional[str] = None) -> dict:
+    print("=" * 60 + "\nROUGE EVALUATION\n" + "=" * 60)
+    
+    config = load_config()
+    out_path = Path(output_dir) if output_dir else REPO_ROOT / config.get("output", {}).get("dir", "evaluation/results")
+    
+    print("\n[Initializing...]")
+    rag_gen, info = init_rag_components(config)
+    print(f"  Gen LLM: {info['gen_model']}, Embeddings: {info['embed_model']}")
+    print(f"  Vector DB: {info['collection']} ({info['doc_count']} docs)")
+    
+    csv_path = str(REPO_ROOT / config["data"]["csv_path"])
+    sample_size = sample_size or config["data"].get("sample_size", 10)
+    questions, ground_truths = load_csv_data(csv_path, sample_size)
+    print(f"\n[Data] Loaded {len(questions)} samples")
+    
+    print("\n[Generating answers...]")
+    answers, contexts = generate_answers(
+        rag_gen, questions,
+        top_k=config["retrieval"]["top_k"],
+        initial_k=config["retrieval"]["initial_k"],
+    )
+    
+    print("\n[Calculating ROUGE scores...]")
+    avg_scores, per_sample = calculate_rouge_scores(answers, ground_truths)
+    
+    print("\n" + "=" * 60 + "\nROUGE RESULTS\n" + "=" * 60)
+    print_scores("ROUGE Metrics", avg_scores)
+    
+    save_eval_report(
+        out_path, "rouge", questions, answers, ground_truths, contexts,
+        per_sample, avg_scores, {k: v for k, v in info.items() if k != "embeddings"},
+    )
+    
+    print("\n ROUGE Evaluation complete!")
+    return avg_scores
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="ROUGE Evaluation")
+    parser.add_argument("--samples", type=int, default=10, help="Number of samples (0=all)")
+    parser.add_argument("--output", type=str, default=None, help="Output directory")
+    args = parser.parse_args()
+    run_rouge_evaluation(sample_size=args.samples, output_dir=args.output)

requirements.txt

@@ -1,4 +1,5 @@
 langchain
+langchain-openai
 langchain-chroma
 chromadb
 datasets

scripts/rag.py

@@ -37,13 +37,13 @@ def main():
     print("=" * 60)
     
     print("\n[1/4] Initializing embedder...")
-    emb_cfg = EmbeddingConfig.from_yaml()
+    emb_cfg = EmbeddingConfig()
     emb = QwenEmbeddings(emb_cfg)
     print(f"  ✓ Model: {emb_cfg.model}")
     print(f"  ✓ API: {emb_cfg.api_base_url}")
     
     print("\n[2/4] Initializing ChromaDB...")
-    db_cfg = ChromaConfig.from_yaml()
+    db_cfg = ChromaConfig()
     db = ChromaVectorDB(embedder=emb, config=db_cfg)
     old_count = db.count()
     print(f"  ✓ Collection: {db_cfg.collection_name}")

scripts/run_eval.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+import argparse
+import sys
+from pathlib import Path
+from datetime import datetime
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+
+def print_header(mode: str):
+    """Print evaluation header."""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print("\n" + "=" * 70)
+    print(f"{'RAG EVALUATION':^70}")
+    print(f"{'Mode: ' + mode.upper():^70}")
+    print(f"{timestamp:^70}")
+    print("=" * 70)
+
+def run_rouge_only(samples: int, output_dir: str):
+    from evaluation.rouge_eval import run_rouge_evaluation
+    return run_rouge_evaluation(sample_size=samples, output_dir=output_dir)
+
+
+def run_ragas_only(samples: int, output_dir: str):
+    from evaluation.ragas_eval import run_ragas_evaluation
+    return run_ragas_evaluation(sample_size=samples, output_dir=output_dir)
+
+
+def run_all(samples: int, output_dir: str):
+    print("\n" + "-" * 70)
+    print("STEP 1/2: ROUGE EVALUATION")
+    print("-" * 70)
+    rouge_scores = run_rouge_only(samples, output_dir)
+    
+    print("\n" + "-" * 70)
+    print("STEP 2/2: RAGAS EVALUATION")
+    print("-" * 70)
+    ragas_scores = run_ragas_only(samples, output_dir)
+    
+    # Combine and print final summary
+    print("\n" + "=" * 70)
+    print(f"{'FINAL EVALUATION SUMMARY':^70}")
+    print("=" * 70)
+    
+    if rouge_scores:
+        print("\n[ROUGE Metrics - Text-based]")
+        for metric, score in rouge_scores.items():
+            bar = "#" * int(float(score) * 20) + "-" * (20 - int(float(score) * 20))
+            print(f"  {metric:25} [{bar}] {score:.4f}")
+    
+    if ragas_scores:
+        print("\n[RAGAS Metrics - LLM-based]")
+        import math
+        for metric in ["faithfulness", "answer_relevancy", "context_precision", "context_recall"]:
+            if metric in ragas_scores:
+                score = float(ragas_scores[metric])
+                if not math.isnan(score):
+                    bar = "#" * int(score * 20) + "-" * (20 - int(score * 20))
+                    print(f"  {metric:25} [{bar}] {score:.4f}")
+                else:
+                    print(f"  {metric:25} [FAILED]")
+    
+    print("\n" + "=" * 70)
+    print(" All evaluations complete!")
+    
+    return {"rouge": rouge_scores, "ragas": ragas_scores}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="RAG Evaluation Script - Run ROUGE and/or RAGAS metrics",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python evaluation/run_eval.py --mode all --samples 10
+  python evaluation/run_eval.py --mode rouge --samples 20
+  python evaluation/run_eval.py --mode ragas --samples 5
+  python evaluation/run_eval.py --mode all --samples 0  # All samples
+
+Evaluation modes:
+  rouge   - Text-based metrics (ROUGE-1, ROUGE-2, ROUGE-L)
+  ragas   - LLM-based metrics (Faithfulness, Answer Relevancy, etc.)
+  all     - Both ROUGE and RAGAS
+        """
+    )
+    
+    parser.add_argument(
+        "--mode", 
+        type=str, 
+        default="all",
+        choices=["rouge", "ragas", "all"],
+        help="Evaluation mode: rouge, ragas, or all (default: all)"
+    )
+    parser.add_argument(
+        "--samples", 
+        type=int, 
+        default=10,
+        help="Number of samples to evaluate (0 = all samples, default: 10)"
+    )
+    parser.add_argument(
+        "--output", 
+        type=str, 
+        default=None,
+        help="Output directory for results (default: evaluation/results)"
+    )
+    
+    args = parser.parse_args()
+    
+    print_header(args.mode)
+    print(f"\n[Configuration]")
+    print(f"  Mode: {args.mode}")
+    print(f"  Samples: {args.samples if args.samples > 0 else 'ALL'}")
+    print(f"  Output: {args.output or 'evaluation/results'}")
+    
+    if args.mode == "rouge":
+        run_rouge_only(args.samples, args.output)
+    elif args.mode == "ragas":
+        run_ragas_only(args.samples, args.output)
+    else:
+        run_all(args.samples, args.output)
+
+
+if __name__ == "__main__":
+    main()

test/llama.py

@@ -0,0 +1,42 @@
+import os
+from llama_parse import LlamaParse, ResultType
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def test_llamaparse(file_path: str):
+    parser = LlamaParse(
+        result_type=ResultType.MD,  # Định dạng Markdown giúp giữ cấu trúc bảng cực tốt
+        num_workers=4,           # Chạy song song để tăng tốc
+        verbose=True,
+        language="vi"            # Cấu hình ngôn ngữ tiếng Việt
+    )
+
+    print(f"--- Đang bắt đầu xử lý file: {file_path} ---")
+    
+    # Thực hiện trích xuất dữ liệu
+    documents = parser.load_data(file_path)
+
+    if documents:
+        # In thử 1000 ký tự đầu tiên để kiểm tra
+        print("\n--- Kết quả trích xuất mẫu ---")
+        print(documents[0].text[:1000])
+
+        # Lưu kết quả ra file .md để bạn xem cấu trúc bảng có bị lệch không
+        output_name = "data/parsed_llama_result.md"
+        with open(output_name, "w", encoding="utf-8") as f:
+            for doc in documents:
+                f.write(doc.text + "\n\n")
+        print(f"\n--- Đã lưu toàn bộ nội dung vào: {output_name} ---")
+    else:
+        print("Lỗi: Không tìm thấy nội dung trong file.")
+
+if __name__ == "__main__":
+    # Thay đường dẫn đến file PDF quy chế của bạn vào đây
+    PATH_TO_PDF = "data/data_raw/quyet_dinh/quy-dinh-chuan-ngoai-ngu-2021.pdf" 
+    
+    api_key = os.getenv("LLAMA_CLOUD_API_KEY")
+    if not api_key:
+        print("Lỗi: Bạn chưa cấu hình LLAMA_CLOUD_API_KEY trong file .env")
+    else:
+        test_llamaparse(PATH_TO_PDF)

test/test_chunk.py

@@ -1,37 +1,47 @@
 import sys
 sys.path.insert(0, "/home/bahung/DoAn")
 
-from core.embeddings.chunk import chunk_markdown_file, ChunkConfig
+from core.embeddings.chunk import chunk_markdown_file
 
-test_file = "data/data_process/quy_che/QCDT_2025_5445_QD-DHBK.md"
+test_file = "data/docling_output/chuong_trinh_dao_tao/1.1. Kỹ thuật Cơ điện tử.md"
 
 print("=" * 70)
-print(f"📄 File: {test_file}")
+print(f" File: {test_file}")
 print("=" * 70)
 
-chunks = chunk_markdown_file(test_file, config=ChunkConfig())
+# Now returns List[BaseNode] instead of List[Dict]
+nodes = chunk_markdown_file(test_file)
 
-print(f"\n📊 Total chunks: {len(chunks)}\n")
+print(f"\n Total nodes: {len(nodes)}\n")
 
-for i, chunk in enumerate(chunks):
+for i, node in enumerate(nodes):
+    content = node.get_content()
+    metadata = node.metadata
+    
     print(f"\n{'─' * 70}")
-    print(f"🔹 CHUNK #{i}")
-    print(f"   Section: {chunk['metadata'].get('section', 'N/A')}")
-    print(f"   Length: {len(chunk['content'])} chars")
+    print(f" NODE #{i}")
+    print(f"   Type: {type(node).__name__}")
+    print(f"   Length: {len(content)} chars")
+    if metadata:
+        print(f"   Metadata: {metadata}")
     print(f"{'─' * 70}")
-    content_preview = chunk['content'][:200]
-    if len(chunk['content']) > 200:
+    content_preview = content[:200]
+    if len(content) > 200:
         content_preview += "..."
     print(content_preview)
 
 with open("test_chunk.md", "w", encoding="utf-8") as f:
-    for i, chunk in enumerate(chunks):
-        f.write(f"# CHUNK {i}\n")
+    for i, node in enumerate(nodes):
+        content = node.get_content()
+        metadata = node.metadata
+        
+        f.write(f"# NODE {i}\n")
+        f.write(f"**Type:** {type(node).__name__}\n\n")
         f.write("**Metadata:**\n")
-        for key, value in chunk['metadata'].items():
+        for key, value in metadata.items():
             f.write(f"- {key}: {value}\n")
         f.write("\n**Content:**\n")
-        f.write(chunk['content'])
+        f.write(content)
         f.write("\n\n---\n\n")
 
-print("\n✅ Done")
+print("\n Done")