fix bug

core/data_processor.py

@@ -5,7 +5,6 @@ import logging
 import datetime
 from typing import Dict, List, Any, Union, Tuple
 
-# Cấu hình logging
 logger = logging.getLogger(__name__)
 
 class DataProcessor:
@@ -26,18 +25,14 @@ class DataProcessor:
         """Tải tất cả dữ liệu từ các thư mục con trong data"""
         logger.info(f"Đang tải dữ liệu từ thư mục: {self.data_dir}")
         
-        # Quét qua tất cả thư mục trong data
         for item in os.listdir(self.data_dir):
             folder_path = os.path.join(self.data_dir, item)
             
-            # Kiểm tra xem đây có phải là thư mục không
             if os.path.isdir(folder_path):
                 metadata_file = os.path.join(folder_path, "metadata.json")
                 
-                # Nếu có file metadata.json
                 if os.path.exists(metadata_file):
                     try:
-                        # Tải metadata
                         with open(metadata_file, 'r', encoding='utf-8') as f:
                             content = f.read()
                             if not content.strip():
@@ -45,7 +40,6 @@ class DataProcessor:
                                 continue
                             folder_metadata = json.loads(content)
                         
-                        # Xác định ID của thư mục
                         folder_id = None
                         if "bai_info" in folder_metadata:
                             folder_id = folder_metadata["bai_info"].get("id", item)
@@ -54,10 +48,8 @@ class DataProcessor:
                         else:
                             folder_id = item
                         
-                        # Lưu metadata vào từ điển
                         self.metadata[folder_id] = folder_metadata
                         
-                        # Tải tất cả chunks, tables và figures
                         self._load_content_from_metadata(folder_path, folder_metadata)
                         
                         logger.info(f"Đã tải xong thư mục: {item}")
@@ -68,33 +60,28 @@ class DataProcessor:
 
     def _load_content_from_metadata(self, folder_path: str, folder_metadata: Dict[str, Any]):
         """Tải nội dung chunks, tables và figures từ metadata"""
-        # Tải chunks
         for chunk_meta in folder_metadata.get("chunks", []):
             chunk_id = chunk_meta.get("id")
             chunk_path = os.path.join(folder_path, "chunks", f"{chunk_id}.md")
             
-            chunk_data = chunk_meta.copy()  # Sao chép metadata của chunk
+            chunk_data = chunk_meta.copy()
             
-            # Thêm nội dung từ file markdown nếu tồn tại
             if os.path.exists(chunk_path):
                 with open(chunk_path, 'r', encoding='utf-8') as f:
                     content = f.read()
                 chunk_data["content"] = self._extract_content_from_markdown(content)
             else:
-                # Nếu không tìm thấy file, tạo nội dung mẫu và ghi log ở debug level
                 chunk_data["content"] = f"Nội dung cho {chunk_id} không tìm thấy."
                 logger.debug(f"Không tìm thấy file chunk: {chunk_path}")
             
             self.chunks.append(chunk_data)
         
-        # Tải tables
         for table_meta in folder_metadata.get("tables", []):
             table_id = table_meta.get("id")
             table_path = os.path.join(folder_path, "tables", f"{table_id}.md")
             
             table_data = table_meta.copy()
             
-            # Thêm nội dung từ file markdown nếu tồn tại
             if os.path.exists(table_path):
                 with open(table_path, 'r', encoding='utf-8') as f:
                     content = f.read()
@@ -105,13 +92,11 @@ class DataProcessor:
             
             self.tables.append(table_data)
         
-        # Tải figures
         for figure_meta in folder_metadata.get("figures", []):
             figure_id = figure_meta.get("id")
             figure_path = os.path.join(folder_path, "figures", f"{figure_id}.md")
             figure_data = figure_meta.copy()
             
-            # Thêm nội dung từ file markdown nếu tồn tại
             content_loaded = False
             if os.path.exists(figure_path):
                 with open(figure_path, 'r', encoding='utf-8') as f:
@@ -119,7 +104,6 @@ class DataProcessor:
                 figure_data["content"] = self._extract_content_from_markdown(content)
                 content_loaded = True
             
-            # Thêm đường dẫn đến file hình ảnh nếu có
             image_path = None
             image_extensions = ['.png', '.jpg', '.jpeg', '.gif', '.svg']
             for ext in image_extensions:
@@ -130,18 +114,15 @@ class DataProcessor:
             
             if image_path:
                 figure_data["image_path"] = image_path
-                # Tạo nội dung mặc định nếu không có file markdown
                 if not content_loaded:
                     figure_caption = figure_meta.get("title", f"Hình {figure_id}")
                     figure_data["content"] = f"![{figure_caption}]({image_path})"
             elif not content_loaded:
-                # Nếu không có cả file markdown và file hình
                 figure_data["content"] = f"Hình {figure_id} không tìm thấy."
                 logger.debug(f"Không tìm thấy file hình cho {figure_id}")
             
             self.figures.append(figure_data)
         
-        # Tải data_files (trường hợp phụ lục)
         if "data_files" in folder_metadata:
             for data_file_meta in folder_metadata.get("data_files", []):
                 data_id = data_file_meta.get("id")
@@ -149,16 +130,13 @@ class DataProcessor:
                 
                 data_file = data_file_meta.copy()
                 
-                # Thêm nội dung từ file markdown nếu tồn tại
                 if os.path.exists(data_path):
                     with open(data_path, 'r', encoding='utf-8') as f:
                         content = f.read()
                     data_file["content"] = self._extract_content_from_markdown(content)
                     
-                    # Xác định loại nội dung
                     content_type = data_file.get("content_type", "table")
                     
-                    # Thêm vào danh sách phù hợp dựa trên loại nội dung
                     if content_type == "table":
                         self.tables.append(data_file)
                     elif content_type == "text":
