update remote

app/law_document_chunker.py

@@ -186,7 +186,7 @@ class LawDocumentChunker:
         if parent.article_number and not metadata.article_number:
             metadata.article_number = parent.article_number
         if parent.article_title and not metadata.article_title:
-            metadata.article_title = parent.article_title
+            metadata.article_title = parent.article_title #
         if parent.clause_number and not metadata.clause_number:
             metadata.clause_number = parent.clause_number
         if parent.sub_clause_letter and not metadata.sub_clause_letter:

app/reranker.py

@@ -4,6 +4,7 @@ from .gemini_client import GeminiClient
 from loguru import logger
 import asyncio
 import random
+import hashlib
 from .constants import BATCH_STATUS_MESSAGES
 
 class Reranker:
@@ -20,17 +21,26 @@ class Reranker:
         else:
             raise NotImplementedError(f"Rerank provider {self.provider} not supported yet.")
         self.facebook_client = facebook_client
+        # Cache cho kết quả reranking
+        self._rerank_cache = {}
+
+    def _get_cache_key(self, query: str, docs: List[Dict]) -> str:
+        """Tạo cache key từ query và docs."""
+        # Tạo hash từ query và doc IDs
+        doc_ids = [str(doc.get('id', '')) for doc in docs[:15]]  # Chỉ cache top 15 docs
+        cache_content = query + "|".join(doc_ids)
+        return hashlib.md5(cache_content.encode()).hexdigest()
 
     async def _score_doc(self, query: str, doc: Dict) -> Dict:
         """
         Score một document với query.
         """
         content = (doc.get('tieude', '') or '') + ' ' + (doc.get('noidung', '') or '')
+        # Tối ưu prompt ngắn gọn hơn
         prompt = (
-            f"Đoạn luật: {content}\n"
-            f"Câu hỏi: {query}\n"
-            "Hãy đánh giá mức độ liên quan giữa đoạn luật và câu hỏi trên thang điểm 0-10. "
-            "Chỉ trả về một số duy nhất."
+            f"Luật: {content[:500]}\n"  # Giới hạn content length
+            f"Hỏi: {query}\n"
+            "Đánh giá mức độ liên quan (0-10). Chỉ trả về số."
         )
         
         try:
@@ -51,53 +61,116 @@ class Reranker:
             doc['rerank_score'] = 0
             return doc
 
+    async def _batch_score_docs(self, query: str, docs: List[Dict]) -> List[Dict]:
+        """
+        Score nhiều documents cùng lúc bằng một prompt duy nhất.
+        """
+        if not docs:
+            return []
+        
+        # Tạo prompt batch cho tất cả documents
+        docs_content = []
+        for i, doc in enumerate(docs):
+            content = (doc.get('tieude', '') or '') + ' ' + (doc.get('noidung', '') or '')
+            docs_content.append(f"{i+1}. {content[:300]}")  # Giới hạn length
+        
+        batch_prompt = (
+            f"Câu hỏi: {query}\n\n"
+            f"Các đoạn luật:\n" + "\n".join(docs_content) + "\n\n"
+            f"Đánh giá mức độ liên quan của từng đoạn (0-10). Trả về dạng: 1.8,2.5,3.0,..."
+        )
+        
+        try:
+            if self.provider == 'gemini':
+                loop = asyncio.get_event_loop()
+                logger.info(f"[RERANK] Sending batch prompt to Gemini")
+                response = await loop.run_in_executor(None, self.client.generate_text, batch_prompt)
+                logger.info(f"[RERANK] Got batch scores from Gemini: {response}")
+                
+                # Parse scores từ response
+                scores_text = str(response).strip()
+                scores = []
+                for score_str in scores_text.split(','):
+                    try:
+                        score = float(score_str.strip().split('.')[0])
+                        scores.append(score)
+                    except:
+                        scores.append(0)
+                
+                # Gán scores cho documents
+                for i, doc in enumerate(docs):
+                    doc['rerank_score'] = scores[i] if i < len(scores) else 0
+                
+                return docs
+                
+            else:
+                raise NotImplementedError(f"Rerank provider {self.provider} not supported yet in batch method.")
+            
+        except Exception as e:
+            logger.error(f"[RERANK] Lỗi khi batch score: {e}")
+            # Fallback về individual scoring
+            for doc in docs:
+                doc['rerank_score'] = 0
+            return docs
+
     async def rerank(self, query: str, docs: List[Dict], top_k: int = 5) -> List[Dict]:
         """
         Rerank docs theo độ liên quan với query, trả về top_k docs.
-        Sử dụng concurrency để process nhiều docs cùng lúc.
+        Sử dụng batch processing để tối ưu hiệu suất.
         """
         logger.info(f"[RERANK] Start rerank for query: {query} | docs: {len(docs)} | top_k: {top_k}")
         
         if not docs:
             return []
         
