update error handling

app/constants.py

@@ -206,5 +206,20 @@ SUMMARY_STATUS_MESSAGES = [
     "Mình đang chốt lại các điểm chính để trả lời một cách trọn vẹn"
 ]
 
+# LLM retry wait messages for Facebook notifications when prompt is too large
+LLM_RETRY_WAIT_MESSAGES = [
+    "Lượng thông tin cần tổng hợp hơi nhiều, bạn cho mình thêm chút thời gian để xử lý nhé.",
+    "Thông tin khá phức tạp, mình cần thêm chút thời gian để phân tích kỹ hơn.",
+    "Để đảm bảo câu trả lời chính xác nhất, mình cần xem xét lại các văn bản này cẩn thận hơn. Bạn chờ chút nha.",
+    "Mình đang sàng lọc lại các văn bản luật để tìm ra câu trả lời phù hợp nhất. Bạn đợi mình một lát nhé.",
+    "Có vẻ như câu hỏi của bạn liên quan đến nhiều quy định, mình cần thêm thời gian để tổng hợp lại.",
+    "Để tránh nhầm lẫn, mình đang đối chiếu thông tin từ nhiều nguồn. Sẽ sớm có câu trả lời cho bạn thôi.",
+    "Thông tin ban đầu khá rộng, mình đang thu hẹp phạm vi để trả lời chính xác hơn. Bạn chờ mình xíu nha.",
+    "Mình đang sắp xếp lại các dữ kiện để câu trả lời được mạch lạc. Cảm ơn bạn đã kiên nhẫn!",
+    "Câu hỏi này cần phân tích sâu hơn một chút. Mình sẽ phản hồi ngay khi có kết quả nhé.",
+    "Mình đang nỗ lực để đưa ra câu trả lời tốt nhất. Quá trình này có thể mất thêm vài giây, mong bạn thông cảm.",
+    "Dữ liệu khá lớn, mình đang tóm tắt lại những điểm chính. Bạn vui lòng đợi trong giây lát."
+]
+
 SHEET_RANGE = 'chat!A2:N'
 VERSION_NUMBER = 123456800

app/gemini_client.py

@@ -2,12 +2,25 @@ from google.generativeai.embedding import embed_content
 from google.generativeai.client import configure
 from google.generativeai.generative_models import GenerativeModel
 from loguru import logger
-from .request_limit_manager import RequestLimitManager
 from typing import List, Optional
+from google.generativeai.types import GenerationConfig
+
+from .request_limit_manager import RequestLimitManager
 from .utils import (
     _safe_truncate
 )
 
+class GeminiResponseError(Exception):
+    """Custom exception for non-retriable Gemini response issues like safety or token limits."""
+    def __init__(self, message, finish_reason=None, usage_metadata=None):
+        super().__init__(message)
+        self.finish_reason = finish_reason
+        self.usage_metadata = usage_metadata
+
+    def __str__(self):
+        usage_str = f"Prompt: {self.usage_metadata.prompt_token_count}, Candidates: {self.usage_metadata.candidates_token_count}, Total: {self.usage_metadata.total_token_count}" if self.usage_metadata else "N/A"
+        return f"{super().__str__()} (Finish Reason: {self.finish_reason}, Usage: {usage_str})"
+
 class GeminiClient:
     def __init__(self):
         self.limit_manager = RequestLimitManager("gemini")
@@ -56,21 +69,30 @@ class GeminiClient:
                 _model = self._get_model_instance(key, model)
                 
                 response = _model.generate_content(prompt, **kwargs)
-                self.limit_manager.log_request(key, model, success=True)
                 
