update query and rerank in parallel

ENVIRONMENT_VARIABLES.md

@@ -14,6 +14,12 @@
 - **Usage**: `MAX_DOCS_TO_RERANK=20`
 - **Impact**: Ảnh hưởng đến số lượng docs được xử lý trong reranking
 
+### RERANK_MIN_SCORE
+- **Description**: Ngưỡng điểm tối thiểu để một document được giữ lại sau khi rerank.
+- **Default**: `7.0`
+- **Usage**: `RERANK_MIN_SCORE=7.5`
+- **Impact**: Ảnh hưởng đến số lượng và chất lượng kết quả cuối cùng. Điểm cao hơn sẽ trả về ít kết quả hơn nhưng liên quan hơn.
+
 ## Logging Configuration
 
 ### LOG_LEVEL
@@ -137,6 +143,7 @@
 # Search Configuration
 MATCH_COUNT=15
 MAX_DOCS_TO_RERANK=15
+RERANK_MIN_SCORE=7.0
 
 # Logging Configuration
 LOG_LEVEL=DEBUG

app/config.py

@@ -8,46 +8,60 @@ from loguru import logger
 load_dotenv()
 
 # Debug: Check environment variables
-logger.info(f"[CONFIG] FACEBOOK_APP_SECRET from env: {os.getenv('FACEBOOK_APP_SECRET', 'NOT_SET')[:5]}...")
-logger.info(f"[CONFIG] FACEBOOK_VERIFY_TOKEN from env: {os.getenv('FACEBOOK_VERIFY_TOKEN', 'NOT_SET')[:5]}...")
-logger.info(f"[CONFIG] SUPABASE_URL from env: {os.getenv('SUPABASE_URL', 'NOT_SET')[:5]}...")
+logger.info(
+    f"[CONFIG] FACEBOOK_APP_SECRET from env: {os.getenv('FACEBOOK_APP_SECRET', 'NOT_SET')[:5]}..."
+)
+logger.info(
+    f"[CONFIG] FACEBOOK_VERIFY_TOKEN from env: {os.getenv('FACEBOOK_VERIFY_TOKEN', 'NOT_SET')[:5]}..."
+)
+logger.info(
+    f"[CONFIG] SUPABASE_URL from env: {os.getenv('SUPABASE_URL', 'NOT_SET')[:5]}..."
+)
+
 
 class Settings(BaseSettings):
     """
     Lưu trữ và quản lý cấu hình ứng dụng từ biến môi trường.
     Các thuộc tính: facebook_verify_token, facebook_app_secret, ...
     """
+
     # Facebook Configuration
     facebook_verify_token: str = os.getenv("FACEBOOK_VERIFY_TOKEN") or ""
     facebook_app_secret: str = os.getenv("FACEBOOK_APP_SECRET") or ""
     facebook_api_base_url: str = os.getenv("FACEBOOK_API_BASE_URL") or ""
-    
+
     # Google Sheets Configuration
-    google_sheets_credentials_file: str = os.getenv("GOOGLE_SHEETS_CREDENTIALS_FILE") or ""
+    google_sheets_credentials_file: str = (
+        os.getenv("GOOGLE_SHEETS_CREDENTIALS_FILE") or ""
+    )
     google_sheets_token_file: str = os.getenv("GOOGLE_SHEETS_TOKEN_FILE") or ""
     conversation_sheet_id: str = os.getenv("CONVERSATION_SHEET_ID") or ""
-    
+
     # Supabase Configuration
     supabase_url: str = os.getenv("SUPABASE_URL") or ""
     supabase_key: str = os.getenv("SUPABASE_KEY") or ""
-    
+
     # Server Configuration
     host: str = os.getenv("HOST", "0.0.0.0") or ""
     port: int = int(os.getenv("PORT", "8000")) or 8000
-    
+
     # Logging Configuration
     log_level: str = os.getenv("LOG_LEVEL", "DEBUG") or "DEBUG"
 
     # Search Configuration
     match_count: int = int(os.getenv("MATCH_COUNT", "20")) or 20
     max_docs_to_rerank: int = int(os.getenv("MAX_DOCS_TO_RERANK", "20")) or 20
+    rerank_min_score: float = float(os.getenv("RERANK_MIN_SCORE", "7.0"))
 
     # Gemini Configuration
     # Hỗ trợ nhiều API key và model cho Gemini
     # Định nghĩa biến môi trường: GEMINI_API_KEYS="key1,key2,..."; GEMINI_MODELS="model1,model2,..."
     gemini_api_keys: str = ""
     gemini_models: str = ""
-    gemini_base_url: str = os.getenv("GEMINI_BASE_URL", "https://generativelanguage.googleapis.com/v1") or ""
+    gemini_base_url: str = (
+        os.getenv("GEMINI_BASE_URL", "https://generativelanguage.googleapis.com/v1")
+        or ""
+    )
 
     # LLM (chat/completion) provider/model
     llm_provider: str = os.getenv("LLM_PROVIDER", "gemini") or ""
@@ -70,6 +84,7 @@ class Settings(BaseSettings):
     class Config:
         env_file = ".env"
 
+
 @lru_cache()
 def get_settings() -> Settings:
     """
@@ -77,4 +92,4 @@ def get_settings() -> Settings:
     Input: None
     Output: Settings instance.
     """
-    return Settings() 
+    return Settings()

app/message_processor.py

@@ -3,14 +3,22 @@ import asyncio
 import traceback
 import json
 from loguru import logger