@@ -173,7 +151,6 @@ class DataProcessor:
     
     def _extract_content_from_markdown(self, md_content: str) -> str:
         """Trích xuất nội dung từ markdown, bỏ qua phần frontmatter"""
-        # Tách frontmatter (nằm giữa "---")
         if md_content.startswith("---"):
             parts = md_content.split("---", 2)
             if len(parts) >= 3:
@@ -214,26 +191,23 @@ class DataProcessor:
         return None
     
     def find_items_by_age(self, age: int) -> Dict[str, List[Dict[str, Any]]]:
-        """Tìm các items (chunks, tables, figures) liên quan đến độ tuổi của người dùng"""
+        """Tìm các items liên quan đến độ tuổi của người dùng"""
         relevant_chunks = []
         relevant_tables = []
         relevant_figures = []
         
-        # Lọc chunks
         for chunk in self.chunks:
-            age_range = chunk.get("age_range", [0, 100])
+            age_range = chunk.get("age_range", [0, 19])
             if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
                 relevant_chunks.append(chunk)
         
-        # Lọc tables
         for table in self.tables:
-            age_range = table.get("age_range", [0, 100])
+            age_range = table.get("age_range", [0, 19])
             if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
                 relevant_tables.append(table)
         
-        # Lọc figures
         for figure in self.figures:
-            age_range = figure.get("age_range", [0, 100])
+            age_range = figure.get("age_range", [0, 19])
             if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
                 relevant_figures.append(figure)
         
@@ -249,7 +223,6 @@ class DataProcessor:
         related_tables = []
         related_figures = []
         
-        # Tìm item gốc
         source_item = None
         for item in self.chunks + self.tables + self.figures:
             if item.get("id") == item_id:
@@ -263,24 +236,19 @@ class DataProcessor:
                 "figures": []
             }
         
-        # Lấy danh sách IDs của các items liên quan
         related_ids = source_item.get("related_chunks", [])
         
-        # Tìm các items liên quan
         for related_id in related_ids:
-            # Tìm trong chunks
             for chunk in self.chunks:
                 if chunk.get("id") == related_id:
                     related_chunks.append(chunk)
                     break
             
-            # Tìm trong tables
             for table in self.tables:
                 if table.get("id") == related_id:
                     related_tables.append(table)
                     break
             
-            # Tìm trong figures
             for figure in self.figures:
                 if figure.get("id") == related_id:
                     related_figures.append(figure)
@@ -294,9 +262,7 @@ class DataProcessor:
     
     def preprocess_query(self, query: str) -> str:
         """Tiền xử lý câu truy vấn"""
-        # Loại bỏ ký tự đặc biệt
         query = re.sub(r'[^\w\s\d]', ' ', query)
-        # Loại bỏ khoảng trắng thừa
         query = re.sub(r'\s+', ' ', query).strip()
         return query
     
@@ -310,10 +276,8 @@ class DataProcessor:
             content = item.get("content", "")
             content_type = item.get("content_type", "text")
             
-            # Nếu là bảng, thêm tiêu đề "B��ng:"
             if content_type == "table":
                 title = f"Bảng: {title}"
-            # Nếu là hình, thêm tiêu đề "Hình:"
             elif content_type == "figure":
                 title = f"Hình: {title}"
             
@@ -326,9 +290,7 @@ class DataProcessor:
         """Chuẩn bị dữ liệu cho việc nhúng (embedding)"""
         all_items = []
         
-        # Thêm chunks
         for chunk in self.chunks:
-            # Tìm chapter từ chunk ID
             chunk_id = chunk.get("id", "")
             chapter = "unknown"
             if chunk_id.startswith("bai1_"):
@@ -346,13 +308,11 @@ class DataProcessor:
             if chunk.get("title"):
                 content = f"Tiêu đề: {chunk.get('title')}\n\nNội dung: {content}"
             
-            # Xử lý age_range - convert list thành string và tách thành min/max
-            age_range = chunk.get("age_range", [0, 100])
+            age_range = chunk.get("age_range", [0, 19])
             age_min = age_range[0] if len(age_range) > 0 else 0
-            age_max = age_range[1] if len(age_range) > 1 else 100
+            age_max = age_range[1] if len(age_range) > 1 else 19
             age_range_str = f"{age_min}-{age_max}"
             
-            # Xử lý related_chunks - convert list thành string
             related_chunks = chunk.get("related_chunks", [])
             related_chunks_str = ",".join(related_chunks) if related_chunks else ""
             
@@ -379,9 +339,7 @@ class DataProcessor:
             }
             all_items.append(embedding_item)
         
-        # Thêm tables
         for table in self.tables:
-            # Tìm chapter từ table ID
             table_id = table.get("id", "")
             chapter = "unknown"
             if table_id.startswith("bai1_"):
@@ -399,13 +357,11 @@ class DataProcessor:
             if table.get("title"):
                 content = f"Bảng: {table.get('title')}\n\nNội dung: {content}"
             
-            # Xử lý age_range
-            age_range = table.get("age_range", [0, 100])
+            age_range = table.get("age_range", [0, 19])
             age_min = age_range[0] if len(age_range) > 0 else 0
-            age_max = age_range[1] if len(age_range) > 1 else 100
+            age_max = age_range[1] if len(age_range) > 1 else 19
             age_range_str = f"{age_min}-{age_max}"
             
-            # Xử lý related_chunks và table_columns
             related_chunks = table.get("related_chunks", [])
             related_chunks_str = ",".join(related_chunks) if related_chunks else ""
             table_columns = table.get("table_columns", [])
@@ -433,9 +389,7 @@ class DataProcessor:
             }
             all_items.append(embedding_item)
         
-        # Thêm figures
         for figure in self.figures:
-            # Tìm chapter từ figure ID
             figure_id = figure.get("id", "")
             chapter = "unknown"
             if figure_id.startswith("bai1_"):