+                # Kiểm tra các vấn đề về nội dung (MAX_TOKENS, SAFETY, etc.)
+                if not response.candidates or response.candidates[0].finish_reason.name not in ["STOP", "FINISH_REASON_UNSPECIFIED"]:
+                    finish_reason = response.candidates[0].finish_reason if response.candidates else None
+                    usage_metadata = response.usage_metadata if hasattr(response, 'usage_metadata') else None
+                    error_message = f"Gemini response finished with reason: {finish_reason.name if finish_reason else 'UNKNOWN'}."
+                    
+                    # Đây là lỗi logic, raise để lớp gọi xử lý (ví dụ: retry với prompt ngắn hơn)
+                    raise GeminiResponseError(
+                        error_message,
+                        finish_reason=finish_reason.name if finish_reason else 'UNKNOWN',
+                        usage_metadata=usage_metadata
+                    )
+
+                self.limit_manager.log_request(key, model, success=True)
                 if hasattr(response, 'usage_metadata'):
                     logger.info(f"[GEMINI][USAGE] Prompt Token Count: {response.usage_metadata.prompt_token_count} - Candidate Token Count: {response.usage_metadata.candidates_token_count} - Total Token Count: {response.usage_metadata.total_token_count}")
                 
-                if hasattr(response, 'text'):
-                    logger.info(f"[GEMINI][TEXT_RESPONSE] {_safe_truncate(response.text)}")
-                    return response.text
-                elif hasattr(response, 'candidates') and response.candidates:
-                    logger.info(f"[GEMINI][CANDIDATES_RESPONSE] {_safe_truncate(response.candidates[0].content.parts[0].text)}")
-                    return response.candidates[0].content.parts[0].text
-                
-                logger.info(f"[GEMINI][RAW_RESPONSE] {response}")
-                return str(response)
-                
+                logger.info(f"[GEMINI][TEXT_RESPONSE] {_safe_truncate(response.text)}")
+                return response.text
+            except GeminiResponseError as e:
+                # Lỗi nội dung, không thể retry bằng cách đổi key. Propagate lên.
+                logger.error(f"[GEMINI] Non-retriable content error: {e}")
+                raise e
             except Exception as e:
                 import re
                 msg = str(e)
@@ -90,10 +112,10 @@ class GeminiClient:
                     last_error = e
                     continue
                 else:
-                    # Lỗi khác không phải rate limit
+                    # Lỗi khác không phải rate limit (vd: timeout, server error)
+                    # sẽ được propagate lên để lớp llm.py xử lý retry với backoff.
                     logger.error(f"[GEMINI] Error generating text: {e}")
-                    last_error = e
-                    break
+                    raise e
         
         raise last_error or RuntimeError("No available Gemini API key/model")
 

app/llm.py

@@ -6,10 +6,11 @@ import re
 import os
 import asyncio
 
+from tenacity import retry, stop_after_attempt, wait_exponential
 import httpx
 from loguru import logger
 