-import random # random is used in the original file, but get_random_message is preferred
-from .constants import START_SEARCHING_MESSAGES, SUMMARY_STATUS_MESSAGES, PROCESSING_STATUS_MESSAGES, FOUND_REGULATIONS_MESSAGES, BATCH_STATUS_MESSAGES, LLM_RETRY_WAIT_MESSAGES
+import random  # random is used in the original file, but get_random_message is preferred
+from .constants import (
+    START_SEARCHING_MESSAGES,
+    SUMMARY_STATUS_MESSAGES,
+    PROCESSING_STATUS_MESSAGES,
+    FOUND_REGULATIONS_MESSAGES,
+    BATCH_STATUS_MESSAGES,
+    LLM_RETRY_WAIT_MESSAGES,
+)
 from .utils import get_random_message, _safe_truncate
 from .facebook import FacebookClient
 from .gemini_client import GeminiResponseError
 from app.config import get_settings
 import re
 
+
 class MessageProcessor:
     def __init__(self, channel, sender_id):
         self.channel = channel
@@ -20,7 +28,7 @@ class MessageProcessor:
             app_secret=get_settings().facebook_app_secret,
             page_id=channel.page_id,
             page_token=channel.get_page_token(),
-            sender_id=sender_id
+            sender_id=sender_id,
         )
 
     async def process_message(self, message_data: Dict[str, Any]):
@@ -30,16 +38,20 @@ class MessageProcessor:
         required_fields = ["sender_id", "page_id", "text", "timestamp"]
         for field in required_fields:
             if field not in message_data:
-                logger.error(f"[ERROR] Missing field {field} in message_data: {message_data}")
+                logger.error(
+                    f"[ERROR] Missing field {field} in message_data: {message_data}"
+                )
                 return
-        
+
         loop = asyncio.get_event_loop()
         sender_id = message_data["sender_id"]
         page_id = message_data["page_id"]
         message_text = message_data["text"]
         timestamp = message_data["timestamp"]
-        attachments = message_data.get('attachments', [])
-        logger.bind(user_id=sender_id, page_id=page_id, message=message_text).info("Processing message")
+        attachments = message_data.get("attachments", [])
+        logger.bind(user_id=sender_id, page_id=page_id, message=message_text).info(
+            "Processing message"
+        )
 
         if not message_text and not attachments:
             logger.info(f"[DEBUG] Không có message_text và attachments, không xử lý...")
@@ -52,31 +64,46 @@ class MessageProcessor:
         logger.info(f"[DEBUG] history: ... {history[-3:]}")
 
         for row in history:
-            sheet_timestamps = [str(ts) for ts in row.get('timestamp', [])]
+            sheet_timestamps = [str(ts) for ts in row.get("timestamp", [])]
             if str(timestamp) in sheet_timestamps:
-                logger.warning(f"Webhook lặp lại cho sự kiện đã tồn tại (timestamp: {timestamp}). Bỏ qua.")
+                logger.warning(
+                    f"Webhook lặp lại cho sự kiện đã tồn tại (timestamp: {timestamp}). Bỏ qua."
+                )
                 return
 
         log_kwargs = {
-            'conversation_id': None, 'recipient_id': sender_id, 'page_id': page_id,
-            'originaltext': message_text, 'originalcommand': '', 'originalcontent': '',
-            'originalattachments': attachments, 'originalvehicle': '', 'originalaction': '',
-            'originalpurpose': '', 'originalquestion': '', 'systemresponse': '',
-            'timestamp': [timestamp], 'isdone': False
+            "conversation_id": None,
+            "recipient_id": sender_id,
+            "page_id": page_id,
+            "originaltext": message_text,
+            "originalcommand": "",
+            "originalcontent": "",
+            "originalattachments": attachments,
+            "originalvehicle": "",
+            "originalaction": "",
+            "originalpurpose": "",
+            "originalquestion": "",
+            "systemresponse": "",
+            "timestamp": [timestamp],
+            "isdone": False,
         }
 
         logger.info(f"[DEBUG] Message cơ bản: {log_kwargs}")
-        conv = await loop.run_in_executor(None, lambda: sheets_client.log_conversation(**log_kwargs))
+        conv = await loop.run_in_executor(
+            None, lambda: sheets_client.log_conversation(**log_kwargs)
+        )
         if not conv:
             logger.error("Không thể tạo conversation mới!")
             return
         logger.info(f"[DEBUG] Message history sau lần ghi đầu: {conv}")
-                
-        conv['timestamp'] = self.flatten_timestamp(conv['timestamp'])
-        if timestamp not in conv['timestamp']:
-            conv['timestamp'].append(timestamp)
-        
-        conv_after_update1 = await loop.run_in_executor(None, lambda: sheets_client.log_conversation(**conv))
+
+        conv["timestamp"] = self.flatten_timestamp(conv["timestamp"])
+        if timestamp not in conv["timestamp"]:
+            conv["timestamp"].append(timestamp)
+
+        conv_after_update1 = await loop.run_in_executor(
+            None, lambda: sheets_client.log_conversation(**conv)
+        )
         if conv_after_update1:
             conv = conv_after_update1
 
@@ -84,9 +111,13 @@ class MessageProcessor:
         if not page_token:
             logger.error(f"No access token found for page {message_data['page_id']}")
             return
-        
+
         try:
-            asyncio.create_task(self.facebook.send_message(message=get_random_message(PROCESSING_STATUS_MESSAGES)))
+            asyncio.create_task(
+                self.facebook.send_message(
+                    message=get_random_message(PROCESSING_STATUS_MESSAGES)
+                )
+            )
         except Exception as e:
             if "expired" in str(e).lower():
                 logger.warning("[FACEBOOK] Token expired, invalidate and refresh")
@@ -98,21 +129,28 @@ class MessageProcessor:
 
         from app.utils import extract_command, extract_keywords
         from app.constants import VEHICLE_KEYWORDS
+
         command, remaining_text = extract_command(message_text)
-        
-        llm_analysis = None # Khởi tạo là None
+
+        llm_analysis = None  # Khởi tạo là None
         try:
-            llm_analysis = await self.channel.llm.analyze(message_text, self.get_llm_history(history))
+            llm_analysis = await self.channel.llm.analyze(
+                message_text, self.get_llm_history(history)
+            )
             logger.info(f"[LLM][RAW] Kết quả trả về từ analyze: {llm_analysis}")
         except GeminiResponseError as e:
-            logger.error(f"[LLM][ANALYZE] Lỗi nội dung (MAX_TOKENS/SAFETY) khi phân tích câu hỏi: {e}. Sẽ fallback về phương pháp cũ.")
+            logger.error(
+                f"[LLM][ANALYZE] Lỗi nội dung (MAX_TOKENS/SAFETY) khi phân tích câu hỏi: {e}. Sẽ fallback về phương pháp cũ."
+            )
         except Exception as e:
-            logger.error(f"[LLM][ANALYZE] Lỗi không xác định khi phân tích câu hỏi: {e}. Sẽ fallback về phương pháp cũ.")
-        
+            logger.error(
+                f"[LLM][ANALYZE] Lỗi không xác định khi phân tích câu hỏi: {e}. Sẽ fallback về phương pháp cũ."
+            )
+
         muc_dich = None
-        tu_khoa_list = [] # Sửa: đổi tên thành tu_khoa_list và khởi tạo là list rỗng
+        tu_khoa_list = []  # Sửa: đổi tên thành tu_khoa_list và khởi tạo là list rỗng
         cau_hoi = None
-        
+
         # Sửa: Đơn giản hóa logic, vì LLM giờ luôn trả về 1 dict
         analysis_data = None
         if isinstance(llm_analysis, list) and llm_analysis:
@@ -122,49 +160,64 @@ class MessageProcessor:
 
         if analysis_data:
             # Lấy phương tiện và chuẩn hóa
-            phuong_tien = self.normalize_vehicle_keyword(analysis_data.get('phuong_tien', ''))
+            phuong_tien = self.normalize_vehicle_keyword(
+                analysis_data.get("phuong_tien", "")
+            )
             keywords = [phuong_tien] if phuong_tien else []
-            
-            muc_dich = analysis_data.get('muc_dich')
-            
+
+            muc_dich = analysis_data.get("muc_dich")
+
             # Lấy danh sách từ khóa, đảm bảo nó là list
-            raw_tu_khoa = analysis_data.get('tu_khoa', [])
+            raw_tu_khoa = analysis_data.get("tu_khoa", [])
             if isinstance(raw_tu_khoa, list):
                 tu_khoa_list = raw_tu_khoa
             elif isinstance(raw_tu_khoa, str) and raw_tu_khoa:
-                tu_khoa_list = [raw_tu_khoa] # Chuyển string thành list 1 phần tử
-                
-            cau_hoi = analysis_data.get('cau_hoi')
+                tu_khoa_list = [raw_tu_khoa]  # Chuyển string thành list 1 phần tử
+
+            cau_hoi = analysis_data.get("cau_hoi")
         else:
             # Fallback logic cũ nếu LLM không phân tích được
             keywords = extract_keywords(message_text, VEHICLE_KEYWORDS)
             cau_hoi = message_text
-            for kw in keywords: cau_hoi = cau_hoi.replace(kw, "")
+            for kw in keywords:
+                cau_hoi = cau_hoi.replace(kw, "")
             cau_hoi = cau_hoi.strip()
-        
+
         # Sửa: Log danh sách từ khóa
-        logger.info(f"[DEBUG] Phương tiện: {keywords} - Từ khóa pháp lý: {tu_khoa_list} - Mục đích: {muc_dich} - Câu hỏi: {cau_hoi}")
+        logger.info(
+            f"[DEBUG] Phương tiện: {keywords} - Từ khóa pháp lý: {tu_khoa_list} - Mục đích: {muc_dich} - Câu hỏi: {cau_hoi}"
+        )
 
-        conv.update({
-            'originalcommand': command, 'originalcontent': remaining_text, 'originalvehicle': ','.join(keywords),
-            # Sửa lỗi: Dùng separator ';;;' để nối các cụm từ khóa,
-            # tránh bị tách sai ở bước sau.
-            'originalaction': ';;;'.join(tu_khoa_list), 'originalpurpose': muc_dich, 'originalquestion': cau_hoi or ""
-        })
+        conv.update(
+            {
+                "originalcommand": command,
+                "originalcontent": remaining_text,
+                "originalvehicle": ",".join(keywords),
+                # Sửa lỗi: Dùng separator ';;;' để nối các cụm từ khóa,
+                # tránh bị tách sai ở bước sau.
+                "originalaction": ";;;".join(tu_khoa_list),
+                "originalpurpose": muc_dich,
+                "originalquestion": cau_hoi or "",
+            }
+        )
 
-        muc_dich_to_use = muc_dich or conv.get('originalpurpose')
+        muc_dich_to_use = muc_dich or conv.get("originalpurpose")
         logger.info(f"[DEBUG] Định hướng mục đích xử lý: {muc_dich_to_use}")
         conversation_context = self.get_llm_history(history)
 
         # Gửi tin nhắn trước khi tiến hành tìm kiếm
-        asyncio.create_task(self.facebook.send_message(message=get_random_message(START_SEARCHING_MESSAGES)))
+        asyncio.create_task(
+            self.facebook.send_message(
+                message=get_random_message(START_SEARCHING_MESSAGES)
+            )
+        )
         response = None
         handlers = {
             "hỏi về mức phạt": self.handle_muc_phat,
             "hỏi về quy tắc giao thông": self.handle_quy_tac,
             "hỏi về báo hiệu đường bộ": self.handle_bao_hieu,
             "hỏi về quy trình xử lý vi phạm giao thông": self.handle_quy_trinh,
-            "thông tin cá nhân của AI": self.handle_ca_nhan
+            "thông tin cá nhân của AI": self.handle_ca_nhan,
         }
 
         if not command:
@@ -172,90 +225,125 @@ class MessageProcessor:
             response = await handler(conv, conversation_context, page_token, sender_id)
         else:
             if command == "xong":