@@ -453,13 +407,11 @@ class DataProcessor:
             if figure.get("title"):
                 content = f"Hình: {figure.get('title')}\n\nMô tả: {content}"
             
-            # Xử lý age_range
             age_range = figure.get("age_range", [0, 100])
             age_min = age_range[0] if len(age_range) > 0 else 0
             age_max = age_range[1] if len(age_range) > 1 else 100
             age_range_str = f"{age_min}-{age_max}"
             
-            # Xử lý related_chunks
             related_chunks = figure.get("related_chunks", [])
             related_chunks_str = ",".join(related_chunks) if related_chunks else ""
             
@@ -509,16 +461,14 @@ class DataProcessor:
             "by_age": {}
         }
         
-        # Thống kê theo bài
         for item in os.listdir(self.data_dir):
             if os.path.isdir(os.path.join(self.data_dir, item)):
                 item_stats = self.count_items_by_prefix(f"{item}_")
                 stats["by_lesson"][item] = item_stats
         
-        # Thống kê theo độ tuổi
         age_ranges = {}
         for chunk in self.chunks + self.tables + self.figures:
-            age_range = chunk.get("age_range", [0, 100])
+            age_range = chunk.get("age_range", [0, 19])
             if len(age_range) == 2:
                 range_key = f"{age_range[0]}-{age_range[1]}"
                 if range_key not in age_ranges:

core/embedding_model.py

@@ -6,16 +6,12 @@ import uuid
 import os
 from config import EMBEDDING_MODEL, CHROMA_PERSIST_DIRECTORY, COLLECTION_NAME
 
-# Cấu hình logging
 logger = logging.getLogger(__name__)
 
-# Global instance để implement singleton pattern
 _embedding_model_instance = None
 
 def get_embedding_model():
-    """
-    Singleton pattern để đảm bảo chỉ có một instance của EmbeddingModel
-    """
+    """Kiểm tra và khởi tạo embedding đảm bảo chỉ khởi tạo một lần"""
     global _embedding_model_instance
     if _embedding_model_instance is None:
         logger.info("Khởi tạo EmbeddingModel instance lần đầu")
@@ -40,52 +36,199 @@ class EmbeddingModel:
             self.model = SentenceTransformer(EMBEDDING_MODEL, cache_folder=cache_dir, trust_remote_code=True)
             logger.info("Đã tải sentence transformer model với cache folder explicit")
         
+        # SỬA: Khai báo biến persist_directory local để tránh lỗi scope
+        persist_directory = CHROMA_PERSIST_DIRECTORY
+        
         # Đảm bảo thư mục ChromaDB tồn tại và có quyền ghi
         try:
-            os.makedirs(CHROMA_PERSIST_DIRECTORY, exist_ok=True)
+            os.makedirs(persist_directory, exist_ok=True)
             # Test ghi file để kiểm tra permission
-            test_file = os.path.join(CHROMA_PERSIST_DIRECTORY, 'test_permission.tmp')
+            test_file = os.path.join(persist_directory, 'test_permission.tmp')
             with open(test_file, 'w') as f:
                 f.write('test')
             os.remove(test_file)
-            logger.info(f"Thư mục ChromaDB đã sẵn sàng: {CHROMA_PERSIST_DIRECTORY}")
+            logger.info(f"Thư mục ChromaDB đã sẵn sàng: {persist_directory}")
         except Exception as e:
             logger.error(f"Lỗi tạo/kiểm tra thư mục ChromaDB: {e}")
             # Fallback to /tmp directory
             import tempfile
-            CHROMA_PERSIST_DIRECTORY = os.path.join(tempfile.gettempdir(), 'chroma_db')
-            os.makedirs(CHROMA_PERSIST_DIRECTORY, exist_ok=True)
-            logger.warning(f"Sử dụng thư mục tạm thời: {CHROMA_PERSIST_DIRECTORY}")
+            persist_directory = os.path.join(tempfile.gettempdir(), 'chroma_db')
+            os.makedirs(persist_directory, exist_ok=True)
+            logger.warning(f"Sử dụng thư mục tạm thời: {persist_directory}")
         
         # Khởi tạo ChromaDB client với persistent storage
         try:
             self.chroma_client = chromadb.PersistentClient(
-                path=CHROMA_PERSIST_DIRECTORY,
+                path=persist_directory,
                 settings=Settings(
                     anonymized_telemetry=False,
                     allow_reset=True
                 )
             )
-            logger.info(f"Đã kết nối ChromaDB tại: {CHROMA_PERSIST_DIRECTORY}")
+            logger.info(f"Đã kết nối ChromaDB tại: {persist_directory}")
         except Exception as e:
             logger.error(f"Lỗi kết nối ChromaDB: {e}")
             # Fallback to in-memory client
             logger.warning("Fallback to in-memory ChromaDB client")
             self.chroma_client = chromadb.Client()
         
-        # Lấy hoặc tạo collection
+        # Lấy hoặc tạo collection với cosine similarity
         try:
             self.collection = self.chroma_client.get_collection(name=COLLECTION_NAME)
             logger.info(f"Đã kết nối collection '{COLLECTION_NAME}' với {self.collection.count()} items")
         except Exception:
-            logger.warning(f"Collection '{COLLECTION_NAME}' không tồn tại, tạo mới...")
-            self.collection = self.chroma_client.create_collection(name=COLLECTION_NAME)
-            logger.info(f"Đã tạo collection mới: {COLLECTION_NAME}")
+            logger.info(f"Collection '{COLLECTION_NAME}' không tồn tại, tạo mới với cosine similarity...")
+            self.collection = self.chroma_client.create_collection(
+                name=COLLECTION_NAME,
+                metadata={
+                    "hnsw:space": "cosine",  # Cosine distance  
+                    "hnsw:M": 16,           # Optimize for accuracy
+                    "hnsw:construction_ef": 100
+                }
+            )
+            logger.info(f"Đã tạo collection mới với cosine similarity: {COLLECTION_NAME}")
+    
+    def _initialize_collection(self):
+        """Khởi tạo collection với cosine similarity"""
+        try:
+            # Kiểm tra xem collection đã tồn tại chưa
+            existing_collections = [col.name for col in self.chroma_client.list_collections()]
+            
+            if COLLECTION_NAME in existing_collections:
+                self.collection = self.chroma_client.get_collection(name=COLLECTION_NAME)
+                
+                # Kiểm tra distance function hiện tại
+                current_metadata = self.collection.metadata or {}
+                current_space = current_metadata.get("hnsw:space", "l2")
+                
+                if current_space != "cosine":
+                    logger.warning(f"Collection hiện tại đang dùng {current_space}, cần migration sang cosine")
+                    if self.collection.count() > 0:
+                        self._migrate_to_cosine()
+                    else:
+                        # Collection trống, xóa và tạo lại
+                        self.chroma_client.delete_collection(name=COLLECTION_NAME)
+                        self._create_cosine_collection()
+                else:
+                    logger.info(f"Đã kết nối collection '{COLLECTION_NAME}' với cosine similarity, {self.collection.count()} items")
+            else:
+                # Collection chưa tồn tại, tạo mới với cosine
+                self._create_cosine_collection()
+                
+        except Exception as e:
+            logger.error(f"Lỗi khởi tạo collection: {e}")
+            # Fallback: tạo collection mới
+            self._create_cosine_collection()
+    
+    def _create_cosine_collection(self):
+        """Tạo collection mới với cosine similarity"""
+        try:
+            self.collection = self.chroma_client.create_collection(
+                name=COLLECTION_NAME,
+                metadata={"hnsw:space": "cosine"}
+            )
+            logger.info(f"Đã tạo collection mới với cosine similarity: {COLLECTION_NAME}")
+        except Exception as e:
+            logger.error(f"Lỗi tạo collection với cosine: {e}")
+            # Fallback về collection mặc định
+            self.collection = self.chroma_client.get_or_create_collection(name=COLLECTION_NAME)
+            logger.warning("Đã fallback về collection mặc định (có thể dùng L2)")
+    
+    def _migrate_to_cosine(self):
+        """Migration collection từ L2 sang cosine"""
+        try:
+            logger.info("Bắt đầu migration collection sang cosine similarity...")
+            
+            # Backup toàn bộ data
+            all_data = self.collection.get(
+                include=['documents', 'metadatas', 'embeddings'],
+                limit=self.collection.count()
+            )
+            
+            if not all_data['documents']:
+                logger.info("Collection trống, chỉ cần tạo lại")
+                self.chroma_client.delete_collection(name=COLLECTION_NAME)
+                self._create_cosine_collection()
+                return
+            
+            # Xóa collection cũ và tạo mới với cosine
+            self.chroma_client.delete_collection(name=COLLECTION_NAME)
+            self._create_cosine_collection()
+            
+            # Restore data theo batch
+            documents = all_data['documents']
+            metadatas = all_data['metadatas']
+            embeddings = all_data['embeddings']
+            ids = all_data['ids']
+            
+            batch_size = 100
+            total_items = len(documents)
+            
+            for i in range(0, total_items, batch_size):
+                batch_docs = documents[i:i + batch_size]
+                batch_metas = metadatas[i:i + batch_size] if metadatas else None
+                batch_embeds = embeddings[i:i + batch_size] if embeddings else None
+                batch_ids = ids[i:i + batch_size]
+                
+                if batch_embeds:
+                    # Có embeddings sẵn, dùng luôn
+                    self.collection.add(
+                        documents=batch_docs,
+                        metadatas=batch_metas,
+                        embeddings=batch_embeds,
+                        ids=batch_ids
+                    )
+                else:
+                    # Tính lại embeddings
+                    new_embeddings = self.encode(batch_docs, is_query=False)
+                    self.collection.add(
+                        documents=batch_docs,
+                        metadatas=batch_metas,
+                        embeddings=new_embeddings,
+                        ids=batch_ids
+                    )
+                
+                logger.info(f"Migration progress: {min(i + batch_size, total_items)}/{total_items}")
+            
+            logger.info(f"Migration hoàn thành! Đã chuyển {total_items} items sang cosine similarity")
+            
+        except Exception as e:
+            logger.error(f"Lỗi migration: {e}")
+            # Tạo collection mới nếu migration thất bại
+            self._create_cosine_collection()
+    
+    def test_embedding_quality(self):
+        try:
+            # Test cases
+            test_cases = [
+                ("query: Tháp dinh dưỡng cho trẻ", "passage: Tháp dinh dưỡng cho trẻ từ 6-11 tuổi"),
+                ("query: dinh dưỡng", "passage: dinh dưỡng cho học sinh"),
+                ("query: xin chào", "passage: Tháp dinh dưỡng cho trẻ")
+            ]
+            
+            for query_text, doc_text in test_cases:
+                # Encode
+                query_emb = self.model.encode([query_text], normalize_embeddings=True)[0]
+                doc_emb = self.model.encode([doc_text], normalize_embeddings=True)[0]
+                
+                # Calculate cosine similarity manually
+                import numpy as np
+                similarity = np.dot(query_emb, doc_emb)
+                
+                logger.info(f"Query: {query_text}")
+                logger.info(f"Doc: {doc_text}")
+                logger.info(f"Similarity: {similarity:.3f}")
+                logger.info(f"Query norm: {np.linalg.norm(query_emb):.3f}")
+                logger.info(f"Doc norm: {np.linalg.norm(doc_emb):.3f}")
+                logger.info("-" * 50)
+                
+        except Exception as e:
+            logger.error(f"Test embedding error: {e}")
     
     def _add_prefix_to_text(self, text, is_query=True):
