add LLM

app/llm.py

@@ -0,0 +1,504 @@
+from typing import List, Dict, Any, Optional, Union
+import httpx
+import json
+from loguru import logger
+from tenacity import retry, stop_after_attempt, wait_exponential
+import os
+
+from .utils import timing_decorator_async, timing_decorator_sync
+
+class LLMClient:
+    """
+    Client để tương tác với các mô hình ngôn ngữ lớn (LLM).
+    Hỗ trợ nhiều provider: OpenAI, HuggingFace, local models, etc.
+    """
+    
+    def __init__(self, provider: str = "openai", **kwargs):
+        """
+        Khởi tạo LLMClient.
+        
+        Args:
+            provider (str): Loại provider ("openai", "huggingface", "local", "custom")
+            **kwargs: Các tham số cấu hình khác
+        """
+        self.provider = provider.lower()
+        self._client = httpx.AsyncClient(timeout=60.0)
+        
+        # Cấu hình theo provider
+        if self.provider == "openai":
+            self._setup_openai(kwargs)
+        elif self.provider == "huggingface":
+            self._setup_huggingface(kwargs)
+        elif self.provider == "local":
+            self._setup_local(kwargs)
+        elif self.provider == "custom":
+            self._setup_custom(kwargs)
+        elif self.provider == "hfs":
+            self._setup_HFS(kwargs)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+    
+    def _setup_openai(self, config: Dict[str, Any]):
+        """Cấu hình cho OpenAI."""
+        self.api_key = config.get("api_key") or os.getenv("OPENAI_API_KEY")
+        self.base_url = config.get("base_url", "https://api.openai.com/v1")
+        self.model = config.get("model", "gpt-3.5-turbo")
+        self.max_tokens = config.get("max_tokens", 1000)
+        self.temperature = config.get("temperature", 0.7)
+        
+        if not self.api_key:
+            raise ValueError("OpenAI API key is required")
+    
+    def _setup_huggingface(self, config: Dict[str, Any]):
+        """Cấu hình cho HuggingFace."""
+        self.api_key = config.get("api_key") or os.getenv("HUGGINGFACE_API_KEY")
+        self.base_url = config.get("base_url", "https://api-inference.huggingface.co")
+        self.model = config.get("model", "microsoft/DialoGPT-medium")
+        self.max_tokens = config.get("max_tokens", 1000)
+        self.temperature = config.get("temperature", 0.7)
+        
+        if not self.api_key:
+            raise ValueError("HuggingFace API key is required")
+    
+    def _setup_local(self, config: Dict[str, Any]):
+        """Cấu hình cho local model."""
+        self.base_url = config.get("base_url", "http://localhost:8000")
+        self.model = config.get("model", "default")
+        self.max_tokens = config.get("max_tokens", 1000)
+        self.temperature = config.get("temperature", 0.7)
+    
+    def _setup_custom(self, config: Dict[str, Any]):
+        """Cấu hình cho custom provider."""
+        self.base_url = config.get("base_url")
+        self.api_key = config.get("api_key")
+        self.model = config.get("model", "default")
+        self.max_tokens = config.get("max_tokens", 1000)
+        self.temperature = config.get("temperature", 0.7)
+
+    def _setup_HFS(self, config: Dict[str, Any]):
+        """Cấu hình cho custom provider."""
+        self.base_url = config.get("base_url")
+        
+        if not self.base_url:
+            raise ValueError("Custom provider requires base_url")
+    
+    @timing_decorator_async
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10), reraise=True)
+    async def generate_text(
+        self, 
+        prompt: str, 
+        system_prompt: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """
+        Tạo text từ prompt sử dụng LLM.
+        
+        Args:
+            prompt (str): Prompt đầu vào
+            system_prompt (str, optional): System prompt
+            **kwargs: Các tham số bổ sung
+            
+        Returns:
+            str: Text được tạo ra
+        """
+        try:
+            if self.provider == "openai":
+                return await self._generate_openai(prompt, system_prompt, **kwargs)
+            elif self.provider == "huggingface":
+                return await self._generate_huggingface(prompt, **kwargs)
+            elif self.provider == "local":
+                return await self._generate_local(prompt, **kwargs)
+            elif self.provider == "custom":
+                return await self._generate_custom(prompt, **kwargs)
+            elif self.provider == "hfs":
+                return await self._generate_hfs(prompt, **kwargs)
+            else:
+                raise ValueError(f"Unsupported provider: {self.provider}")
+                
+        except Exception as e:
+            logger.error(f"Error generating text with {self.provider}: {e}")
+            raise
+    
+    async def _generate_openai(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> str:
+        """Generate text với OpenAI API."""
+        messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        payload = {
+            "model": kwargs.get("model", self.model),
+            "messages": messages,
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": kwargs.get("temperature", self.temperature),
+            "stream": False
+        }
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = await self._client.post(
+            f"{self.base_url}/chat/completions",
+            headers=headers,
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+    
+    async def _generate_huggingface(self, prompt: str, **kwargs) -> str:
+        """Generate text với HuggingFace API."""
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": kwargs.get("max_tokens", self.max_tokens),
+                "temperature": kwargs.get("temperature", self.temperature),
+                "return_full_text": False
+            }
+        }
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = await self._client.post(
+            f"{self.base_url}/models/{self.model}",
+            headers=headers,
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data[0]["generated_text"]
+    
+    async def _generate_local(self, prompt: str, **kwargs) -> str:
+        """Generate text với local model."""
+        payload = {
+            "prompt": prompt,
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": kwargs.get("temperature", self.temperature),
+            "model": kwargs.get("model", self.model)
+        }
+        
+        response = await self._client.post(
+            f"{self.base_url}/generate",
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data.get("text", "")
+    
+    async def _generate_custom(self, prompt: str, **kwargs) -> str:
+        """Generate text với custom provider."""
+        payload = {
+            "prompt": prompt,
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": kwargs.get("temperature", self.temperature),
+            "model": kwargs.get("model", self.model)
+        }
+        
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        
+        response = await self._client.post(
+            f"{self.base_url}/generate",
+            headers=headers,
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data.get("text", "")
+    
+    async def _generate_hfs(self, prompt: str, **kwargs) -> str:
+        """Generate text với HFS provider."""
+        payload = {
+            "prompt": prompt
+        }
+        
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        
+        response = await self._client.post(
+            f"{self.base_url}/purechat",
+            headers=headers,
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data.get("response", "")
+
+    @timing_decorator_async
+    async def chat(
+        self, 
+        messages: List[Dict[str, str]], 
+        **kwargs
+    ) -> str:
+        """
+        Chat với LLM sử dụng conversation history.
+        
+        Args:
+            messages (List[Dict]): List các message với format [{"role": "user", "content": "..."}]
+            **kwargs: Các tham số bổ sung
+            
+        Returns:
+            str: Response từ LLM
+        """
+        if self.provider == "openai":
+            return await self._chat_openai(messages, **kwargs)
+        else:
+            # Với các provider khác, convert messages thành prompt
+            prompt = self._messages_to_prompt(messages)
+            return await self.generate_text(prompt, **kwargs)
+    
+    async def _chat_openai(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        """Chat với OpenAI API."""
+        payload = {
+            "model": kwargs.get("model", self.model),
+            "messages": messages,
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "temperature": kwargs.get("temperature", self.temperature),
+            "stream": False
+        }
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = await self._client.post(
+            f"{self.base_url}/chat/completions",
+            headers=headers,
+            json=payload
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+    
+    def _messages_to_prompt(self, messages: List[Dict[str, str]]) -> str:
+        """Convert conversation messages thành prompt string."""
+        prompt = ""
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            
+            if role == "system":
+                prompt += f"System: {content}\n\n"
+            elif role == "user":
+                prompt += f"User: {content}\n"
+            elif role == "assistant":
+                prompt += f"Assistant: {content}\n"
+        
+        prompt += "Assistant: "
+        return prompt
+    
+    @timing_decorator_async
+    async def classify_text(
+        self, 
+        text: str, 
+        categories: List[str],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Phân loại text vào các categories.
+        
+        Args:
+            text (str): Text cần phân loại
+            categories (List[str]): List các categories
+            **kwargs: Các tham số bổ sung
+            
+        Returns:
+            Dict: Kết quả phân loại
+        """
+        prompt = f"""
+        Phân loại text sau vào một trong các categories: {', '.join(categories)}
+        
+        Text: {text}
+        
+        Trả về kết quả theo format JSON:
+        {{
+            "category": "tên_category",
+            "confidence": 0.95,
+            "reasoning": "lý do phân loại"
+        }}
+        """
+        
+        response = await self.generate_text(prompt, **kwargs)
+        
+        try:
+            # Tìm JSON trong response
+            import re
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if json_match:
+                result = json.loads(json_match.group())
+                return result
+            else:
+                return {
+                    "category": "unknown",
+                    "confidence": 0.0,
+                    "reasoning": "Không thể parse JSON response"
+                }
+        except json.JSONDecodeError:
+            return {
+                "category": "unknown", 
+                "confidence": 0.0,
+                "reasoning": f"JSON parse error: {response}"
+            }
+    
+    @timing_decorator_async
+    async def extract_entities(
+        self, 
+        text: str,
+        entity_types: Optional[List[str]] = None,
+        **kwargs
+    ) -> List[Dict[str, Any]]:
+        """
+        Trích xuất entities từ text.
+        
+        Args:
+            text (str): Text cần trích xuất
+            entity_types (List[str]): Các loại entity cần tìm
+            **kwargs: Các tham số bổ sung
+            
+        Returns:
+            List[Dict]: List các entities được tìm thấy
+        """
+        if entity_types is None:
+            entity_types = ["PERSON", "ORGANIZATION", "LOCATION", "MONEY", "DATE"]
+        
+        prompt = f"""
+        Trích xuất các entities từ text sau. Tìm các entities thuộc types: {', '.join(entity_types)}
+        
+        Text: {text}
+        
+        Trả về kết quả theo format JSON:
+        [
+            {{
+                "text": "tên entity",
+                "type": "loại entity",
+                "start": 0,
+                "end": 10
+            }}
+        ]
+        """
+        
+        response = await self.generate_text(prompt, **kwargs)
+        
+        try:
+            import re
+            json_match = re.search(r'\[.*\]', response, re.DOTALL)
+            if json_match:
+                entities = json.loads(json_match.group())
+                return entities
+            else:
+                return []
+        except json.JSONDecodeError:
+            logger.error(f"Error parsing entities JSON: {response}")
+            return []
+
+    @timing_decorator_async
+    async def analyze(
+        self, 
+        text: str,
+        **kwargs
+    ) -> List[Dict[str, Any]]:
+        """
+        Trích xuất entities từ text.
+        
+        Args:
+            text (str): Text cần trích xuất
+            **kwargs: Các tham số bổ sung
+            
+        Returns:
+            List[Dict]: List các entities được tìm thấy
+        """
+                
+        prompt = f"""
+            Phân tích ngữ nghĩa câu sau: \"{text}\"
+
+            Trả lời dưới dạng JSON với 3 trường sau:
+            {{
+                "muc_dich": "...",
+                "phuong_tien": "...",
+                "hanh_vi_vi_pham": "..."
+            }}
+
+            Ví dụ:
+            "Tôi chạy xe hơi không bật đèn vào ban đêm thì có bị sao không?"
+            → {{
+                "muc_dich": "Hỏi về hậu quả/hình phạt khi không bật đèn xe hơi ban đêm",
+                "phuong_tien": "Xe hơi",
+                "hanh_vi_vi_pham": "Không bật đèn khi lái xe vào ban đêm"
+            }}
+
+            Câu bạn cần phân tích:
+            \"{text}\"
+            """.strip()
+        
+        response = await self.generate_text(prompt, **kwargs)
+        
+        try:
+            import re
+            json_match = re.search(r'\[.*\]', response, re.DOTALL)
+            if json_match:
+                entities = json.loads(json_match.group())
+                return entities
+            else:
+                return []
+        except json.JSONDecodeError:
+            logger.error(f"Error parsing entities JSON: {response}")
+            return []
+    
+    async def close(self):
+        """Đóng client connection."""
+        await self._client.aclose()
+
+
+# Factory function để tạo LLMClient dễ dàng
+def create_llm_client(provider: str = "openai", **kwargs) -> LLMClient:
+    """
+    Factory function để tạo LLMClient.
+    
+    Args:
+        provider (str): Loại provider
+        **kwargs: Các tham số cấu hình
+        
+    Returns:
+        LLMClient: Instance của LLMClient
+    """
+    return LLMClient(provider, **kwargs)
+
+
+# Ví dụ sử dụng
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test_llm():
+        # Test với OpenAI
+        llm = create_llm_client("openai", model="gpt-3.5-turbo")
+        
+        # Generate text
+        response = await llm.generate_text("Xin chào, bạn có khỏe không?")
+        print(f"Response: {response}")
+        
+        # Chat
+        messages = [
+            {"role": "user", "content": "Bạn có thể giúp tôi không?"}
+        ]
+        chat_response = await llm.chat(messages)
+        print(f"Chat response: {chat_response}")
+        
+        await llm.close()
+    
+    asyncio.run(test_llm()) 

app/main.py

@@ -16,6 +16,7 @@ from .embedding import EmbeddingClient
 from .utils import setup_logging, extract_command, extract_keywords, timing_decorator_async, timing_decorator_sync, ensure_log_dir, validate_config
 from .constants import VEHICLE_KEYWORDS, SHEET_RANGE, VEHICLE_KEYWORD_TO_COLUMN
 from .health import router as health_router
+from .llm import create_llm_client
 
 app = FastAPI(title="WeBot Facebook Messenger API")
 
@@ -52,6 +53,12 @@ embedding_client = EmbeddingClient()
 # Keywords to look for in messages
 VEHICLE_KEYWORDS = ["xe máy", "ô tô", "xe đạp", "xe hơi"]
 
+# Khởi tạo LLM client (ví dụ dùng HFS, bạn có thể đổi provider tuỳ ý)
+llm_client = create_llm_client(
+    provider="hfs",
+    base_url="https://vietcat-vietnameseembeddingv2.hf.space"
+)
+
 logger.info("[STARTUP] Mount health router...")
 app.include_router(health_router)
 
@@ -60,6 +67,8 @@ validate_config(settings)
 
 executor = ThreadPoolExecutor(max_workers=4)
 
+message_text = None
+
 @app.get("/")
 async def root():
     """Endpoint root để kiểm tra trạng thái app."""
@@ -171,7 +180,23 @@ async def process_message(message_data: Dict[str, Any]):
 
     # Extract command and keywords
     command, remaining_text = extract_command(message_text)
-    keywords = extract_keywords(message_text, VEHICLE_KEYWORDS)
+    # Sử dụng LLM để phân tích message_text và extract keywords, mục đích, hành vi vi phạm
+    llm_analysis = await llm_client.analyze(message_text)
+    muc_dich = None
+    hanh_vi_vi_pham = None
+    if isinstance(llm_analysis, dict):
+        keywords = [llm_analysis.get('phuong_tien', '').lower()]
+        muc_dich = llm_analysis.get('muc_dich')
+        hanh_vi_vi_pham = llm_analysis.get('hanh_vi_vi_pham')
+    elif isinstance(llm_analysis, list) and len(llm_analysis) > 0:
+        keywords = [llm_analysis[0].get('phuong_tien', '').lower()]
+        muc_dich = llm_analysis[0].get('muc_dich')
+        hanh_vi_vi_pham = llm_analysis[0].get('hanh_vi_vi_pham')
+    else:
+        keywords = extract_keywords(message_text, VEHICLE_KEYWORDS)
+        hanh_vi_vi_pham = message_text.replace(keywords, "")
+
+    logger.info(f"[DEBUG] Phương tiện: {keywords} - Hành vi: {hanh_vi_vi_pham} - Mục đích: {muc_dich}")
 
     # Get conversation history (run in thread pool)
     loop = asyncio.get_event_loop()
@@ -191,6 +216,8 @@ async def process_message(message_data: Dict[str, Any]):
         'content': remaining_text,
         'attachments': attachments,
         'vehicle': ','.join(keywords),
+        'action': hanh_vi_vi_pham,
+        'purpose': muc_dich,
         'is_done': False
     }
 
@@ -199,12 +226,15 @@ async def process_message(message_data: Dict[str, Any]):
         if not command:
             if keywords:
                 # Có thông tin phương tiện
-                embedding = await embedding_client.create_embedding(message_text)
+                if hanh_vi_vi_pham:
+                    embedding = await embedding_client.create_embedding(hanh_vi_vi_pham)
+                else:
+                    embedding = await embedding_client.create_embedding(message_text)
                 logger.info(f"[DEBUG] embedding: {embedding[:5]} ... (total {len(embedding)})")
                 matches = supabase_client.match_documents(embedding, vehicle_keywords=keywords)
                 logger.info(f"[DEBUG] matches: {matches}")
                 if matches:
-                    response = format_search_results(matches)
+                    response = await format_search_results(matches)
                 else:
                     response = "Xin lỗi, tôi không tìm thấy thông tin phù hợp."
                 log_kwargs['is_done'] = True
@@ -225,16 +255,28 @@ async def process_message(message_data: Dict[str, Any]):
     last_command = last_conv['originalcommand'] if last_conv else ''
     last_isdone = last_conv['isdone'] if last_conv else False
 
+    # --- Cập nhật log_kwargs theo lịch sử ---
+    log_kwargs_old = log_kwargs.copy()
+    log_kwargs_overwritten = {}
+    for key in log_kwargs.keys():
+        history_val = last_conv.get(key) if last_conv else None
+        current_val = log_kwargs[key]
+        if history_val not in [None, '', [], {}]:
+            if current_val not in [None, '', [], {}]:
+                log_kwargs_overwritten[key] = current_val  # Lưu giá trị cũ để xử lý sau
+            log_kwargs[key] = history_val  # Ưu tiên giá trị từ lịch sử
+    # --- END cập nhật log_kwargs ---
+
     if not last_command:
         # Lịch sử không có command
         if keywords:
             # Có thông tin phương tiện
-            embedding = await embedding_client.create_embedding(message_text)
+            embedding = await embedding_client.create_embedding(log_kwargs['action'])
             logger.info(f"[DEBUG] embedding: {embedding[:5]} ... (total {len(embedding)})")
             matches = supabase_client.match_documents(embedding, vehicle_keywords=keywords)
             logger.info(f"[DEBUG] matches: {matches}")
             if matches:
-                response = format_search_results(matches)
+                response = await format_search_results(matches)
             else:
                 response = "Xin lỗi, tôi không tìm thấy thông tin phù hợp."
             log_kwargs['is_done'] = True
@@ -268,36 +310,95 @@ async def process_message(message_data: Dict[str, Any]):
             await loop.run_in_executor(executor, lambda: sheets_client.log_conversation(**log_kwargs))
             return
 
-def format_search_results(matches: List[Dict[str, Any]]) -> str:
+async def format_search_results(matches: List[Dict[str, Any]]) -> str:
     if not matches:
         return "Không tìm thấy kết quả phù hợp."
     # Tìm item có similarity cao nhất
     top = None
-    for item in matches:
-        if not top or (item.get('similarity', 0) > top.get('similarity', 0)):
-            top = item
-    result_text = ""
+    top_result_text = ""
+    full_result_text = ""
+
+    for i, match in enumerate(matches, 1):
+        if not top or (match.get('similarity', 0) > top.get('similarity', 0)):
+            top = match
+
+        # Chuẩn bị context cho LLM: liệt kê tất cả các item với chú thích rõ ràng
+        full_result_text += f"Đoạn {i}:\n"
+         # Thực hiện hành vi
+        tieude = (top.get('tieude') or '').strip()
+        noidung = (top.get('noidung') or '').strip()
+        hanhvi = (tieude + "\n" + noidung).strip().replace('\n', ' ')
+        full_result_text += f"Thực hiện hành vi:\n{hanhvi}"
+        # Cá nhân bị phạt tiền
+        if top.get('canhantu') or top.get('canhanden'):
+            full_result_text += f"\nCá nhân sẽ bị phạt tiền từ {top.get('canhantu', '')} VNĐ đến {top.get('canhanden', '')} VNĐ"
+        # Tổ chức bị phạt tiền
+        if top.get('tochuctu') or top.get('tochucden'):
+            full_result_text += f"\nTổ chức sẽ bị phạt tiền từ {top.get('tochuctu', '')} VNĐ đến {top.get('tochucden', '')} VNĐ"
+        # Hình phạt bổ sung
+        if top.get('hpbsnoidung'):
+            full_result_text += f"\nNgoài việc bị phạt tiền, người vi phạm còn bị {top.get('hpbsnoidung')}"
+        # Biện pháp khắc phục hậu quả
+        if top.get('bpkpnoidung'):
+            full_result_text += f"\nNgoài ra, người vi phạm còn bị buộc {top.get('bpkpnoidung')}"
+    
     if top and (top.get('tieude') or top.get('noidung')):
         # Thực hiện hành vi
         tieude = (top.get('tieude') or '').strip()
         noidung = (top.get('noidung') or '').strip()
         hanhvi = (tieude + "\n" + noidung).strip().replace('\n', ' ')
-        result_text += f"Thực hiện hành vi:\n{hanhvi}"
+        top_result_text += f"Thực hiện hành vi:\n{hanhvi}"
         # Cá nhân bị phạt tiền
         if top.get('canhantu') or top.get('canhanden'):
-            result_text += f"\nCá nhân sẽ bị phạt tiền từ {top.get('canhantu', '')} VNĐ đến {top.get('canhanden', '')} VNĐ"
+            top_result_text += f"\nCá nhân sẽ bị phạt tiền từ {top.get('canhantu', '')} VNĐ đến {top.get('canhanden', '')} VNĐ"
         # Tổ chức bị phạt tiền
         if top.get('tochuctu') or top.get('tochucden'):
-            result_text += f"\nTổ chức sẽ bị phạt tiền từ {top.get('tochuctu', '')} VNĐ đến {top.get('tochucden', '')} VNĐ"
+            top_result_text += f"\nTổ chức sẽ bị phạt tiền từ {top.get('tochuctu', '')} VNĐ đến {top.get('tochucden', '')} VNĐ"
         # Hình phạt bổ sung
         if top.get('hpbsnoidung'):
-            result_text += f"\nNgoài việc bị phạt tiền, người vi phạm còn bị {top.get('hpbsnoidung')}"
+            top_result_text += f"\nNgoài việc bị phạt tiền, người vi phạm còn bị {top.get('hpbsnoidung')}"
         # Biện pháp khắc phục hậu quả
         if top.get('bpkpnoidung'):
-            result_text += f"\nNgoài ra, người vi phạm còn bị buộc {top.get('bpkpnoidung')}"
+            top_result_text += f"\nNgoài ra, người vi phạm còn bị buộc {top.get('bpkpnoidung')}"
     else:
         result_text = "Không có kết quả phù hợp!"
-    return result_text.strip()
+    
+    # Prompt cho LLM
+    prompt = (
+        "Bạn là một trợ lý AI có kiến thức pháp luật, hãy trả lời câu hỏi dựa trên các đoạn luật sau. "
+        "Chỉ sử dụng thông tin có trong các đoạn, không tự đoán.\n"
+        f"Các đoạn luật liên quan:\n{full_result_text}"
+        "\nHãy trả lời ngắn gọn, dễ hiểu, trích dẫn rõ ràng thông tin từ các đoạn luật nếu cần."
+        f"Câu hỏi của người dùng: {message_text}\n"
+    )
+
+    logger.info(f"[DEBUG] prompt:\n {prompt}")
+
+    # Gọi LLM để sinh câu trả lời, fallback nếu lỗi
+    try:
+        answer = await llm_client.generate_text(prompt)
+        if answer and answer.strip():
+            return answer.strip()
+    except Exception as e:
+        logger.error(f"LLM không sẵn sàng: {e}\n{traceback.format_exc()}")
+    # Fallback: trả về tổng hợp các đoạn luật như cũ
+    fallback = "Tóm tắt các đoạn luật liên quan:\n\n"
+    for i, match in enumerate(matches, 1):
+        fallback += f"Đoạn {i}:\n"
+        tieude = (match.get('tieude') or '').strip()
+        noidung = (match.get('noidung') or '').strip()
+        if tieude or noidung:
+            fallback += f"  - Hành vi: {(tieude + ' ' + noidung).strip()}\n"
+        if match.get('canhantu') or match.get('canhanden'):
+            fallback += f"  - Cá nhân bị phạt tiền từ {match.get('canhantu', '')} VNĐ đến {match.get('canhanden', '')} VNĐ\n"
+        if match.get('tochuctu') or match.get('tochucden'):
+            fallback += f"  - Tổ chức bị phạt tiền từ {match.get('tochuctu', '')} VNĐ đến {match.get('tochucden', '')} VNĐ\n"
+        if match.get('hpbsnoidung'):
+            fallback += f"  - Hình phạt bổ sung: {match.get('hpbsnoidung')}\n"
+        if match.get('bpkpnoidung'):
+            fallback += f"  - Biện pháp khắc phục hậu quả: {match.get('bpkpnoidung')}\n"
+        fallback += "\n"
+    return fallback.strip()
 
 async def create_facebook_post(page_token: str, sender_id: str, history: List[Dict[str, Any]]) -> str:
     """

app/sheets.py

@@ -90,8 +90,8 @@ class SheetsClient:
             history = []
 
             for row in values:
-                # Bổ sung cột rỗng cho đủ 9 cột
-                row = row + [""] * (9 - len(row))
+                # Bổ sung cột rỗng cho đủ 11 cột
+                row = row + [""] * (11 - len(row))
                 if row[4] == user_id and row[5] == page_id and row[8].lower() == 'false':
                     history.append({
                         'conversation_id': row[0],
@@ -102,7 +102,9 @@ class SheetsClient:
                         'page_id': row[5],
                         'originaltext': row[6],
                         'originalvehicle': row[7],
-                        'isdone': row[8].lower() == 'true'
+                        'originalaction': row[8],
+                        'originalpurpose': row[9],
+                        'isdone': row[10].lower() == 'true'
                     })
 
             return history
@@ -121,6 +123,8 @@ class SheetsClient:
         content: str = "",
         attachments: Optional[List[str]] = None,
         vehicle: str = "",
+        action: str = "",
+        purpose: str = "",
         is_done: bool = False
     ) -> bool:
         """
@@ -148,6 +152,8 @@ class SheetsClient:
                     page_id,
                     message,
                     vehicle,
+                    action,
+                    purpose,
                     str(is_done).lower()
                 ]]
 
@@ -182,8 +188,8 @@ class SheetsClient:
                 if row_index is not None:
                     # Lấy dữ liệu dòng hiện tại
                     current_row = values[row_index]
-                    # Đảm bảo đủ 9 cột
-                    while len(current_row) < 9:
+                    # Đảm bảo đủ 11 cột
+                    while len(current_row) < 11:
                         current_row.append("")
                     # Tạo dòng mới với giá trị mới nếu có, giữ nguyên nếu không
                     new_row = [
@@ -195,7 +201,9 @@ class SheetsClient:
                         page_id if page_id else current_row[5],
                         message if message else current_row[6],
                         vehicle if vehicle else current_row[7],
-                        str(is_done).lower() if is_done is not None else current_row[8]
+                        action if action else current_row[8],
+                        purpose if purpose else current_row[9],
+                        str(is_done).lower() if is_done is not None else current_row[10]
                     ]
                     update_range = f"{SHEET_RANGE.split('!')[0]}!A{row_index + 1}"
                     body = {