-                post_url = await self.create_facebook_post(page_token, conv['recipient_id'], [conv])
-                response = f"Bài viết đã được tạo thành công! Bạn có thể xem tại: {post_url}" if post_url else "Đã xảy ra lỗi khi tạo bài viết."
-                conv['isdone'] = True
+                post_url = await self.create_facebook_post(
+                    page_token, conv["recipient_id"], [conv]
+                )
+                response = (
+                    f"Bài viết đã được tạo thành công! Bạn có thể xem tại: {post_url}"
+                    if post_url
+                    else "Đã xảy ra lỗi khi tạo bài viết."
+                )
+                conv["isdone"] = True
             else:
-                response = "Vui lòng cung cấp thêm thông tin và gõ lệnh \\xong khi hoàn tất."
-                conv['isdone'] = False
+                response = (
+                    "Vui lòng cung cấp thêm thông tin và gõ lệnh \\xong khi hoàn tất."
+                )
+                conv["isdone"] = False
 
         asyncio.create_task(self.facebook.send_message(message=response))
-        
-        conv['systemresponse'] = response
-        
+
+        conv["systemresponse"] = response
+
         logger.info(f"Chuẩn bị ghi/cập nhật dữ liệu cuối cùng vào sheet: {conv}")
-        
+
         loop.run_in_executor(None, lambda: sheets_client.log_conversation(**conv))
-        
+
         return
-    
-    def get_latest_timestamp(self,ts_value):
-        if isinstance(ts_value, (int, float)): return int(ts_value)
+
+    def get_latest_timestamp(self, ts_value):
+        if isinstance(ts_value, (int, float)):
+            return int(ts_value)
         if isinstance(ts_value, str):
-            try: return int(json.loads(ts_value))
-            except: 
-                try: return int(ts_value)
-                except: return 0
+            try:
+                return int(json.loads(ts_value))
+            except:
+                try:
+                    return int(ts_value)
+                except:
+                    return 0
         if isinstance(ts_value, list):
-            if not ts_value: return 0
-            return max([self.get_latest_timestamp(item) for item in ts_value]) if ts_value else 0
+            if not ts_value:
+                return 0
+            return (
+                max([self.get_latest_timestamp(item) for item in ts_value])
+                if ts_value
+                else 0
+            )
         return 0
-    
+
     def get_llm_history(self, history: List[Dict[str, Any]]) -> str:
         """
         Định dạng lịch sử hội thoại thành một chuỗi văn bản duy nhất,
         bao gồm cả các từ khóa đã sử dụng để cung cấp ngữ cảnh cho LLM.
         """
-        sorted_history = sorted(history, key=lambda row: self.get_latest_timestamp(row.get('timestamp', 0)))
-        
+        sorted_history = sorted(
+            history, key=lambda row: self.get_latest_timestamp(row.get("timestamp", 0))
+        )
+
         # Lấy 5 lượt hội thoại gần nhất để tránh context quá dài
         recent_history = sorted_history[-5:]
-        
+
         context_lines = []
         for row in recent_history:
-            user_text = row.get('originaltext', '').strip()
-            assistant_text = row.get('systemresponse', '').strip()
-            keywords_used = row.get('originalaction', '').strip()
+            user_text = row.get("originaltext", "").strip()
+            assistant_text = row.get("systemresponse", "").strip()
+            keywords_used = row.get("originalaction", "").strip()
 
             if user_text:
-                context_lines.append(f"##Người dùng##: {user_text} (từ khóa đã dùng: {keywords_used})")
-            
+                context_lines.append(
+                    f"##Người dùng##: {user_text} (từ khóa đã dùng: {keywords_used})"
+                )
+
             if assistant_text:
                 context_lines.append(f"##Trợ lý##: {assistant_text}")
-                
+
         return "\n".join(context_lines)
 
     def flatten_timestamp(self, ts):
         flat = []
-        if not isinstance(ts, list): ts = [ts]
+        if not isinstance(ts, list):
+            ts = [ts]
         for t in ts:
-            if isinstance(t, list): flat.extend(self.flatten_timestamp(t))
-            else: flat.append(t)
+            if isinstance(t, list):
+                flat.extend(self.flatten_timestamp(t))
+            else:
+                flat.append(t)
         return flat
 
     def normalize_vehicle_keyword(self, keyword: str) -> str:
         from app.constants import VEHICLE_KEYWORDS
         import difflib
-        if not keyword: return ""
-        matches = difflib.get_close_matches(keyword.lower(), [k.lower() for k in VEHICLE_KEYWORDS], n=1, cutoff=0.6)
+
+        if not keyword:
+            return ""
+        matches = difflib.get_close_matches(
+            keyword.lower(), [k.lower() for k in VEHICLE_KEYWORDS], n=1, cutoff=0.6
+        )
         if matches:
             for k in VEHICLE_KEYWORDS:
-                if k.lower() == matches[0]: return k
+                if k.lower() == matches[0]:
+                    return k
         return keyword
-        
-    async def format_search_results(self, conversation_context: str, question: str, matches: List[Dict[str, Any]], page_token: str, sender_id: str) -> str:
+
+    async def format_search_results(
+        self,
+        conversation_context: str,
+        question: str,
+        matches: List[Dict[str, Any]],
+        page_token: str,
+        sender_id: str,
+    ) -> str:
         if not matches:
             return "Không tìm thấy kết quả phù hợp."