-        """
-        Thêm prefix cho text theo yêu cầu của multilingual-e5-base
-        """
+        # Clean text trước
+        text = text.strip()
+        
         # Kiểm tra xem text đã có prefix chưa
         if text.startswith(('query:', 'passage:')):
             return text
@@ -98,24 +241,32 @@ class EmbeddingModel:
     
     def encode(self, texts, is_query=True):
         """
-        Encode văn bản thành embeddings
-        
-        Args:
-            texts (str or list): Văn bản hoặc danh sách văn bản cần encode
-            is_query (bool): True nếu là query, False nếu là passage
-            
-        Returns:
-            list: Embeddings vector
+        Encode văn bản thành embeddings với proper normalization
         """
         try:
             if isinstance(texts, str):
                 texts = [texts]
             
-            # Thêm prefix cho texts
+            # Thêm prefix cho texts (QUAN TRỌNG cho multilingual-e5-base)
             processed_texts = [self._add_prefix_to_text(text, is_query) for text in texts]
             
-            logger.debug(f"Đang encode {len(processed_texts)} văn bản")
-            embeddings = self.model.encode(processed_texts, show_progress_bar=False, normalize_embeddings=True)
+            logger.debug(f"Đang encode {len(processed_texts)} văn bản với prefix")
+            logger.debug(f"Sample processed text: {processed_texts[0][:100]}...")
+            
+            # Encode với normalize_embeddings=True (QUAN TRỌNG!)
+            embeddings = self.model.encode(
+                processed_texts, 
+                show_progress_bar=False, 
+                normalize_embeddings=True  # ✅ THÊM DÒNG NÀY
+            )
+            
+            # Double-check normalization
+            import numpy as np
+            for i, emb in enumerate(embeddings[:2]):  # Check first 2 embeddings
+                norm = np.linalg.norm(emb)
+                logger.debug(f"Embedding {i} norm: {norm}")
+                if abs(norm - 1.0) > 0.01:
+                    logger.warning(f"Embedding {i} not properly normalized: norm = {norm}")
             
             return embeddings.tolist()
             
@@ -124,24 +275,10 @@ class EmbeddingModel:
             raise
     
     def search(self, query, top_k=5, age_filter=None):
-        """
-        Tìm kiếm văn bản tương tự trong ChromaDB
-        
-        Args:
-            query (str): Câu hỏi cần tìm kiếm
-            top_k (int): Số lượng kết quả trả về
-            age_filter (int): Lọc theo độ tuổi (optional)
-            
-        Returns:
-            list: Danh sách kết quả tìm kiếm
-        """
+        """Tìm kiếm văn bản tương tự trong ChromaDB"""
         try:
-            logger.debug(f"Dang tim kiem cho query: {query[:50]}...")
-            
-            # Encode query thành embedding (với prefix query:)
             query_embedding = self.encode(query, is_query=True)[0]
             
-            # Tạo where clause cho age filter
             where_clause = None
             if age_filter:
                 where_clause = {
@@ -150,34 +287,53 @@ class EmbeddingModel:
                         {"age_max": {"$gte": age_filter}}
                     ]
                 }
-            
-            # Thực hiện search trong ChromaDB
+                print(f"🔍 AGE FILTER: Tìm kiếm cho tuổi {age_filter}")
+                print(f"🔍 WHERE CLAUSE: {where_clause}")
+            else:
+                print(f"⚠️  KHÔNG CÓ AGE FILTER - Tìm tất cả chunks")
             search_results = self.collection.query(
                 query_embeddings=[query_embedding],
                 n_results=top_k,
                 where=where_clause,
                 include=['documents', 'metadatas', 'distances']
             )
+
+            print(f"\n{'='*60}")
+            print(f"📊 CHROMADB SEARCH RESULTS")
+            print(f"{'='*60}")
+            print(f"Query: {query}")
+            print(f"Age filter: {age_filter}")
+            print(f"Found {len(search_results['documents'][0]) if search_results['documents'] else 0} chunks")
+            print(f"{'='*60}")
             
             if not search_results or not search_results['documents']:
-                logger.warning("Khong tim thay ket qua nao")
+                logger.warning("Không tìm thấy kết quả nào")
                 return []
             
-            # Format kết quả
             results = []
             documents = search_results['documents'][0]
             metadatas = search_results['metadatas'][0]
             distances = search_results['distances'][0]
             
             for i, (doc, metadata, distance) in enumerate(zip(documents, metadatas, distances)):
+                chunk_id = metadata.get('chunk_id', f'chunk_{i}')
+                title = metadata.get('title', 'No title')
+                age_range = metadata.get('age_range', 'Unknown')
+                age_min = metadata.get('age_min', 'N/A')
+                age_max = metadata.get('age_max', 'N/A')
+                content_type = metadata.get('content_type', 'text')
+                chapter = metadata.get('chapter', 'Unknown')
+                similarity = round(1 - distance, 3)
+                
                 results.append({
                     'document': doc,
                     'metadata': metadata or {},
                     'distance': distance,
-                    'similarity': 1 - distance,  # Chuyển distance thành similarity
+                    'similarity': similarity,
                     'rank': i + 1
                 })
             
+            print(f"\n{'='*60}")
             logger.info(f"Tim thay {len(results)} ket qua cho query")
             return results
             
@@ -186,36 +342,22 @@ class EmbeddingModel:
             return []
     
     def add_documents(self, documents, metadatas=None, ids=None):
-        """
-        Thêm documents vào ChromaDB
-        
-        Args:
-            documents (list): Danh sách văn bản
-            metadatas (list): Danh sách metadata tương ứng
-            ids (list): Danh sách ID tương ứng (optional)
-            
-        Returns:
-            bool: True nếu thành công
-        """
+        """Thêm documents vào ChromaDB"""
         try:
             if not documents:
                 logger.warning("Không có documents để thêm")
                 return False
             
