adjust prompt

app/llm.py

@@ -1,32 +1,67 @@
+from __future__ import annotations
+
 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 re
 import os
+import asyncio
+
+import httpx
+from loguru import logger
+
 from .gemini_client import GeminiClient
 from .config import get_settings
+from .utils import (
+    timing_decorator_async,
+    timing_decorator_sync,  # kept for compatibility even if unused here
+    call_endpoint_with_retry,
+)
+
+
+def _safe_truncate(s: str, n: int = 1000) -> str:
+    """Truncate long strings for logging purposes."""
+    if not isinstance(s, str):
+        s = str(s)
+    return s if len(s) <= n else s[:n] + "... [truncated]"
+
+
+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.
+
+    Strategy:
+    1) Try json.loads() on the whole string first.
+    2) Fallback to regex to find the first JSON list/object snippet.
+    """
+    if not text:
+        return None
+
+    # 1) try direct load
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+
+    # 2) find first JSON array or object
+    match = re.search(r"(\[[\s\S]+?\]|\{[\s\S]+?\})", text)
+    if match:
+        try:
+            return json.loads(match.group(1))
+        except Exception:
+            return None
+    return None
 
-from .utils import timing_decorator_async, timing_decorator_sync, call_endpoint_with_retry
 
 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.
+    Hỗ trợ nhiều provider: OpenAI, HuggingFace, local models, custom, HFS, Gemini.
     """
-    
+
     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
+
+        # Dispatch provider setup
         if self.provider == "openai":
             self._setup_openai(kwargs)
         elif self.provider == "huggingface":
@@ -36,41 +71,39 @@ class LLMClient:
         elif self.provider == "custom":
             self._setup_custom(kwargs)
         elif self.provider == "hfs":
-            self._setup_HFS(kwargs)
+            self._setup_hfs(kwargs)
         elif self.provider == "gemini":
             self._setup_gemini(kwargs)
         else:
             raise ValueError(f"Unsupported provider: {provider}")
-    
+
+    # ---------- Provider setups ---------- #
+
     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") or ""
         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", "")
         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)
-    
+
     def _setup_local(self, config: Dict[str, Any]):
-        """Cấu hình cho local model."""
         self.api_key = ""
         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.api_key = config.get("api_key", "")
         self.base_url = config.get("base_url")
         self.model = config.get("model", "default")
@@ -79,40 +112,33 @@ class LLMClient:
         if not self.base_url:
             raise ValueError("Custom provider requires base_url")
 
-    def _setup_HFS(self, config: Dict[str, Any]):
-        """Cấu hình cho custom provider."""
+    def _setup_hfs(self, config: Dict[str, Any]):
         self.api_key = config.get("api_key", "")
         self.base_url = config.get("base_url")
         if not self.base_url:
-            raise ValueError("Custom provider requires base_url")
-    
+            raise ValueError("HFS provider requires base_url")
+
     def _setup_gemini(self, config: Dict[str, Any]):
-        """Cấu hình cho Gemini."""
-        # Sử dụng GeminiClient với RequestLimitManager
+        # Sử dụng GeminiClient với RequestLimitManager (theo thiết kế của bạn)
         self.gemini_client = GeminiClient()
         logger.info("[LLM] Initialized GeminiClient with RequestLimitManager")