-    
-        asyncio.create_task(self.facebook.send_message(message=get_random_message(FOUND_REGULATIONS_MESSAGES)))
-    
-        #TODO: thời gian rerank kéo dài hơn 30s. Tạm thời bỏ qua bước reranking cho đến khi tìm ra phương án optimize 
-        try:
-            reranked = await self.channel.reranker.rerank(question, matches, top_k=10)
-            if reranked: matches = reranked
-        except Exception as e:
-            logger.error(f"[RERANK] Lỗi khi rerank: {e}")
-    
+
+        # TODO: thời gian rerank kéo dài hơn 30s. Tạm thời bỏ qua bước reranking cho đến khi tìm ra phương án optimize
+        # try:
+        #     settings = get_settings()
+        #     reranked = await self.channel.reranker.rerank(question, matches, min_score=settings.rerank_min_score)
+        #     if reranked: matches = reranked
+        # except Exception as e:
+        #     logger.error(f"[RERANK] Lỗi khi rerank: {e}")
+
         # --- START: Logical Retry Loop for MAX_TOKENS/SAFETY ---
         max_logical_retries = 3
         original_matches = list(matches)
@@ -269,23 +357,36 @@ class MessageProcessor:
                 if not current_matches:
                     logger.error(f"[LLM_RETRY] No more documents to reduce. Failing.")
                     break
-                logger.warning(f"[LLM_RETRY] Attempt {attempt + 1}. Reducing documents to {len(current_matches)}.")
+                logger.warning(
+                    f"[LLM_RETRY] Attempt {attempt + 1}. Reducing documents to {len(current_matches)}."
+                )
 
             full_result_text = ""
+
             def arr_to_str(arr, sep=", "):
-                if not arr: return ""
-                return sep.join([str(x) for x in arr if x not in (None, "")]) if isinstance(arr, list) else str(arr)
+                if not arr:
+                    return ""
+                return (
+                    sep.join([str(x) for x in arr if x not in (None, "")])
+                    if isinstance(arr, list)
+                    else str(arr)
+                )
 
             for i, match in enumerate(current_matches, 1):
-                full_result_text += f"\n\n* Nguồn: {(match.get('structure') or '').strip()}:\n"
-                fullContent = (match.get('fullcontent') or '').strip()
+                full_result_text += (
+                    f"\n\n* Nguồn: {(match.get('structure') or '').strip()}:\n"
+                )
+                fullContent = (match.get("fullcontent") or "").strip()
                 full_result_text += f"{fullContent}"
-                hpbsnoidung = arr_to_str(match.get('hpbsnoidung'), sep="; ")
-                if hpbsnoidung: full_result_text += f"\n- Hình phạt bổ sung: {hpbsnoidung}"
-                bpkpnoidung = arr_to_str(match.get('bpkpnoidung'), sep="; ")
-                if bpkpnoidung: full_result_text += f"\n- Biện pháp khắc phục: {bpkpnoidung}"
-                if match.get('cr_impounding'): full_result_text += f"\n- Tạm giữ phương tiện: 07 ngày"
-            
+                hpbsnoidung = arr_to_str(match.get("hpbsnoidung"), sep="; ")
+                if hpbsnoidung:
+                    full_result_text += f"\n- Hình phạt bổ sung: {hpbsnoidung}"
+                bpkpnoidung = arr_to_str(match.get("bpkpnoidung"), sep="; ")
+                if bpkpnoidung:
+                    full_result_text += f"\n- Biện pháp khắc phục: {bpkpnoidung}"
+                if match.get("cr_impounding"):
+                    full_result_text += f"\n- Tạm giữ phương tiện: 07 ngày"
+
             prompt = (
                 "Bạn là một trợ lý pháp lý AI chuyên nghiệp. Nhiệm vụ của bạn là tổng hợp thông tin từ hai nguồn: **Lịch sử trò chuyện** và **Các đoạn luật liên quan** để đưa ra một câu trả lời duy nhất, liền mạch và tự nhiên cho người dùng.\n\n"
                 "**QUY TẮC BẮT BUỘC:**\n"
@@ -298,135 +399,196 @@ class MessageProcessor:
                 f"### Câu hỏi của người dùng:\n{question}\n\n"
                 "### Trả lời:"
             )
-            
-            asyncio.create_task(self.facebook.send_message(message=f"{get_random_message(SUMMARY_STATUS_MESSAGES)}"))
-            
+
+            asyncio.create_task(
+                self.facebook.send_message(
+                    message=f"{get_random_message(SUMMARY_STATUS_MESSAGES)}"
+                )
+            )
+
             try:
                 # Đã bỏ cấu hình tường minh để sử dụng cài đặt mặc định của thư viện Gemini.
                 answer = await self.channel.llm.generate_text(prompt)
-                
+
                 if answer and answer.strip():
-                    logger.info(f"LLM trả về câu trả lời thành công: \n\tanswer: {_safe_truncate(answer)}")
+                    logger.info(
+                        f"LLM trả về câu trả lời thành công: \n\tanswer: {_safe_truncate(answer)}"
+                    )
                     return answer.strip()
                 else:
-                    logger.warning("LLM trả về câu trả lời hợp lệ nhưng rỗng. Sẽ trả về tin nhắn xin lỗi.")
+                    logger.warning(
+                        "LLM trả về câu trả lời hợp lệ nhưng rỗng. Sẽ trả về tin nhắn xin lỗi."
+                    )
                     break
 
             except GeminiResponseError as e:
-                logger.error(f"[LLM_RETRY] Lỗi nội dung từ Gemini, sẽ thử lại với ít tài liệu hơn. Lý do: {e}")
+                logger.error(
+                    f"[LLM_RETRY] Lỗi nội dung từ Gemini, sẽ thử lại với ít tài liệu hơn. Lý do: {e}"
+                )
                 if attempt < max_logical_retries:
-                    asyncio.create_task(self.facebook.send_message(message=get_random_message(LLM_RETRY_WAIT_MESSAGES)))
+                    asyncio.create_task(
+                        self.facebook.send_message(
+                            message=get_random_message(LLM_RETRY_WAIT_MESSAGES)
+                        )
+                    )
                     continue
                 else:
                     logger.error(f"[LLM_RETRY] Đã hết số lần thử lại logic. Thất bại.")
                     break
 
             except Exception as e:
-                logger.error(f"LLM không sẵn sàng sau tất cả các lần thử lại: {e}\n{traceback.format_exc()}")
+                logger.error(
+                    f"LLM không sẵn sàng sau tất cả các lần thử lại: {e}\n{traceback.format_exc()}"
+                )
                 break
 
         # Fallback message if all attempts fail
-        logger.error("Tất cả các lần gọi LLM đều thất bại. Trả về tin nhắn xin lỗi cho người dùng.")
+        logger.error(
+            "Tất cả các lần gọi LLM đều thất bại. Trả về tin nhắn xin lỗi cho người dùng."
+        )
         return "Xin lỗi bạn, tôi đang gặp một chút trục trặc kỹ thuật trong việc tổng hợp câu trả lời. Bạn có thể vui lòng đặt lại câu hỏi hoặc thử lại sau một lát được không ạ?"
 
-    async def create_facebook_post(self, page_token: str, sender_id: str, history: List[Dict[str, Any]]) -> str:
-        logger.info(f"[MOCK] Creating Facebook post for sender_id={sender_id} with history={history}")
-        return "https://facebook.com/mock_post_url" 
+    async def create_facebook_post(
+        self, page_token: str, sender_id: str, history: List[Dict[str, Any]]
+    ) -> str:
+        logger.info(
+            f"[MOCK] Creating Facebook post for sender_id={sender_id} with history={history}"
+        )
+        return "https://facebook.com/mock_post_url"
 
-    async def _search_and_rerank_task(self, keyword: str, full_query_context: str, vehicle_keywords: List[str]) -> List[Dict[str, Any]]:
+    async def _search_and_rerank_task(
+        self, keyword: str, full_query_context: str, vehicle_keywords: List[str]
+    ) -> List[Dict[str, Any]]:
         """
         Hàm trợ giúp để thực hiện một tác vụ song song: query từ Supabase và sau đó rerank kết quả.
         LƯU Ý: Việc rerank cho mỗi luồng riêng lẻ có thể tốn kém và không hiệu quả về chất lượng kết quả cuối cùng.
         """
         try:
             logger.info(f"[SEARCH_RERANK_TASK] Bắt đầu tác vụ cho từ khóa: '{keyword}'")
-            
+
             # 1. Query Supabase
             embedding = await self.channel.embedder.create_embedding(keyword)
             loop = asyncio.get_event_loop()
             match_count = get_settings().match_count
-            
+
             matches = await loop.run_in_executor(
                 None,
                 lambda: self.channel.supabase.match_documents(
                     embedding=embedding,
                     match_count=match_count,
                     user_question=keyword,
-                    vehicle_keywords=vehicle_keywords
-                )
+                    vehicle_keywords=vehicle_keywords,
+                ),
             )
-            
+
             if not matches:
-                logger.info(f"[SEARCH_RERANK_TASK] Không tìm thấy kết quả nào từ Supabase cho từ khóa: '{keyword}'")
+                logger.info(
+                    f"[SEARCH_RERANK_TASK] Không tìm thấy kết quả nào từ Supabase cho từ khóa: '{keyword}'"
+                )
                 return []
 
-            logger.info(f"[SEARCH_RERANK_TASK] Tìm thấy {len(matches)} kết quả. Bắt đầu rerank cho từ khóa: '{keyword}'")
+            logger.info(
+                f"[SEARCH_RERANK_TASK] Tìm thấy {len(matches)} kết quả. Bắt đầu rerank cho từ khóa: '{keyword}'"
+            )
 
             # 2. Rerank (Tạm thời bỏ qua theo logic code gốc, nhưng nếu bật sẽ chạy ở đây)
             # CẢNH BÁO: Bước này rất tốn kém và làm chậm hệ thống nếu chạy cho mỗi từ khóa.
             # Việc rerank nhiều lần sẽ làm tăng chi phí và có thể chạm giới hạn API.
-            reranked_matches = matches # Mặc định trả về kết quả gốc nếu rerank bị lỗi hoặc tắt
+            reranked_matches = (
+                matches  # Mặc định trả về kết quả gốc nếu rerank bị lỗi hoặc tắt
+            )
             try:
                 # Sử dụng full_query_context để rerank sẽ cho kết quả tốt hơn là chỉ dùng keyword
-                reranked = await self.channel.reranker.rerank(keyword, matches, top_k=10) 
+                settings = get_settings()
+                reranked = await self.channel.reranker.rerank(
+                    keyword, matches, min_score=settings.rerank_min_score
+                )
                 if reranked:
                     reranked_matches = reranked
-                    logger.info(f"[SEARCH_RERANK_TASK] Rerank thành công cho từ khóa '{keyword}', còn lại {len(reranked_matches)} kết quả.")
+                    logger.info(
+                        f"[SEARCH_RERANK_TASK] Rerank thành công cho từ khóa '{keyword}', còn lại {len(reranked_matches)} kết quả."
+                    )
             except Exception as e:
-                logger.error(f"[SEARCH_RERANK_TASK] Lỗi khi rerank cho từ khóa '{keyword}': {e}. Sử dụng kết quả gốc.")
-            
+                logger.error(
+                    f"[SEARCH_RERANK_TASK] Lỗi khi rerank cho từ khóa '{keyword}': {e}. Sử dụng kết quả gốc."
+                )
+
             return reranked_matches
         except Exception as e:
-            logger.error(f"Lỗi trong tác vụ tìm kiếm và rerank cho từ khóa '{keyword}': {e}")
-            return [] # Trả về danh sách rỗng để không làm hỏng luồng chung
+            logger.error(
+                f"Lỗi trong tác vụ tìm kiếm và rerank cho từ khóa '{keyword}': {e}"
+            )
+            return []  # Trả về danh sách rỗng để không làm hỏng luồng chung
 
     async def handle_muc_phat(self, conv, conversation_context, page_token, sender_id):