-            # Tạo IDs nếu không được cung cấp
             if not ids:
                 ids = [str(uuid.uuid4()) for _ in documents]
             
-            # Tạo metadatas rỗng nếu không được cung cấp
             if not metadatas:
                 metadatas = [{} for _ in documents]
             
             logger.info(f"Đang thêm {len(documents)} documents vào ChromaDB")
             
-            # Encode documents thành embeddings (với prefix passage:)
             embeddings = self.encode(documents, is_query=False)
             
-            # Thêm vào collection
             self.collection.add(
                 embeddings=embeddings,
                 documents=documents,
@@ -231,9 +373,7 @@ class EmbeddingModel:
             return False
     
     def index_chunks(self, chunks):
-        """
-        Index các chunks dữ liệu vào ChromaDB
-        """
+        """Index các chunks dữ liệu vào ChromaDB"""
         try:
             if not chunks:
                 logger.warning("Không có chunks để index")
@@ -250,11 +390,9 @@ class EmbeddingModel:
                 
                 documents.append(chunk['content'])
                 
-                # Lấy metadata đã được chuẩn bị sẵn
                 metadata = chunk.get('metadata', {})
                 metadatas.append(metadata)
                 
-                # Sử dụng ID có sẵn hoặc tạo mới
                 chunk_id = chunk.get('id') or str(uuid.uuid4())
                 ids.append(chunk_id)
             
@@ -262,7 +400,6 @@ class EmbeddingModel:
                 logger.warning("Không có documents hợp lệ để index")
                 return False
             
-            # Batch processing để tránh overload
             batch_size = 100
             total_batches = (len(documents) + batch_size - 1) // batch_size
             
@@ -300,9 +437,9 @@ class EmbeddingModel:
             logger.warning(f"Đang xóa collection: {COLLECTION_NAME}")
             self.chroma_client.delete_collection(name=COLLECTION_NAME)
             
-            # Tạo lại collection mới
-            self.collection = self.chroma_client.create_collection(name=COLLECTION_NAME)
-            logger.info("Đã tạo lại collection mới")
+            # Tạo lại collection với cosine similarity
+            self._create_cosine_collection()
+            logger.info("Đã tạo lại collection mới với cosine similarity")
             
             return True
             
@@ -310,15 +447,49 @@ class EmbeddingModel:
             logger.error(f"Lỗi xóa collection: {e}")
             return False
     
+    def get_collection_info(self):
+        """Lấy thông tin về collection và distance function"""
+        try:
+            metadata = self.collection.metadata or {}
+            distance_func = metadata.get("hnsw:space", "l2")
+            
+            return {
+                'collection_name': COLLECTION_NAME,
+                'distance_function': distance_func,
+                'total_documents': self.count(),
+                'metadata': metadata
+            }
+        except Exception as e:
+            logger.error(f"Lỗi lấy collection info: {e}")
+            return {'error': str(e)}
+    
+    def verify_cosine_similarity(self):
+        """Kiểm tra và xác nhận đang sử dụng cosine similarity"""
+        try:
+            info = self.get_collection_info()
+            distance_func = info.get('distance_function', 'unknown')
+            
+            logger.info(f"Collection đang sử dụng distance function: {distance_func}")
+            
+            if distance_func == "cosine":
+                logger.info("Xác nhận: Đang sử dụng cosine similarity")
+                return True
+            else:
+                logger.warning(f"Cảnh báo: Đang sử dụng {distance_func}, không phải cosine")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Lỗi verify cosine: {e}")
+            return False
+    
     def get_stats(self):
         """Lấy thống kê về collection"""
         try:
             total_count = self.count()
+            collection_info = self.get_collection_info()
             
-            # Lấy sample để phân tích metadata
             sample_results = self.collection.get(limit=min(100, total_count))
             
-            # Thống kê content types
             content_types = {}
             chapters = {}
             age_groups = {}
@@ -328,15 +499,12 @@ class EmbeddingModel:
                     if not metadata:
                         continue
                     
-                    # Content type stats
                     content_type = metadata.get('content_type', 'unknown')
                     content_types[content_type] = content_types.get(content_type, 0) + 1
                     
-                    # Chapter stats
                     chapter = metadata.get('chapter', 'unknown')
                     chapters[chapter] = chapters.get(chapter, 0) + 1
                     
-                    # Age group stats
                     age_group = metadata.get('age_group', 'unknown')
                     age_groups[age_group] = age_groups.get(age_group, 0) + 1
             
@@ -346,7 +514,9 @@ class EmbeddingModel:
                 'chapters': chapters,
                 'age_groups': age_groups,
                 'collection_name': COLLECTION_NAME,
-                'embedding_model': EMBEDDING_MODEL
+                'embedding_model': EMBEDDING_MODEL,
+                'distance_function': collection_info.get('distance_function', 'unknown'),
+                'using_cosine_similarity': collection_info.get('distance_function') == 'cosine'
             }
             
         except Exception as e:

core/rag_pipeline.py

@@ -5,68 +5,56 @@ from config import GEMINI_API_KEY, HUMAN_PROMPT_TEMPLATE, SYSTEM_PROMPT, TOP_K_R
 import os
 import re
 
-# Cấu hình logging
 logger = logging.getLogger(__name__)
 
-# Cấu hình Gemini
+# Cấu hình Gemini API
 genai.configure(api_key=GEMINI_API_KEY)
 
 class RAGPipeline:
     def __init__(self):
-        """Khởi tạo RAG Pipeline chỉ với embedding model"""
-        logger.info("Khởi tạo RAG Pipeline")
+        # Khởi tạo RAG Pipeline với embedding model
+        logger.info("Đang khởi tạo RAG Pipeline")
         
         self.embedding_model = get_embedding_model()
-        
-        # Khởi tạo Gemini model
         self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
         