-    
+
+    # ---------- Core APIs ---------- #
+
     @timing_decorator_async
     async def generate_text(
-        self, 
-        prompt: str, 
+        self,
+        prompt: str,
         system_prompt: Optional[str] = None,
-        **kwargs
+        **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
         """
-        logger.info(f"[LLM] generate_text - provider: {self.provider} \n\t prompt: {prompt}")
+        logger.info(
+            f"[LLM] generate_text - provider: {self.provider}\n\t prompt: {_safe_truncate(prompt, 1200)}"
+        )
         try:
-            result = None
             if self.provider == "openai":
                 result = await self._generate_openai(prompt, system_prompt, **kwargs)
             elif self.provider == "huggingface":
@@ -127,24 +153,38 @@ class LLMClient:
                 result = await self._generate_gemini(prompt, **kwargs)
             else:
                 raise ValueError(f"Unsupported provider: {self.provider}")
-            logger.info(f"[LLM] generate_text - provider: {self.provider}\n\t result: {result}")
+
+            logger.info(f"[LLM] generate_text - provider: {self.provider}\n\t result: {_safe_truncate(result, 1200)}")
             return result
         except Exception as e:
-            logger.error(f"[LLM] Error generating text with {self.provider}: {e}")
+            logger.exception(f"[LLM] Error generating text with {self.provider}: {e}")
             raise
-    
-    async def _generate_openai(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> str:
+
+    async def _generate_openai(
+        self, prompt: str, system_prompt: Optional[str] = None, **kwargs
+    ) -> str:
         url = f"{self.base_url}/chat/completions"
-        payload = {"model": kwargs.get("model", self.model), "messages": [{"role": "system", "content": system_prompt or ""}, {"role": "user", "content": prompt}], "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"}
+        payload = {
+            "model": kwargs.get("model", self.model),
+            "messages": [
+                {"role": "system", "content": system_prompt or ""},
+                {"role": "user", "content": prompt},
+            ],
+            "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 call_endpoint_with_retry(self._client, url, payload, headers=headers)
         if response is not None:
             data = response.json()
             return data["choices"][0]["message"]["content"]
-        else:
-            logger.error("OpenAI API response is None")
-            raise RuntimeError("OpenAI API response is None")
-    
+        logger.error("OpenAI API response is None")
+        raise RuntimeError("OpenAI API response is None")
+
     async def _generate_huggingface(self, prompt: str, **kwargs) -> str:
         url = f"{self.base_url}/generate"
         payload = {"inputs": prompt}
@@ -152,10 +192,9 @@ class LLMClient:
         if response is not None:
             data = response.json()
             return data[0]["generated_text"]
-        else:
-            logger.error("HuggingFace API response is None")
-            raise RuntimeError("HuggingFace API response is None")
-    
+        logger.error("HuggingFace API response is None")
+        raise RuntimeError("HuggingFace API response is None")
+
     async def _generate_local(self, prompt: str, **kwargs) -> str:
         url = f"{self.base_url}/generate"
         payload = {"prompt": prompt}
@@ -163,10 +202,9 @@ class LLMClient:
         if response is not None:
             data = response.json()
             return data.get("text", "")
-        else:
-            logger.error("Local API response is None")
-            raise RuntimeError("Local API response is None")
-    
+        logger.error("Local API response is None")
+        raise RuntimeError("Local API response is None")
+
     async def _generate_custom(self, prompt: str, **kwargs) -> str:
         url = f"{self.base_url}/custom"
         payload = {"prompt": prompt}
@@ -174,130 +212,101 @@ class LLMClient:
         if response is not None:
             data = response.json()
             return data.get("text", "")
-        else:
-            logger.error("Custom API response is None")
-            raise RuntimeError("Custom API response is None")
-    
+        logger.error("Custom API response is None")
+        raise RuntimeError("Custom API response is None")
+
     async def _generate_hfs(self, prompt: str, **kwargs) -> str:
+        # Giữ nguyên chữ ký call_endpoint_with_retry như bạn đã dùng
         endpoint = f"{self.base_url}/purechat"
         payload = {"prompt": prompt}
         headers = {}
-        if self.api_key:
+        if hasattr(self, "api_key") and self.api_key:
             headers["Authorization"] = f"Bearer {self.api_key}"
-        response = await call_endpoint_with_retry(self._client, endpoint, payload, 3, 500, headers=headers)
-        logger.info(f"[LLM] generate_text - provider: {self.provider}\n\t response: {response}")
+        response = await call_endpoint_with_retry(
+            self._client, endpoint, payload, 3, 500, headers=headers
+        )
+        logger.info(
+            f"[LLM] generate_text - provider: {self.provider}\n\t response: {_safe_truncate(str(response), 1200)}"
+        )
         try:
-            import json as _json
-            logger.info(f"[LLM][RAW_RESPONSE] { _json.dumps(response, ensure_ascii=False, indent=2) }")
+            logger.info(
+                f"[LLM][RAW_RESPONSE] {json.dumps(response, ensure_ascii=False, indent=2) if hasattr(response, 'json') else str(response)}"
+            )
         except Exception:
             logger.info(f"[LLM][RAW_RESPONSE] {str(response)}")
+
         if response is not None:
             data = response.json()
-            if 'response' in data:
-                return data['response']
-            elif 'result' in data:
-                return data['result']
-            elif 'data' in data and isinstance(data['data'], list):
-                return data['data'][0]
+            if "response" in data:
+                return data["response"]
+            if "result" in data:
+                return data["result"]
+            if "data" in data and isinstance(data["data"], list) and data["data"]:
+                return data["data"][0]
             return str(data)
-        else:
-            logger.error("HFS API response is None")
-            raise RuntimeError("HFS API response is None")
+        logger.error("HFS API response is None")
+        raise RuntimeError("HFS API response is None")
 
     async def _generate_gemini(self, prompt: str, **kwargs) -> str:
-        import asyncio
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self.gemini_client.generate_text, prompt)
+        # Đảm bảo kwargs được truyền nếu GeminiClient hỗ trợ
+        return await loop.run_in_executor(None, lambda: self.gemini_client.generate_text(prompt, **kwargs))
 
     @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
-        """
-        logger.info(f"[LLM] chat - messages: {messages}")
+    async def chat(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        """Chat với LLM sử dụng conversation history."""
+        logger.info(f"[LLM] chat - provider: {self.provider} - messages: {messages}")
         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)
-    
+        # Convert messages -> prompt cho các provider khác
+        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
+            "stream": False,
         }