-        vehicle_str = conv.get('originalvehicle', '')
-        vehicle_keywords = vehicle_str.split(',') if vehicle_str else []
-        action_keywords_str = conv.get('originalaction', '')
-        question = conv.get('originalquestion', '')
+        vehicle_str = conv.get("originalvehicle", "")
+        vehicle_keywords = vehicle_str.split(",") if vehicle_str else []
+        action_keywords_str = conv.get("originalaction", "")
+        question = conv.get("originalquestion", "")
 
         # Sửa lỗi: Tách các cụm từ khóa bằng separator ';;;' thay vì khoảng trắng.
         # Điều này đảm bảo mỗi từ khóa là một cụm từ hoàn chỉnh.
         # Lọc bỏ các chuỗi rỗng có thể xuất hiện nếu action_keywords_str rỗng.
-        tu_khoa_list = [kw.strip() for kw in action_keywords_str.split(';;;') if kw.strip()]
+        tu_khoa_list = [
+            kw.strip() for kw in action_keywords_str.split(";;;") if kw.strip()
+        ]
 
         if not tu_khoa_list and not question:
-             return "Để tra cứu mức phạt, bạn vui lòng cung cấp hành vi vi phạm nhé."
+            return "Để tra cứu mức phạt, bạn vui lòng cung cấp hành vi vi phạm nhé."
 
         main_query_for_context = question or action_keywords_str
 
         try:
             # --- 1. Tạo và chạy song song các tác vụ Query -> Rerank ---
             search_terms = tu_khoa_list if tu_khoa_list else [main_query_for_context]
-            tasks = [self._search_and_rerank_task(term, main_query_for_context, vehicle_keywords) for term in search_terms]
+            tasks = [
+                self._search_and_rerank_task(
+                    term, main_query_for_context, vehicle_keywords
+                )
+                for term in search_terms
+            ]
+            asyncio.create_task(
+                self.facebook.send_message(
+                    message=get_random_message(FOUND_REGULATIONS_MESSAGES)
+                )
+            )
             list_of_reranked_results = await asyncio.gather(*tasks)
-            
+
             # --- 2. Tổng hợp và loại bỏ kết quả trùng lặp ---
             combined_matches = []
             seen_ids = set()
             for reranked_list in list_of_reranked_results:
                 for match in reranked_list:
-                    match_id = match.get('doc_id')
+                    match_id = match.get("doc_id")
                     if match_id and match_id not in seen_ids:
                         combined_matches.append(match)
                         seen_ids.add(match_id)
-            
-            logger.info(f"Tổng hợp được {len(combined_matches)} văn bản duy nhất từ các tác vụ song song.")
+
+            logger.info(
+                f"Tổng hợp được {len(combined_matches)} văn bản duy nhất từ các tác vụ song song."
+            )
 
             # --- 3. Tạo câu trả lời ---
             if combined_matches:
-                response = await self.format_search_results(conversation_context, main_query_for_context, combined_matches, page_token, sender_id)
+                response = await self.format_search_results(
+                    conversation_context,
+                    main_query_for_context,
+                    combined_matches,
+                    page_token,
+                    sender_id,
+                )
             else:
                 response = "Xin lỗi, tôi không tìm thấy thông tin phù hợp với hành vi bạn mô tả."
         except Exception as e:
             logger.error(f"Lỗi khi tra cứu mức phạt: {e}\n{traceback.format_exc()}")
             response = "Đã có lỗi xảy ra trong quá trình tra cứu. Vui lòng thử lại sau."
-            
-        conv['isdone'] = True
+
+        conv["isdone"] = True
         return response
 