-        # Rerank toàn bộ docs, không giới hạn 10 docs
-        docs_to_rerank = docs
-        logger.info(f"[RERANK] Will rerank {len(docs_to_rerank)} docs (no limit)")
+        # Kiểm tra cache trước
+        cache_key = self._get_cache_key(query, docs)
+        if cache_key in self._rerank_cache:
+            logger.info(f"[RERANK] Cache hit for query, returning cached result")
+            cached_result = self._rerank_cache[cache_key][:top_k]
+            return cached_result
         
-        # Process docs với concurrency
-        batch_size = 5  # Process 5 docs cùng lúc
-        scored = []
+        # Giới hạn số lượng docs để rerank - chỉ rerank top 15 docs có similarity cao nhất
+        max_docs_to_rerank = 15
+        docs_to_rerank = docs[:max_docs_to_rerank]
+        logger.info(f"[RERANK] Will rerank {len(docs_to_rerank)} docs (limited to top {max_docs_to_rerank})")
         
-        for i in range(0, len(docs_to_rerank), batch_size):
-            batch = docs_to_rerank[i:i + batch_size]
-            logger.info(f"[RERANK] Processing batch {i//batch_size + 1}: {len(batch)} docs")
-            
-            # Tạo tasks cho batch hiện tại
-            tasks = [self._score_doc(query, doc) for doc in batch]
-            
-            # Chạy batch concurrently
-            batch_results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            # Xử lý kết quả
-            for result in batch_results:
-                if isinstance(result, Exception):
-                    logger.error(f"[RERANK] Batch processing error: {result}")
-                    continue
-                scored.append(result)
-            
-            logger.info(f"[RERANK] Completed batch {i//batch_size + 1}, processed {len(scored)} docs so far")
-            # Send Facebook message after each batch
-            if self.facebook_client:
+        # Sử dụng batch processing thay vì individual scoring
+        try:
+            scored = await self._batch_score_docs(query, docs_to_rerank)
+            logger.info(f"[RERANK] Batch processing completed, scored {len(scored)} docs")
+        except Exception as e:
+            logger.error(f"[RERANK] Batch processing failed, falling back to individual scoring: {e}")
+            # Fallback về individual scoring nếu batch processing thất bại
+            scored = []
+            for doc in docs_to_rerank:
                 try:
-                    message = random.choice(BATCH_STATUS_MESSAGES)
-                    await self.facebook_client.send_message(message=f"... {message} ...")
+                    scored_doc = await self._score_doc(query, doc)
+                    scored.append(scored_doc)
                 except Exception as e:
-                    logger.error(f"[RERANK][FACEBOOK] Error sending batch message: {e}")
+                    logger.error(f"[RERANK] Error scoring individual doc: {e}")
+                    doc['rerank_score'] = 0
+                    scored.append(doc)
+        
+        # Gửi Facebook message chỉ một lần sau khi hoàn thành
+        if self.facebook_client:
+            try:
+                message = random.choice(BATCH_STATUS_MESSAGES)
+                await self.facebook_client.send_message(message=f"... {message} ...")
+            except Exception as e:
+                logger.error(f"[RERANK][FACEBOOK] Error sending batch message: {e}")
         
         # Sort theo score và trả về top_k
         scored = sorted(scored, key=lambda x: x['rerank_score'], reverse=True)
         result = scored[:top_k]
         
+        # Cache kết quả
+        self._rerank_cache[cache_key] = scored
+        # Giới hạn cache size để tránh memory leak
+        if len(self._rerank_cache) > 100:
+            # Xóa cache cũ nhất
+            oldest_key = next(iter(self._rerank_cache))
+            del self._rerank_cache[oldest_key]
+        
         logger.info(f"[RERANK] Top reranked docs: {result}")
         return result