-        
         headers = {
             "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
         }
-        
         response = await self._client.post(
-            f"{self.base_url}/chat/completions",
-            headers=headers,
-            json=payload
+            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 = ""
+        prompt_lines = []
         for msg in messages:
             role = msg.get("role", "user")
             content = msg.get("content", "")
-            
             if role == "system":
-                prompt += f"System: {content}\n\n"
+                prompt_lines.append(f"System: {content}\n")
             elif role == "user":
-                prompt += f"User: {content}\n"
+                prompt_lines.append(f"User: {content}\n")
             elif role == "assistant":
-                prompt += f"Assistant: {content}\n"
-        
-        prompt += "Assistant: "
-        return prompt
-    
+                prompt_lines.append(f"Assistant: {content}\n")
+        prompt_lines.append("Assistant: ")
+        return "".join(prompt_lines)
+
+    # ---------- Utility tasks ---------- #
+
     @timing_decorator_async
     async def classify_text(
-        self, 
-        text: str, 
-        categories: List[str],
-        **kwargs
+        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
-        """
+        """Phân loại text vào các categories."""
         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",
@@ -305,55 +314,31 @@ class LLMClient:
             "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}"
-            }
-    
+
+        result = _parse_json_from_text(response or "")
+        if isinstance(result, dict):
+            return result
+        # fallback default
+        return {
+            "category": "unknown",
+            "confidence": 0.0,
+            "reasoning": f"Cannot parse JSON from response: {_safe_truncate(response, 500)}",
+        }
+
     @timing_decorator_async
     async def extract_entities(
-        self, 
-        text: str,
-        entity_types: Optional[List[str]] = None,
-        **kwargs
+        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
-        """
+        """Trích xuất entities từ text."""
         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:
         [
             {{
@@ -364,158 +349,125 @@ class LLMClient:
             }}
         ]
         """
-        
         response = await self.generate_text(prompt, **kwargs)
-        
+
         try:
-            import re
-            # Log toàn bộ response dưới dạng text dễ đọc
-            try:
-                import json as _json
-                logger.info(f"[LLM][RAW_RESPONSE] { _json.dumps(response, ensure_ascii=False, indent=2) }")
-            except Exception:
-                logger.info(f"[LLM][RAW_RESPONSE] {str(response)}")
-            # Ưu tiên parse object JSON nếu có
-            json_match_obj = re.search(r'\{[\s\S]*?\}', response)
-            json_match_list = re.search(r'\[[\s\S]*?\]', response)
-            if json_match_list:
-                entities = json.loads(json_match_list.group())
-                return entities
-            elif json_match_obj:
-                entity = json.loads(json_match_obj.group())
-                return [entity]
-            else:
-                return []
-        except json.JSONDecodeError:
-            logger.error(f"Error parsing entities JSON: {response}")
+            logger.info(
+                f"[LLM][RAW_RESPONSE][extract_entities] {_safe_truncate(response, 2000)}"
+            )
+            parsed = _parse_json_from_text(response or "")
+            if isinstance(parsed, list):
+                return parsed
+            if isinstance(parsed, dict):
+                return [parsed]
+            return []
+        except Exception as e:
+            logger.error(f"Error parsing entities JSON: {e} | Raw: {response}")
             return []
 
     @timing_decorator_async
     async def analyze(
-        self, 
-        text: str, 
-        conversation_context: str,
-        **kwargs
+        self, text: str, conversation_context: 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
+        Phân tích câu hỏi về luật giao thông Việt Nam và chuẩn hóa thành JSON.
         """
-                
         prompt = f"""
-            Bạn là một chuyên gia phân tích ngôn ngữ tự nhiên (NLP) chuyên xử lý các câu hỏi về luật giao thông Việt Nam. Nhiệm vụ của bạn là đọc kỹ **lịch sử trò chuyện** và **câu hỏi mới nhất** của người dùng để trích xuất thông tin vào một cấu trúc JSON duy nhất. Chỉ trả về đối tượng JSON, không thêm bất kỳ giải thích nào.
-            Định dạng JSON bắt buộc:
+        Bạn là một chuyên gia phân tích ngôn ngữ tự nhiên (NLP) chuyên xử lý các câu hỏi về luật giao thông Việt Nam. Nhiệm vụ của bạn là đọc kỹ **lịch sử trò chuyện** và **câu hỏi mới nhất** của người dùng để trích xuất thông tin vào một cấu trúc JSON duy nhất. Chỉ trả về đối tượng JSON, không thêm bất kỳ giải thích nào.
 
-            {{
-                "muc_dich": "...",
-                "phuong_tien": "...",
-                "hanh_vi": "...",
-                "cau_hoi": "..."
-            }}
+        Định dạng JSON bắt buộc:
 
-            Hướng dẫn chi tiết cho từng trường:
+        {{
+            "muc_dich": "...",
+            "phuong_tien": "...",
+            "hanh_vi": "...",
+            "cau_hoi": "..."
+        }}
 
-            **muc_dich**: Phải là một trong các giá trị sau: "hỏi về mức phạt", "hỏi về quy tắc giao thông", "hỏi về báo hiệu đường bộ", "hỏi về quy trình xử lý vi phạm giao thông", "thông tin cá nhân của AI", "khác". **Phải dựa vào câu hỏi mới nhất để xác định.**
-            **phuong_tien**: Tên phương tiện được đề cập trong câu hỏi mới hoặc trong lịch sử gần nhất. Nếu không có, để chuỗi rỗng "".
-            **hanh_vi**: Tên gọi pháp lý của hành vi. **Sử dụng lịch sử trò chuyện để xác định hành vi nếu câu hỏi mới không đề cập đến.** Nếu không có hành vi cụ thể, để chuỗi rỗng "".
-            **cau_hoi**: Diễn đạt lại câu hỏi mới nhất của người dùng thành một câu hỏi hoàn chỉnh, kết hợp ngữ cảnh từ lịch sử nếu cần, sử dụng đúng thuật ngữ pháp lý.
+        Hướng dẫn chi tiết cho từng trường:
 
-            VÍ DỤ MẪU:
+        **muc_dich**: Phải là một trong các giá trị sau: 
+        - "hỏi về mức phạt"
+        - "hỏi về quy tắc giao thông"
+        - "hỏi về báo hiệu đường bộ"
+        - "hỏi về quy trình xử lý vi phạm giao thông"
+        - "thông tin cá nhân của AI"
+        - "khác"
 
-            Câu hỏi đầu vào: "ô tô vượt đèn đỏ phạt nhiêu?"
-            Kết quả JSON mong muốn:
-            {{
-                "muc_dich": "hỏi về mức phạt",
-                "phuong_tien": "Ô tô",
-                "hanh_vi": "Không chấp hành hiệu lệnh của đèn tín hiệu giao thông",
-                "cau_hoi": "Mức xử phạt cho hành vi ô tô không chấp hành hiệu lệnh của đèn tín hiệu giao thông là bao nhiêu?"
-            }}
+        **Phải dựa vào câu hỏi mới nhất để xác định.**
+
+        **phuong_tien**: Tên phương tiện được đề cập trong câu hỏi mới hoặc trong lịch sử gần nhất. Nếu không có, để chuỗi rỗng "".
+
+        **hanh_vi**: Là cụm từ hoặc từ khóa ngắn gọn và phù hợp nhất để **tìm kiếm nội dung liên quan đến câu hỏi**. Có thể là tên hành vi vi phạm, thuật ngữ pháp lý, hoặc khái niệm về quy tắc/báo hiệu/vi phạm. Nếu không có thông tin rõ ràng, để chuỗi rỗng "".
+
+        **cau_hoi**: Diễn đạt lại câu hỏi mới nhất của người dùng thành một câu hỏi hoàn chỉnh, kết hợp ngữ cảnh từ lịch sử nếu cần, sử dụng đúng thuật ngữ pháp lý.
+
+        VÍ DỤ MẪU:
+
+        Câu hỏi đầu vào: "ô tô vượt đèn đỏ phạt nhiêu?"
+        Kết quả JSON mong muốn:
+        {{
+            "muc_dich": "hỏi về mức phạt",
+            "phuong_tien": "Ô tô",
+            "hanh_vi": "Không chấp hành hiệu lệnh của đèn tín hiệu giao thông",
+            "cau_hoi": "Mức xử phạt cho hành vi ô tô không chấp hành hiệu lệnh của đèn tín hiệu giao thông là bao nhiêu?"
+        }}
+
+        Bây giờ, hãy phân tích lịch sử và câu hỏi sau và chỉ trả về đối tượng JSON.
 
-            Bây giờ, hãy phân tích lịch sử và câu hỏi sau và chỉ trả về đối tượng JSON.
-            Lịch sử trò chuyện:
-            \"{conversation_context}\"
+        Lịch sử trò chuyện:
+        "{conversation_context}"
+
+        Câu hỏi:
+        "{text}"
+        """.strip()
 
-            Câu hỏi:
-            \"{text}\"
-            """.strip()
-        
         response = await self.generate_text(prompt, **kwargs)
-        
-        logger.info(f"[LLM][RAW] Kết quả trả về từ generate_text: {response}")
+        logger.info(f"[LLM][RAW][analyze] Kết quả trả về từ generate_text: {_safe_truncate(response, 2000)}")
 
         try:
-            import re
-            # Log toàn bộ response dưới dạng text dễ đọc
-            try:
-                import json as _json
-                logger.info(f"[LLM][RAW_RESPONSE] { _json.dumps(response, ensure_ascii=False, indent=2) }")
-            except Exception:
-                logger.info(f"[LLM][RAW_RESPONSE] {str(response)}")
-            # Ưu tiên parse object JSON nếu có
-            json_match_obj = re.search(r'\{[\s\S]*?\}', response)
-            json_match_list = re.search(r'\[[\s\S]*?\]', response)
-            if json_match_list:
-                entities = json.loads(json_match_list.group())
-                return entities
-            elif json_match_obj:
-                entity = json.loads(json_match_obj.group())
-                return [entity]
-            else:
-                return []
-        except json.JSONDecodeError:
-            logger.error(f"Error parsing entities JSON: {response}")
+            parsed = _parse_json_from_text(response or "")
+            if isinstance(parsed, list):
+                return parsed
+            if isinstance(parsed, dict):
+                return [parsed]
             return []
-    
+        except Exception as e:
+            logger.error(f"Error parsing analyze JSON: {e} | Raw: {response}")
+            return []
+
     async def close(self):
         """Đóng client connection."""
-        await self._client.aclose()
+        if hasattr(self, "_client") and self._client:
+            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
         settings = get_settings()
         llm_client = create_llm_client(
             provider=settings.llm_provider,
             model=settings.llm_model,
             # ... các config khác nếu cần ...
         )
-        
+
         # Generate text
         response = await llm_client.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_client.chat(messages)
         print(f"Chat response: {chat_response}")
-        
+
         await llm_client.close()
-    
-    asyncio.run(test_llm()) 
+
+    asyncio.run(test_llm())