-        logger.info("RAG Pipeline đã sẵn sàng")
+        logger.info("RAG Pipeline đã sẵn sàng hoạt động")
     
     def generate_response(self, query, age=1):
-        """
-        Generate response cho user query sử dụng RAG
-        
-        Args:
-            query (str): Câu hỏi của người dùng
-            age (int): Tuổi của người dùng (1-19)
-        
-        Returns:
-            dict: Response data with success status
-        """
+        # Tạo phản hồi cho câu hỏi của người dùng sử dụng RAG
         try:
-            logger.info(f"Bắt đầu generate response cho query: {query[:50]}... (age: {age})")
+            logger.info(f"Bắt đầu tạo phản hồi cho câu hỏi: {query[:50]}... (tuổi: {age})")
+            
+            # Tìm kiếm thông tin liên quan trong ChromaDB
+            logger.info("Đang tìm kiếm thông tin liên quan trong cơ sở dữ liệu")
+            search_results = self.embedding_model.search(query, top_k=TOP_K_RESULTS, age_filter=age)
+            # search_results = self.embedding_model.search(query, top_k=TOP_K_RESULTS)
             
-            # SỬA: Chỉ search trong ChromaDB, không load lại dữ liệu
-            logger.info("Đang tìm kiếm thông tin liên quan...")
-            search_results = self.embedding_model.search(query, top_k=TOP_K_RESULTS)
             if not search_results or len(search_results) == 0:
-                logger.warning("Không tìm thấy thông tin liên quan")
+                logger.warning("Không tìm thấy thông tin liên quan trong cơ sở dữ liệu")
                 return {
                     "success": True,
                     "response": "Xin lỗi, tôi không tìm thấy thông tin liên quan đến câu hỏi của bạn trong tài liệu.",
                     "sources": []
                 }
             
-            # Chuẩn bị contexts từ kết quả tìm kiếm
+            # Chuẩn bị ngữ cảnh từ kết quả tìm kiếm
             contexts = []
             sources = []
             
             for result in search_results:
-                # Lấy thông tin từ metadata
                 metadata = result.get('metadata', {})
                 content = result.get('document', '')
                 
-                # Thêm context
+                # Thêm nội dung vào ngữ cảnh
                 contexts.append({
                     "content": content,
                     "metadata": metadata
                 })
                 
-                # Thêm source reference
+                # Tạo thông tin nguồn tài liệu
                 source_info = {
-                    "chunk_id": metadata.get('chunk_id', 'unknown'),
-                    "title": metadata.get('title', metadata.get('chapter', 'Tài liệu dinh dưỡng')),  # Giữ title nếu cần
+                    "title": metadata.get('title', metadata.get('chapter', 'Tài liệu dinh dưỡng')),
                     "pages": metadata.get('pages'),
                     "content_type": metadata.get('content_type', 'text')
                 }
@@ -74,14 +62,14 @@ class RAGPipeline:
                 if source_info not in sources:
                     sources.append(source_info)
             
-            # Format contexts cho prompt
+            # Định dạng ngữ cảnh cho prompt
             formatted_contexts = self._format_contexts(contexts)
             
-            # Tạo prompt với age context
+            # Tạo prompt với ngữ cảnh độ tuổi
             full_prompt = self._create_prompt_with_age_context(query, age, formatted_contexts)
             