-    async def _handle_general_question(self, conversation_context: str, message_text: str, topic: str) -> str:
+    async def _handle_general_question(
+        self, conversation_context: str, message_text: str, topic: str
+    ) -> str:
         prompt = (
             "Bạn là một trợ lý AI am hiểu về luật giao thông Việt Nam. "
             "Dựa vào lịch sử trò chuyện và kiến thức của bạn, hãy trả lời câu hỏi của người dùng một cách rõ ràng, ngắn gọn và chính xác.\n"
@@ -440,41 +602,57 @@ class MessageProcessor:
             if answer and answer.strip():
                 return answer.strip()
             # If LLM returns an empty answer, provide a generic response.
-            logger.warning(f"LLM returned an empty answer for general question on topic: {topic}")
+            logger.warning(
+                f"LLM returned an empty answer for general question on topic: {topic}"
+            )
             return "Cảm ơn bạn đã hỏi, nhưng tôi chưa có thông tin về vấn đề này. Bạn có thể hỏi câu khác được không?"
         except (GeminiResponseError, Exception) as e:
             logger.error(f"Error handling general question on topic '{topic}': {e}")
             return "Xin lỗi bạn, tôi đang gặp một chút trục trặc kỹ thuật và chưa thể trả lời câu hỏi này. Bạn vui lòng thử lại sau một lát nhé."
 
     async def handle_khac(self, conv, conversation_context, page_token, sender_id):
-        conv['isdone'] = True
-        return await self._handle_general_question(conversation_context, conv['originaltext'], "một vấn đề khác")
+        conv["isdone"] = True
+        return await self._handle_general_question(
+            conversation_context, conv["originaltext"], "một vấn đề khác"
+        )
 
     async def handle_quy_tac(self, conv, conversation_context, page_token, sender_id):
-        conv['isdone'] = True
-        return await self.handle_muc_phat(conv, conversation_context, page_token, sender_id)
+        conv["isdone"] = True
+        return await self.handle_muc_phat(
+            conv, conversation_context, page_token, sender_id
+        )
 
     async def handle_bao_hieu(self, conv, conversation_context, page_token, sender_id):
-        conv['isdone'] = True
-        return await self.handle_muc_phat(conv, conversation_context, page_token, sender_id)
+        conv["isdone"] = True
+        return await self.handle_muc_phat(
+            conv, conversation_context, page_token, sender_id
+        )
 
     async def handle_quy_trinh(self, conv, conversation_context, page_token, sender_id):
-        conv['isdone'] = True
-        return await self.handle_muc_phat(conv, conversation_context, page_token, sender_id)
+        conv["isdone"] = True
+        return await self.handle_muc_phat(
+            conv, conversation_context, page_token, sender_id
+        )
 
     async def handle_ca_nhan(self, conv, conversation_context, page_token, sender_id):
         prompt = (
             "Biết rằng bạn đã có lịch sử trao đổi như sau:"
             f"Lịch sử:\n{conversation_context}\n\n"
             'Với các thông tin sau: "Bạn có tên là WeThoong AI, là trợ lý giao thông thông minh. Bạn được anh Viet Cat tạo ra và facebook cá nhân của anh ấy là https://facebook.com/vietcat". '
-            'Không được trả lời bạn là AI của Google, OpenAI, hay bất kỳ hãng nào khác. '
-            'Hãy trả lời thông minh, hài hước, ngắn gọn cho câu hỏi sau:\n'
+            "Không được trả lời bạn là AI của Google, OpenAI, hay bất kỳ hãng nào khác. "
+            "Hãy trả lời thông minh, hài hước, ngắn gọn cho câu hỏi sau:\n"
             f'Câu hỏi:\n"{conv["originaltext"]}"'
         )
         try:
             answer = await self.channel.llm.generate_text(prompt)
-            conv['isdone'] = True
-            return answer.strip() if answer and answer.strip() else "Chào bạn, mình là WeThoong AI đây!"
+            conv["isdone"] = True
+            return (
+                answer.strip()
+                if answer and answer.strip()
+                else "Chào bạn, mình là WeThoong AI đây!"
+            )
         except Exception as e:
             logger.error(f"Lỗi khi xử lý câu hỏi cá nhân: {e}")
-            return "Chào bạn, mình là WeThoong AI, trợ lý giao thông thông minh của bạn!"
+            return (
+                "Chào bạn, mình là WeThoong AI, trợ lý giao thông thông minh của bạn!"
+            )

app/reranker.py

@@ -68,13 +68,15 @@ class Reranker:
             
             logger.info(f"[RERANK] Cleaned cache: removed {len(keys_to_remove)} old entries")
 
-    def _get_cached_result(self, cache_key: str, top_k: int) -> List[Dict]:
+    def _get_cached_result(self, cache_key: str, min_score: float) -> List[Dict]:
         """Lấy kết quả từ cache nếu có và còn hợp lệ."""
         if cache_key in self._rerank_cache:
             current_time = time.time()
             if current_time - self._cache_timestamps.get(cache_key, 0) <= self._cache_ttl:
-                cached_result = self._rerank_cache[cache_key][:top_k]
-                logger.info(f"[RERANK] Cache hit for query, returning {len(cached_result)} cached results")
+                # Lọc theo điểm thay vì lấy top_k
+                cached_docs = self._rerank_cache[cache_key]
+                cached_result = [doc for doc in cached_docs if doc.get('rerank_score', 0) >= min_score]
+                logger.info(f"[RERANK] Cache hit for query, returning {len(cached_result)} cached results with score >= {min_score}")
                 return cached_result
             else:
                 # Cache đã hết hạn, xóa
@@ -206,24 +208,24 @@ class Reranker:
             return doc
 
     @timing_decorator_async
-    async def rerank(self, query: str, docs: List[Dict], top_k: int = 5) -> List[Dict]:
+    async def rerank(self, query: str, docs: List[Dict], min_score: float = 7.0) -> List[Dict]:
         """
-        Rerank docs theo độ liên quan với query, trả về top_k docs.
+        Rerank docs theo độ liên quan với query, trả về các docs có điểm >= min_score.
         Sử dụng batch processing và caching để tối ưu hiệu suất.
         """
-        logger.info(f"[RERANK] Start rerank for query: {query} | docs: {len(docs)} | top_k: {top_k}")
+        logger.info(f"[RERANK] Start rerank for query: {query} | docs: {len(docs)} | min_score: {min_score}")
         
         if not docs:
             return []
         
         # Kiểm tra cache trước
         cache_key = self._get_cache_key(query, docs)
-        cached_result = self._get_cached_result(cache_key, top_k)
+        cached_result = self._get_cached_result(cache_key, min_score)
         
         if cached_result:
             return cached_result
         
-        # Giới hạn số lượng docs để rerank - chỉ rerank top 15 docs có similarity cao nhất
+        # Giới hạn số lượng docs để rerank - chỉ rerank top N docs có similarity cao nhất
         max_docs_to_rerank = self.max_docs_to_rerank
         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})")
@@ -245,12 +247,14 @@ class Reranker:
                     doc['rerank_score'] = 0
                     scored.append(doc)
         
-        # Sort theo score và trả về top_k
-        scored = sorted(scored, key=lambda x: x['rerank_score'], reverse=True)
-        result = scored[:top_k]
+        # Sort theo score
+        scored = sorted(scored, key=lambda x: x.get('rerank_score', 0), reverse=True)
         
-        # Cache kết quả với system mới
+        # Lọc theo min_score
+        result = [doc for doc in scored if doc.get('rerank_score', 0) >= min_score]
+        
+        # Cache kết quả đã được chấm điểm (toàn bộ, trước khi lọc)
         self._set_cached_result(cache_key, scored)
         
-        logger.info(f"[RERANK] Top reranked docs: {result[:2]}...{result[-2:]}")
-        return result 
+        logger.info(f"[RERANK] Found {len(result)} docs with score >= {min_score}. Top results: {result[:2]}...{result[-2:] if len(result) > 2 else ''}")
+        return result