-from .gemini_client import GeminiClient
+from .gemini_client import GeminiClient, GeminiResponseError
 from .config import get_settings
 from .utils import (
     timing_decorator_async,
@@ -18,6 +19,18 @@ from .utils import (
     _safe_truncate
 )
 
+# --- Retry decorator cho các lỗi tạm thời của LLM (network, server-side) ---
+retry_on_llm_transient_error = retry(
+    stop=stop_after_attempt(4), # 1 lần gọi gốc + 3 lần thử lại
+    wait=wait_exponential(multiplier=5, min=10, max=60), # Chờ 10s, 20s, 40s
+    # Chỉ retry nếu exception KHÔNG PHẢI là GeminiResponseError (lỗi nội dung)
+    retry=lambda e: not isinstance(e, GeminiResponseError),
+    before_sleep=lambda retry_state: logger.warning(
+        f"[LLM][RETRY] LLM call failed with transient error, retrying... "
+        f"Attempt: {retry_state.attempt_number}, Error: {retry_state.outcome.exception()}"
+    )
+)
+
 def _parse_json_from_text(text: str) -> Optional[Union[List[Dict[str, Any]], Dict[str, Any]]]:
     """Best-effort JSON extractor from LLM free-form responses.
 
@@ -241,9 +254,12 @@ class LLMClient:
         logger.error("HFS API response is None")
         raise RuntimeError("HFS API response is None")
 
+    @retry_on_llm_transient_error
     async def _generate_gemini(self, prompt: str, **kwargs) -> str:
         loop = asyncio.get_event_loop()
         # Đảm bảo kwargs được truyền nếu GeminiClient hỗ trợ
+        # Decorator sẽ xử lý retry cho các lỗi tạm thời (network, server).
+        # GeminiResponseError (lỗi nội dung) sẽ được raise lên cho message_processor xử lý.
         return await loop.run_in_executor(None, lambda: self.gemini_client.generate_text(prompt, **kwargs))
 
     @timing_decorator_async

app/message_processor.py

@@ -3,9 +3,11 @@ import asyncio
 import traceback
 import json
 from loguru import logger
-from .constants import START_SEARCHING_MESSAGES, SUMMARY_STATUS_MESSAGES, PROCESSING_STATUS_MESSAGES, FOUND_REGULATIONS_MESSAGES, BATCH_STATUS_MESSAGES
-from .utils import get_random_message
+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
 
@@ -236,57 +238,89 @@ class MessageProcessor:
     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}")
-        
-        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)
-
-        for i, match in enumerate(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"{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"
-        
-        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"
-            "1.  **Hành văn tự nhiên:** Trả lời thẳng vào câu hỏi. **Không** bắt đầu bằng các cụm từ như 'Dựa trên thông tin được cung cấp', 'Theo các đoạn luật', v.v.\n"
-            "2.  **Nguồn trích dẫn:** Khi cần trích dẫn, chỉ nêu nguồn từ văn bản luật (ví dụ: 'theo Khoản 1, Điều 5...'). **Tuyệt đối không** trích dẫn nguồn là 'từ lịch sử trò chuyện'.\n"
-            "3.  **Tổng hợp thông tin:** Phải kết hợp thông tin từ cả hai nguồn một cách mượt mà. Ví dụ, nếu lịch sử trò chuyện đã có mức phạt cho xe máy, và câu hỏi hiện tại là về xe máy điện, hãy sử dụng thông tin từ văn bản luật để xác định xe máy điện thuộc nhóm xe nào, sau đó áp dụng mức phạt đã biết từ lịch sử.\n"
-            "4.  **Ngắn gọn, chính xác:** Luôn trả lời ngắn gọn, rõ ràng và chỉ dựa vào thông tin được cung cấp.\n\n"
-            f"### Lịch sử trò chuyện:\n{conversation_context}\n\n"
-            f"### Các đoạn luật liên quan:\n{full_result_text}\n\n"
-            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)}"))
-        
-        try:
-            answer = await self.channel.llm.generate_text(prompt)
-            if answer and answer.strip():
-                logger.info(f"LLM trả về câu trả lời: \n\tanswer: {answer}")
-                return answer.strip()
-            else:
-                logger.error(f"LLM không trả về câu trả lời phù hợp: \n\tanswer: {answer}")
-        except Exception as e:
-            logger.error(f"LLM không sẵn sàng: {e}\n{traceback.format_exc()}")
-        
-        return "Dựa trên thông tin bạn cung cấp, tôi đã tìm thấy một số quy định liên quan. Tuy nhiên, tôi đang gặp chút khó khăn trong việc tóm tắt. Bạn vui lòng tham khảo nội dung chi tiết trong các văn bản luật nhé."
+    
+            # --- START: Logical Retry Loop for MAX_TOKENS/SAFETY ---
+            max_logical_retries = 3
+            original_matches = list(matches)
+    
+            for attempt in range(max_logical_retries + 1):
+                current_matches = original_matches
+                if attempt > 0:
+                    reduction_factor = 1.0 - (0.2 * attempt)
+                    new_count = int(len(original_matches) * reduction_factor)
+                    current_matches = original_matches[:new_count]
+                    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)}.")
+    
+                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)
+    
+                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"{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"
+                
+                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"
+                    "1.  **Hành văn tự nhiên:** Trả lời thẳng vào câu hỏi. **Không** bắt đầu bằng các cụm từ như 'Dựa trên thông tin được cung cấp', 'Theo các đoạn luật', v.v.\n"
+                    "2.  **Nguồn trích dẫn:** Khi cần trích dẫn, chỉ nêu nguồn từ văn bản luật (ví dụ: 'theo Khoản 1, Điều 5...'). **Tuyệt đối không** trích dẫn nguồn là 'từ lịch sử trò chuyện'.\n"
+                    "3.  **Tổng hợp thông tin:** Phải kết hợp thông tin từ cả hai nguồn một cách mượt mà. Ví dụ, nếu lịch sử trò chuyện đã có mức phạt cho xe máy, và câu hỏi hiện tại là về xe máy điện, hãy sử dụng thông tin từ văn bản luật để xác định xe máy điện thuộc nhóm xe nào, sau đó áp dụng mức phạt đã biết từ lịch sử.\n"
+                    "4.  **Ngắn gọn, chính xác:** Luôn trả lời ngắn gọn, rõ ràng và chỉ dựa vào thông tin được cung cấp.\n\n"
+                    f"### Lịch sử trò chuyện:\n{conversation_context}\n\n"
+                    f"### Các đoạn luật liên quan:\n{full_result_text}\n\n"
+                    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)}"))
+                
+                try:
+                    from google.generativeai.types import GenerationConfig
+                    generation_config = GenerationConfig(max_output_tokens=2048, temperature=0.5)
+                    answer = await self.channel.llm.generate_text(prompt, generation_config=generation_config)
+                    
+                    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)}")
+                        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.")
+                        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}")
+                    if attempt < max_logical_retries:
+                        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()}")
+                    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.")
+            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}")

app/supabase_db.py

@@ -1,15 +1,24 @@
 from typing import Any, Dict, List, Optional
 from postgrest.types import CountMethod
-from supabase.client import create_client, Client
+from supabase.client import create_client, Client, ClientOptions
+from postgrest.exceptions import APIError
 from loguru import logger
 import re
-import time
 import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
 from .utils import timing_decorator_sync
 from .constants import VEHICLE_KEYWORD_TO_COLUMN, VIETNAMESE_STOP_WORDS, VIETNAMESE_STOP_PHRASES
 from .config import get_settings
 
+# --- Cơ chế retry mạnh mẽ và có thể tái sử dụng ---
+retry_on_supabase_error = retry(
+    stop=stop_after_attempt(4), # 1 lần gọi gốc + 3 lần thử lại
+    wait=wait_exponential(multiplier=5, min=10, max=60), # Chờ 10s, 20s, 40s
+    retry=retry_if_exception_type((httpx.HTTPError, APIError)),
+    before_sleep=lambda retry_state: logger.warning(f"Supabase call failed, retrying... Attempt: {retry_state.attempt_number}, Error: {retry_state.outcome.exception()}")
+)
+
 def remove_stop_phrases(text, stop_phrases):
     for phrase in stop_phrases:
         # Sửa: Không escape dấu cách trong phrase, chỉ escape các ký tự đặc biệt khác
@@ -25,11 +34,15 @@ class SupabaseClient:
         Input: url (str), key (str)
         Output: SupabaseClient instance.
         """
-        self.client: Client = create_client(url, key)
+        # Tăng thời gian timeout mặc định của client để xử lý các truy vấn nặng
+        opts = ClientOptions(postgrest_client_timeout=60.0)
+        self.client: Client = create_client(url, key, options=opts)
+        
         settings = get_settings()
         self.default_match_count = settings.match_count
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def get_page_token(self, page_id: str):
         """
         Lấy access token của Facebook page từ Supabase.
@@ -41,11 +54,15 @@ class SupabaseClient:
             if response.data and len(response.data) > 0:
                 return response.data[0]['token']
             return None
-        except Exception as e:
-            logger.error(f"Error getting page token: {e}")
-            return None
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error getting page token after retries: {e}")
+            raise # Ném lại lỗi để tenacity có thể bắt và retry
+        except Exception as e: # Bắt các lỗi không mong muốn khác
+            logger.exception(f"An unexpected error occurred while getting page token: {e}")
+            return None # Không retry với lỗi không mong muốn
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def match_documents(self, embedding: List[float], match_count: Optional[int] = None, vehicle_keywords: Optional[List[str]] = None, user_question: str = '', keyword_threshold: float = 0.01, vector_threshold: float = 0.3, rrf_k: int = 60):
         """
         Truy vấn vector similarity search qua RPC match_documents.
@@ -86,30 +103,21 @@ class SupabaseClient:
             if vehicle_columns:
                 payload['vehicle_filters'] = vehicle_columns
 
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                response = self.client.rpc(
-                    'match_documents',
-                    payload
-                ).execute()
-
-                if response.data:
-                    return response.data
-                return []
-            except httpx.TimeoutException:
-                logger.warning(f"Supabase RPC 'match_documents' timeout on attempt {attempt + 1}/{max_retries}. Retrying...")
-                if attempt == max_retries - 1:
-                    logger.error(f"Supabase RPC failed after {max_retries} attempts due to timeout.")
-                    return []
-                time.sleep(1 * (2 ** attempt))  # Exponential backoff: 1s, 2s, 4s
-            except Exception as e:
-                logger.error(f"Error matching documents: {e}")
-                return []
-        
-        return [] # Fallback in case loop finishes without returning
+        try:
+            response = self.client.rpc(
+                'match_documents',
+                payload
+            ).execute()
+            return response.data or []
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error matching documents after retries: {e}")
+            raise
+        except Exception as e:
+            logger.exception(f"An unexpected error occurred in match_documents: {e}")
+            return []
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def store_embedding(self, text: str, embedding: List[float], metadata: Dict[str, Any]):
         """
         Lưu embedding vào Supabase.
@@ -124,11 +132,15 @@ class SupabaseClient:
             }).execute()
             
             return bool(response.data)
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error storing embedding after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"Error storing embedding: {e}")
+            logger.exception(f"An unexpected error occurred while storing embedding: {e}")
             return False
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def store_document_chunk(self, chunk_data: Dict[str, Any]) -> bool:
         """
         Lưu document chunk vào Supabase.
@@ -181,11 +193,15 @@ class SupabaseClient:
                 logger.error(f"Failed to store chunk {processed_data.get('id', 'unknown')}")
                 return False
                 
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error storing document chunk after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"Error storing document chunk: {e}")
+            logger.exception(f"An unexpected error occurred while storing document chunk: {e}")
             return False
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def delete_all_document_chunks(self) -> bool:
         """
         Xóa toàn bộ bảng document_chunks.
@@ -196,11 +212,15 @@ class SupabaseClient:
             response = self.client.table('document_chunks').delete().execute()
             logger.info(f"Successfully deleted all document chunks")
             return True
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error deleting all document chunks after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"Error deleting all document chunks: {e}")
+            logger.exception(f"An unexpected error occurred while deleting all document chunks: {e}")
             return False
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def get_document_chunks_by_vanbanid(self, vanbanid: int) -> List[Dict[str, Any]]:
         """
         Lấy tất cả chunks của một văn bản theo vanbanid.