-            # Generate response với Gemini
-            logger.info("Đang tạo phản hồi với Gemini...")
+            # Tạo phản hồi với Gemini AI
+            logger.info("Đang tạo phản hồi với Gemini AI")
             response = self.gemini_model.generate_content(
                 full_prompt,
                 generation_config=genai.types.GenerationConfig(
@@ -91,7 +79,7 @@ class RAGPipeline:
             )
             
             if not response or not response.text:
-                logger.error("Gemini không trả về response")
+                logger.error("Gemini AI không trả về phản hồi")
                 return {
                     "success": False,
                     "error": "Không thể tạo phản hồi"
@@ -99,7 +87,7 @@ class RAGPipeline:
             
             response_text = response.text.strip()
             
-            # Post-process response để xử lý hình ảnh
+            # Xử lý các đường dẫn hình ảnh trong phản hồi
             response_text = self._process_image_links(response_text)
             
             logger.info("Đã tạo phản hồi thành công")
@@ -111,25 +99,23 @@ class RAGPipeline:
             }
             
         except Exception as e:
-            logger.error(f"Lỗi generate response: {str(e)}")
+            logger.error(f"Lỗi khi tạo phản hồi: {str(e)}")
             return {
                 "success": False,
                 "error": f"Lỗi tạo phản hồi: {str(e)}"
             }
     
     def _format_contexts(self, contexts):
-        """Format contexts thành string cho prompt"""
+        # Định dạng ngữ cảnh thành chuỗi cho prompt
         formatted = []
         
         for i, context in enumerate(contexts, 1):
             content = context['content']
             metadata = context['metadata']
             
-            # Thêm thông tin metadata
+            # Thêm thông tin metadata vào ngữ cảnh
             context_str = f"[Tài liệu {i}]"
-            if metadata.get('chunk_id'):
-                context_str += f" - ID: {metadata['chunk_id']}"
-            elif metadata.get('title'):
+            if metadata.get('title'):
                 context_str += f" - {metadata['title']}"
             if metadata.get('pages'):
                 context_str += f" (Trang {metadata['pages']})"
@@ -139,9 +125,8 @@ class RAGPipeline:
         
         return "\n".join(formatted)
     
-    def _create_prompt_with_age_context(self, query, age, contexts):
-        """Tạo prompt với age context"""
-        # Xác định age group
+    def _create_prompt_with_age_context(self, query, age, contexts):        
+        # Xác định hướng dẫn theo nhóm tuổi
         if age <= 3:
             age_guidance = "Sử dụng ngôn ngữ đơn giản, dễ hiểu cho phụ huynh có con nhỏ."
         elif age <= 6:
@@ -153,7 +138,7 @@ class RAGPipeline:
         else:
             age_guidance = "Thông tin đầy đủ, chi tiết cho học sinh trung học phổ thông."
         
-        # Tạo system prompt với age context
+        # Tạo system prompt có tính đến độ tuổi
         age_aware_system_prompt = f"""{SYSTEM_PROMPT}
 
 QUAN TRỌNG - Hướng dẫn theo độ tuổi:
@@ -163,7 +148,7 @@ Người dùng hiện tại {age} tuổi. {age_guidance}
 - Tránh thông tin quá phức tạp hoặc không phù hợp
 """
         
-        # Tạo human prompt
+        # Tạo human prompt từ template
         human_prompt = HUMAN_PROMPT_TEMPLATE.format(
             query=query,
             age=age,
@@ -173,30 +158,28 @@ Người dùng hiện tại {age} tuổi. {age_guidance}
         return f"{age_aware_system_prompt}\n\n{human_prompt}"
     
     def _process_image_links(self, response_text):
-        """Xử lý các đường dẫn hình ảnh trong response"""
+        # Xử lý và chuyển đổi các đường dẫn hình ảnh trong phản hồi
         try:
             import re
             
-            # Tìm các pattern markdown image
+            # Tìm các pattern markdown: ![alt](path)
             image_pattern = r'!\[([^\]]*)\]\(([^)]+)\)'
             
             def replace_image_path(match):
                 alt_text = match.group(1)
                 image_path = match.group(2)
                 
-                # Xử lý đường dẫn local Windows/Linux
+                # Xử lý đường dẫn local (Windows/Linux)
                 if '\\' in image_path or image_path.startswith('/') or ':' in image_path:
-                    # Extract filename từ đường dẫn local
+                    # Trích xuất tên file từ đường dẫn local
                     filename = image_path.split('\\')[-1].split('/')[-1]
                     
-                    # Tìm bai_id từ filename
+                    # Tìm bai_id từ tên file (format: baiX_filename)
                     bai_match = re.match(r'^(bai\d+)_', filename)
                     if bai_match:
                         bai_id = bai_match.group(1)
-                    else:
-                        bai_id = 'bai1'  # default
                     
-                    # Tạo API URL
+                    # Tạo URL API
                     api_url = f"/api/figures/{bai_id}/{filename}"
                     return f"![{alt_text}]({api_url})"
                 
@@ -210,39 +193,29 @@ Người dùng hiện tại {age} tuổi. {age_guidance}
                     bai_match = re.match(r'^(bai\d+)_', filename)
                     if bai_match:
                         bai_id = bai_match.group(1)
-                    else:
-                        bai_id = 'bai1'
                     
                     api_url = f"/api/figures/{bai_id}/{filename}"
                     return f"![{alt_text}]({api_url})"
-                
-                # Các trường hợp khác, giữ nguyên
+
                 return match.group(0)
             
-            # Thay thế tất cả image links
+            # Thay thế tất cả các liên kết hình ảnh
             processed_text = re.sub(image_pattern, replace_image_path, response_text)
             
-            logger.info(f"Processed {len(re.findall(image_pattern, response_text))} image links")
+            image_count = len(re.findall(image_pattern, response_text))
+            if image_count > 0:
+                logger.info(f"Đã xử lý {image_count} liên kết hình ảnh")
+            
             return processed_text
             
         except Exception as e:
-            logger.error(f"Lỗi xử lý image links: {e}")
+            logger.error(f"Lỗi khi xử lý liên kết hình ảnh: {e}")
             return response_text
 
     def generate_follow_up_questions(self, query, answer, age=1):
-        """
-        Tạo câu hỏi gợi ý dựa trên query và answer
-        
-        Args:
-            query (str): Câu hỏi gốc
-            answer (str): Câu trả lời đã được tạo
-            age (int): Tuổi người dùng
-        
-        Returns:
-            dict: Response data với danh sách câu hỏi gợi ý
-        """
+        # Tạo câu hỏi gợi ý dựa trên cuộc hội thoại hiện tại
         try:
-            logger.info("Đang tạo câu hỏi follow-up...")
+            logger.info("Đang tạo câu hỏi gợi ý")
             
             follow_up_prompt = f"""
 Dựa trên cuộc hội thoại sau, hãy tạo 3-5 câu hỏi gợi ý phù hợp cho người dùng {age} tuổi về chủ đề dinh dưỡng:
@@ -273,27 +246,30 @@ Trả về danh sách câu hỏi, mỗi câu một dòng, không đánh số.
                     "error": "Không thể tạo câu hỏi gợi ý"
                 }
             
-            # Parse response thành list câu hỏi
+            # Chuyển đổi phản hồi thành danh sách câu hỏi
             questions = []
             lines = response.text.strip().split('\n')
             
             for line in lines:
                 line = line.strip()
+                # Lọc các dòng hợp lệ (không rỗng, không phải comment, đủ dài)
                 if line and not line.startswith('#') and len(line) > 10:
-                    # Loại bỏ số thứ tự nếu có
+                    # Loại bỏ số thứ tự nếu có (1. 2. hoặc 1) 2))
                     line = re.sub(r'^\d+[\.\)]\s*', '', line)
                     questions.append(line)
             
-            # Giới hạn 5 câu hỏi
+            # Giới hạn tối đa 5 câu hỏi
             questions = questions[:5]
             
+            logger.info(f"Đã tạo {len(questions)} câu hỏi gợi ý")
+            
             return {
                 "success": True,
                 "questions": questions
             }
             
         except Exception as e:
-            logger.error(f"Lỗi tạo follow-up questions: {str(e)}")
+            logger.error(f"Lỗi khi tạo câu hỏi gợi ý: {str(e)}")
             return {
                 "success": False,
                 "error": f"Lỗi tạo câu hỏi gợi ý: {str(e)}"