@@ -213,11 +233,15 @@ class SupabaseClient:
                 logger.info(f"Found {len(response.data)} chunks for vanbanid {vanbanid}")
                 return response.data
             return []
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error getting document chunks for vanbanid {vanbanid} after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"Error getting document chunks for vanbanid {vanbanid}: {e}")
+            logger.exception(f"An unexpected error occurred while getting document chunks for vanbanid {vanbanid}: {e}")
             return []
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def delete_document_chunks_by_vanbanid(self, vanbanid: int) -> bool:
         """
         Xóa tất cả chunks của một văn bản theo vanbanid.
@@ -228,11 +252,15 @@ class SupabaseClient:
             response = self.client.table('document_chunks').delete().eq('vanbanid', vanbanid).execute()
             logger.info(f"Successfully deleted all chunks for vanbanid {vanbanid}")
             return True
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"Error deleting chunks for vanbanid {vanbanid} after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"Error deleting chunks for vanbanid {vanbanid}: {e}")
+            logger.exception(f"An unexpected error occurred while deleting chunks for vanbanid {vanbanid}: {e}")
             return False
 
     @timing_decorator_sync
+    @retry_on_supabase_error
     def get_all_document_chunks(self) -> List[Dict[str, Any]]:
         """
         Lấy toàn bộ dữ liệu từ bảng document_chunks.
@@ -283,6 +311,9 @@ class SupabaseClient:
             logger.info(f"[SUPABASE] Fetched {page_count} pages with page_size={page_size}")
             return all_chunks
                 
+        except (httpx.HTTPError, APIError) as e:
+            logger.error(f"[SUPABASE] Error fetching document chunks after retries: {e}")
+            raise
         except Exception as e:
-            logger.error(f"[SUPABASE] Error fetching document chunks: {e}")
+            logger.exception(f"An unexpected error occurred while fetching document chunks: {e}")
             return []