Upload 4 files

agent_service.py

@@ -1,458 +1,474 @@
-"""
-Agent Service - Central Brain for Sales & Feedback Agents
-Manages LLM conversation loop with tool calling
-"""
-from typing import Dict, Any, List, Optional
-import os
-from tools_service import ToolsService
-
-
-class AgentService:
-    """
-    Manages the conversation loop between User -> LLM -> Tools -> Response
-    """
-    
-    def __init__(
-        self,
-        tools_service: ToolsService,
-        embedding_service,
-        qdrant_service,
-        advanced_rag,
-        hf_token: str
-    ):
-        self.tools_service = tools_service
-        self.embedding_service = embedding_service
-        self.qdrant_service = qdrant_service
-        self.advanced_rag = advanced_rag
-        self.hf_token = hf_token
-        
-        # Load system prompts
-        self.prompts = self._load_prompts()
-    
-    def _load_prompts(self) -> Dict[str, str]:
-        """Load system prompts from files"""
-        prompts = {}
-        prompts_dir = "prompts"
-        
-        for mode in ["sales_agent", "feedback_agent"]:
-            filepath = os.path.join(prompts_dir, f"{mode}.txt")
-            try:
-                with open(filepath, 'r', encoding='utf-8') as f:
-                    prompts[mode] = f.read()
-                print(f"✓ Loaded prompt: {mode}")
-            except Exception as e:
-                print(f"⚠️ Error loading {mode} prompt: {e}")
-                prompts[mode] = ""
-        
-        return prompts
-    
-    async def chat(
-        self,
-        user_message: str,
-        conversation_history: List[Dict],
-        mode: str = "sales",  # "sales" or "feedback"
-        user_id: Optional[str] = None,
-        access_token: Optional[str] = None,  # NEW: For authenticated API calls
-        max_iterations: int = 3
-    ) -> Dict[str, Any]:
-        """
-        Main conversation loop
-        
-        Args:
-            user_message: User's input
-            conversation_history: Previous messages [{"role": "user", "content": ...}, ...]
-            mode: "sales" or "feedback"
-            user_id: User ID (for feedback mode to check purchase history)
-            access_token: JWT token for authenticated API calls
-            max_iterations: Maximum tool call iterations to prevent infinite loops
-        
-        Returns:
-            {
-                "message": "Bot response",
-                "tool_calls": [...],  # List of tools called (for debugging)
-                "mode": mode
-            }
-        """
-        print(f"\n🤖 Agent Mode: {mode}")
-        print(f"👤 User Message: {user_message}")
-        
-        # Store access_token for tool calls
-        self.current_access_token = access_token
-        
-        # Select system prompt
-        system_prompt = self._get_system_prompt(mode)
-        
-        # Build conversation context
-        messages = self._build_messages(system_prompt, conversation_history, user_message)
-        
-        # Agentic loop: LLM may call tools multiple times
-        tool_calls_made = []
-        current_response = None
-        
-        for iteration in range(max_iterations):
-            print(f"\n🔄 Iteration {iteration + 1}")
-            
-            # Call LLM
-            llm_response = await self._call_llm(messages)
-            print(f"🧠 LLM Response: {llm_response[:200]}...")
-            
-            # Check if LLM wants to call a tool
-            tool_call = self._parse_tool_call(llm_response)
-            
-            if not tool_call:
-                # No tool call -> This is the final response
-                current_response = llm_response
-                break
-            
-            # Execute tool
-            print(f"🔧 Tool Called: {tool_call['tool_name']}")
-            tool_result = await self.tools_service.execute_tool(
-                tool_call['tool_name'],
-                tool_call['arguments'],
-                access_token=self.current_access_token  # Pass access_token
-            )
-            
-            # Record tool call
-            tool_calls_made.append({
-                "function": tool_call['tool_name'],
-                "arguments": tool_call['arguments'],
-                "result": tool_result
-            })
-            
-            # Add tool result to conversation
-            messages.append({
-                "role": "assistant",
-                "content": llm_response
-            })
-            messages.append({
-                "role": "system",
-                "content": f"Tool Result:\n{self._format_tool_result({'result': tool_result})}"
-            })
-            
-            # If tool returns "run_rag_search", handle it specially
-            if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
-                rag_results = await self._execute_rag_search(tool_result["query"])
-                messages[-1]["content"] = f"RAG Search Results:\n{rag_results}"
-        
-        # Clean up response
-        final_response = current_response or llm_response
-        final_response = self._clean_response(final_response)
-        
-        return {
-            "message": final_response,
-            "tool_calls": tool_calls_made,
-            "mode": mode
-        }
-    
-    def _get_system_prompt(self, mode: str) -> str:
-        """Get system prompt for selected mode with tools definition"""
-        prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
-        base_prompt = self.prompts.get(prompt_key, "")
-        
-        # Add tools definition
-        tools_definition = self._get_tools_definition()
-        
-        return f"{base_prompt}\n\n{tools_definition}"
-    
-    def _get_tools_definition(self) -> str:
-        """Get tools definition in text format for prompt"""
-        return """
-# AVAILABLE TOOLS
-
-You can call the following tools when needed. To call a tool, output a JSON block like this:
-
-```json
-{
-  "tool_call": "tool_name",
-  "arguments": {
-    "arg1": "value1",
-    "arg2": "value2"
-  }
-}
-```
-
-## Tools List:
-
-### 1. search_events
-Search for events matching user criteria.
-Arguments:
-- query (string): Search keywords
-- vibe (string, optional): Mood/vibe (e.g., "chill", "sôi động")
-- time (string, optional): Time period (e.g., "cuối tuần này")
-
-Example:
-```json
-{"tool_call": "search_events", "arguments": {"query": "nhạc rock", "vibe": "sôi động"}}
-```
-
-### 2. get_event_details
-Get detailed information about a specific event.
-Arguments:
-- event_id (string): Event ID from search results
-
-Example:
-```json
-{"tool_call": "get_event_details", "arguments": {"event_id": "6900ae38eb03f29702c7fd1d"}}
-```
-
-### 3. get_purchased_events (Feedback mode only)
-Check which events the user has attended.
-Arguments:
-- user_id (string): User ID
-
-Example:
-```json
-{"tool_call": "get_purchased_events", "arguments": {"user_id": "user_123"}}
-```
-
-### 4. save_feedback
-Save user's feedback/review for an event.
-Arguments:
-- event_id (string): Event ID
-- rating (integer): 1-5 stars
-- comment (string, optional): User's comment
-
-Example:
-```json
-{"tool_call": "save_feedback", "arguments": {"event_id": "abc123", "rating": 5, "comment": "Tuyệt vời!"}}
-```
-
-### 5. save_lead
-Save customer contact information.
-Arguments:
-- email (string, optional): Email address
-- phone (string, optional): Phone number
-- interest (string, optional): What they're interested in
-
-Example:
-```json
-{"tool_call": "save_lead", "arguments": {"email": "user@example.com", "interest": "Rock show"}}
-```
-
-**IMPORTANT:**
-- Call tools ONLY when you need real-time data
-- After receiving tool results, respond naturally to the user
-- Don't expose raw JSON to users - always format nicely
-"""
-    
-    def _build_messages(
-        self,
-        system_prompt: str,
-        history: List[Dict],
-        user_message: str
-    ) -> List[Dict]:
-        """Build messages array for LLM"""
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Add conversation history
-        messages.extend(history)
-        
-        # Add current user message
-        messages.append({"role": "user", "content": user_message})
-        
-        return messages
-    
-    async def _call_llm(self, messages: List[Dict]) -> str:
-        """
-        Call HuggingFace LLM directly using chat_completion (conversational)
-        """
-        try:
-            from huggingface_hub import AsyncInferenceClient
-            
-            # Create async client
-            client = AsyncInferenceClient(token=self.hf_token)
-            
-            # Call HF API with chat completion (conversational)
-            response_text = ""
-            async for message in await client.chat_completion(
-                messages=messages,  # Use messages directly
-                model="meta-llama/Llama-3.3-70B-Instruct",
-                max_tokens=512,
-                temperature=0.7,
-                stream=True
-            ):
-                if message.choices and message.choices[0].delta.content:
-                    response_text += message.choices[0].delta.content
-            
-            return response_text
-        except Exception as e:
-            print(f"⚠️ LLM Call Error: {e}")
-            return "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
-    
-    def _messages_to_prompt(self, messages: List[Dict]) -> str:
-        """Convert messages array to single prompt string"""
-        prompt_parts = []
-        
-        for msg in messages:
-            role = msg["role"]
-            content = msg["content"]
-            
-            if role == "system":
-                prompt_parts.append(f"[SYSTEM]\n{content}\n")
-            elif role == "user":
-                prompt_parts.append(f"[USER]\n{content}\n")
-            elif role == "assistant":
-                prompt_parts.append(f"[ASSISTANT]\n{content}\n")
-        
-        return "\n".join(prompt_parts)
-    
-    def _format_tool_result(self, tool_result: Dict) -> str:
-        """Format tool result for feeding back to LLM"""
-        result = tool_result.get("result", {})
-        
-        if isinstance(result, dict):
-            # Pretty print key info
-            formatted = []
-            for key, value in result.items():
-                if key not in ["success", "error"]:
-                    formatted.append(f"{key}: {value}")
-            return "\n".join(formatted)
-        
-        return str(result)
-    
-    async def _execute_rag_search(self, query_params: Dict) -> str:
-        """
-        Execute RAG search for event discovery
-        Called when LLM wants to search_events
-        """
-        query = query_params.get("query", "")
-        vibe = query_params.get("vibe", "")
-        
-        # Build search query
-        search_text = f"{query} {vibe}".strip()
-        
-        print(f"🔍 RAG Search: {search_text}")
-        
-        # Use embedding + qdrant
-        embedding = self.embedding_service.encode_text(search_text)
-        results = self.qdrant_service.search(
-            query_embedding=embedding,
-            limit=5
-        )
-        
-        # Format results
-        formatted = []
-        for i, result in enumerate(results, 1):
-            # Result is a dict with keys: id, score, payload
-            payload = result.get("payload", {})
-            texts = payload.get("texts", [])
-            text = texts[0] if texts else ""
-            event_id = payload.get("id_use", "")
-            
-            formatted.append(f"{i}. {text[:100]}... (ID: {event_id})")
-        
-        return "\n".join(formatted) if formatted else "Không tìm thấy sự kiện phù hợp."
-    
-    def _parse_tool_call(self, llm_response: str) -> Optional[Dict]:
-        """
-        Parse LLM response to detect tool calls using structured JSON
-        
-        Returns:
-            {"tool_name": "...", "arguments": {...}} or None
-        """
-        import json
-        import re
-        
-        # Method 1: Look for JSON code block
-        json_match = re.search(r'```json\s*(\{.*?\})\s*```', llm_response, re.DOTALL)
-        if json_match:
-            try:
-                data = json.loads(json_match.group(1))
-                return self._extract_tool_from_json(data)
-            except json.JSONDecodeError:
-                pass
-        
-        # Method 2: Look for inline JSON object
-        # Find all potential JSON objects
-        json_objects = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', llm_response)
-        for json_str in json_objects:
-            try:
-                data = json.loads(json_str)
-                tool_call = self._extract_tool_from_json(data)
-                if tool_call:
-                    return tool_call
-            except json.JSONDecodeError:
-                continue
-        
-        # Method 3: Nested JSON (for complex structures)
-        try:
-            # Find outermost curly braces
-            if '{' in llm_response and '}' in llm_response:
-                start = llm_response.find('{')
-                # Find matching closing brace
-                count = 0
-                for i, char in enumerate(llm_response[start:], start):
-                    if char == '{':
-                        count += 1
-                    elif char == '}':
-                        count -= 1
-                        if count == 0:
-                            json_str = llm_response[start:i+1]
-                            data = json.loads(json_str)
-                            return self._extract_tool_from_json(data)
-        except (json.JSONDecodeError, ValueError):
-            pass
-        
-        return None
-    
-    def _extract_tool_from_json(self, data: dict) -> Optional[Dict]:
-        """
-        Extract tool call information from parsed JSON
-        
-        Supports multiple formats:
-        - {"tool_call": "search_events", "arguments": {...}}
-        - {"function": "search_events", "parameters": {...}}
-        - {"name": "search_events", "args": {...}}
-        """
-        # Format 1: tool_call + arguments
-        if "tool_call" in data and isinstance(data["tool_call"], str):
-            return {
-                "tool_name": data["tool_call"],
-                "arguments": data.get("arguments", {})
-            }
-        
-        # Format 2: function + parameters
-        if "function" in data:
-            return {
-                "tool_name": data["function"],
-                "arguments": data.get("parameters", data.get("arguments", {}))
-            }
-        
-        # Format 3: name + args
-        if "name" in data:
-            return {
-                "tool_name": data["name"],
-                "arguments": data.get("args", data.get("arguments", {}))
-            }
-        
-        # Format 4: Direct tool name as key
-        valid_tools = ["search_events", "get_event_details", "get_purchased_events", "save_feedback", "save_lead"]
-        for tool in valid_tools:
-            if tool in data:
-                return {
-                    "tool_name": tool,
-                    "arguments": data[tool] if isinstance(data[tool], dict) else {}
-                }
-        
-        return None
-    
-    def _clean_response(self, response: str) -> str:
-        """Remove JSON artifacts from final response"""
-        # Remove JSON blocks
-        if "```json" in response:
-            response = response.split("```json")[0]
-        if "```" in response:
-            response = response.split("```")[0]
-        
-        # Remove tool call markers
-        if "{" in response and "tool_call" in response:
-            # Find the last natural sentence before JSON
-            lines = response.split("\n")
-            cleaned = []
-            for line in lines:
-                if "{" in line and "tool_call" in line:
-                    break
-                cleaned.append(line)
-            response = "\n".join(cleaned)
-        
-        return response.strip()
+"""
+Agent Service - Central Brain for Sales & Feedback Agents
+Manages LLM conversation loop with tool calling
+"""
+from typing import Dict, Any, List, Optional
+import os
+from tools_service import ToolsService
+
+
+class AgentService:
+    """
+    Manages the conversation loop between User -> LLM -> Tools -> Response
+    """
+    
+    def __init__(
+        self,
+        tools_service: ToolsService,
+        embedding_service,
+        qdrant_service,
+        advanced_rag,
+        hf_token: str,
+        feedback_tracking=None  # NEW: Optional feedback tracking
+    ):
+        self.tools_service = tools_service
+        self.embedding_service = embedding_service
+        self.qdrant_service = qdrant_service
+        self.advanced_rag = advanced_rag
+        self.hf_token = hf_token
+        self.feedback_tracking = feedback_tracking
+        
+        # Load system prompts
+        self.prompts = self._load_prompts()
+    
+    def _load_prompts(self) -> Dict[str, str]:
+        """Load system prompts from files"""
+        prompts = {}
+        prompts_dir = "prompts"
+        
+        for mode in ["sales_agent", "feedback_agent"]:
+            filepath = os.path.join(prompts_dir, f"{mode}.txt")
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    prompts[mode] = f.read()
+                print(f"✓ Loaded prompt: {mode}")
+            except Exception as e:
+                print(f"⚠️ Error loading {mode} prompt: {e}")
+                prompts[mode] = ""
+        
+        return prompts
+    
+    async def chat(
+        self,
+        user_message: str,
+        conversation_history: List[Dict],
+        mode: str = "sales",  # "sales" or "feedback"
+        user_id: Optional[str] = None,
+        access_token: Optional[str] = None,  # NEW: For authenticated API calls
+        max_iterations: int = 3
+    ) -> Dict[str, Any]:
+        """
+        Main conversation loop
+        
+        Args:
+            user_message: User's input
+            conversation_history: Previous messages [{"role": "user", "content": ...}, ...]
+            mode: "sales" or "feedback"
+            user_id: User ID (for feedback mode to check purchase history)
+            access_token: JWT token for authenticated API calls
+            max_iterations: Maximum tool call iterations to prevent infinite loops
+        
+        Returns:
+            {
+                "message": "Bot response",
+                "tool_calls": [...],  # List of tools called (for debugging)
+                "mode": mode
+            }
+        """
+        print(f"\n🤖 Agent Mode: {mode}")
+        print(f"👤 User Message: {user_message}")
+        print(f"🔑 Auth Info:")
+        print(f"  - User ID: {user_id}")
+        print(f"  - Access Token: {'✅ Received' if access_token else '❌ None'}")
+        
+        # Store user_id and access_token for tool calls
+        self.current_user_id = user_id
+        self.current_access_token = access_token
+        if access_token:
+            print(f"  - Stored access_token for tools: {access_token[:20]}...")
+        if user_id:
+            print(f"  - Stored user_id for tools: {user_id}")
+        
+        # Select system prompt
+        system_prompt = self._get_system_prompt(mode)
+        
+        # Build conversation context
+        messages = self._build_messages(system_prompt, conversation_history, user_message)
+        
+        # Agentic loop: LLM may call tools multiple times
+        tool_calls_made = []
+        current_response = None
+        
+        for iteration in range(max_iterations):
+            print(f"\n🔄 Iteration {iteration + 1}")
+            
+            # Call LLM
+            llm_response = await self._call_llm(messages)
+            print(f"🧠 LLM Response: {llm_response[:200]}...")
+            
+            # Check if LLM wants to call a tool
+            tool_call = self._parse_tool_call(llm_response)
+            
+            if not tool_call:
+                # No tool call -> This is the final response
+                current_response = llm_response
+                break
+            
+            # Execute tool
+            print(f"🔧 Tool Called: {tool_call['tool_name']}")
+            
+            # Auto-inject real user_id for get_purchased_events
+            if tool_call['tool_name'] == 'get_purchased_events' and self.current_user_id:
+                print(f"🔄 Auto-injecting real user_id: {self.current_user_id}")
+                tool_call['arguments']['user_id'] = self.current_user_id
+            
+            tool_result = await self.tools_service.execute_tool(
+                tool_call['tool_name'],
+                tool_call['arguments'],
+                access_token=self.current_access_token  # Pass access_token
+            )
+            
+            # Record tool call
+            tool_calls_made.append({
+                "function": tool_call['tool_name'],
+                "arguments": tool_call['arguments'],
+                "result": tool_result
+            })
+            
+            # Add tool result to conversation
+            messages.append({
+                "role": "assistant",
+                "content": llm_response
+            })
+            messages.append({
+                "role": "system",
+                "content": f"Tool Result:\n{self._format_tool_result({'result': tool_result})}"
+            })
+            
+            # If tool returns "run_rag_search", handle it specially
+            if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
+                rag_results = await self._execute_rag_search(tool_result["query"])
+                messages[-1]["content"] = f"RAG Search Results:\n{rag_results}"
+        
+        # Clean up response
+        final_response = current_response or llm_response
+        final_response = self._clean_response(final_response)
+        
+        return {
+            "message": final_response,
+            "tool_calls": tool_calls_made,
+            "mode": mode
+        }
+    
+    def _get_system_prompt(self, mode: str) -> str:
+        """Get system prompt for selected mode with tools definition"""
+        prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
+        base_prompt = self.prompts.get(prompt_key, "")
+        
+        # Add tools definition
+        tools_definition = self._get_tools_definition()
+        
+        return f"{base_prompt}\n\n{tools_definition}"
+    
+    def _get_tools_definition(self) -> str:
+        """Get tools definition in text format for prompt"""
+        return """
+# AVAILABLE TOOLS
+
+You can call the following tools when needed. To call a tool, output a JSON block like this:
+
+```json
+{
+  "tool_call": "tool_name",
+  "arguments": {
+    "arg1": "value1",
+    "arg2": "value2"
+  }
+}
+```
+
+## Tools List:
+
+### 1. search_events
+Search for events matching user criteria.
+Arguments:
+- query (string): Search keywords
+- vibe (string, optional): Mood/vibe (e.g., "chill", "sôi động")
+- time (string, optional): Time period (e.g., "cuối tuần này")
+
+Example:
+```json
+{"tool_call": "search_events", "arguments": {"query": "nhạc rock", "vibe": "sôi động"}}
+```
+
+### 2. get_event_details
+Get detailed information about a specific event.
+Arguments:
+- event_id (string): Event ID from search results
+
+Example:
+```json
+{"tool_call": "get_event_details", "arguments": {"event_id": "6900ae38eb03f29702c7fd1d"}}
+```
+
+### 3. get_purchased_events (Feedback mode only)
+Check which events the user has attended.
+Arguments:
+- user_id (string): User ID
+
+Example:
+```json
+{"tool_call": "get_purchased_events", "arguments": {"user_id": "user_123"}}
+```
+
+### 4. save_feedback
+Save user's feedback/review for an event.
+Arguments:
+- event_id (string): Event ID
+- rating (integer): 1-5 stars
+- comment (string, optional): User's comment
+
+Example:
+```json
+{"tool_call": "save_feedback", "arguments": {"event_id": "abc123", "rating": 5, "comment": "Tuyệt vời!"}}
+```
+
+### 5. save_lead
+Save customer contact information.
+Arguments:
+- email (string, optional): Email address
+- phone (string, optional): Phone number
+- interest (string, optional): What they're interested in
+
+Example:
+```json
+{"tool_call": "save_lead", "arguments": {"email": "user@example.com", "interest": "Rock show"}}
+```
+
+**IMPORTANT:**
+- Call tools ONLY when you need real-time data
+- After receiving tool results, respond naturally to the user
+- Don't expose raw JSON to users - always format nicely
+"""
+    
+    def _build_messages(
+        self,
+        system_prompt: str,
+        history: List[Dict],
+        user_message: str
+    ) -> List[Dict]:
+        """Build messages array for LLM"""
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Add conversation history
+        messages.extend(history)
+        
+        # Add current user message
+        messages.append({"role": "user", "content": user_message})
+        
+        return messages
+    
+    async def _call_llm(self, messages: List[Dict]) -> str:
+        """
+        Call HuggingFace LLM directly using chat_completion (conversational)
+        """
+        try:
+            from huggingface_hub import AsyncInferenceClient
+            
+            # Create async client
+            client = AsyncInferenceClient(token=self.hf_token)
+            
+            # Call HF API with chat completion (conversational)
+            response_text = ""
+            async for message in await client.chat_completion(
+                messages=messages,  # Use messages directly
+                model="meta-llama/Llama-3.3-70B-Instruct",
+                max_tokens=512,
+                temperature=0.7,
+                stream=True
+            ):
+                if message.choices and message.choices[0].delta.content:
+                    response_text += message.choices[0].delta.content
+            
+            return response_text
+        except Exception as e:
+            print(f"⚠️ LLM Call Error: {e}")
+            return "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
+    
+    def _messages_to_prompt(self, messages: List[Dict]) -> str:
+        """Convert messages array to single prompt string"""
+        prompt_parts = []
+        
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            
+            if role == "system":
+                prompt_parts.append(f"[SYSTEM]\n{content}\n")
+            elif role == "user":
+                prompt_parts.append(f"[USER]\n{content}\n")
+            elif role == "assistant":
+                prompt_parts.append(f"[ASSISTANT]\n{content}\n")
+        
+        return "\n".join(prompt_parts)
+    
+    def _format_tool_result(self, tool_result: Dict) -> str:
+        """Format tool result for feeding back to LLM"""
+        result = tool_result.get("result", {})
+        
+        if isinstance(result, dict):
+            # Pretty print key info
+            formatted = []
+            for key, value in result.items():
+                if key not in ["success", "error"]:
+                    formatted.append(f"{key}: {value}")
+            return "\n".join(formatted)
+        
+        return str(result)
+    
+    async def _execute_rag_search(self, query_params: Dict) -> str:
+        """
+        Execute RAG search for event discovery
+        Called when LLM wants to search_events
+        """
+        query = query_params.get("query", "")
+        vibe = query_params.get("vibe", "")
+        
+        # Build search query
+        search_text = f"{query} {vibe}".strip()
+        
+        print(f"🔍 RAG Search: {search_text}")
+        
+        # Use embedding + qdrant
+        embedding = self.embedding_service.encode_text(search_text)
+        results = self.qdrant_service.search(
+            query_embedding=embedding,
+            limit=5
+        )
+        
+        # Format results
+        formatted = []
+        for i, result in enumerate(results, 1):
+            # Result is a dict with keys: id, score, payload
+            payload = result.get("payload", {})
+            texts = payload.get("texts", [])
+            text = texts[0] if texts else ""
+            event_id = payload.get("id_use", "")
+            
+            formatted.append(f"{i}. {text[:100]}... (ID: {event_id})")
+        
+        return "\n".join(formatted) if formatted else "Không tìm thấy sự kiện phù hợp."
+    
+    def _parse_tool_call(self, llm_response: str) -> Optional[Dict]:
+        """
+        Parse LLM response to detect tool calls using structured JSON
+        
+        Returns:
+            {"tool_name": "...", "arguments": {...}} or None
+        """
+        import json
+        import re
+        
+        # Method 1: Look for JSON code block
+        json_match = re.search(r'```json\s*(\{.*?\})\s*```', llm_response, re.DOTALL)
+        if json_match:
+            try:
+                data = json.loads(json_match.group(1))
+                return self._extract_tool_from_json(data)
+            except json.JSONDecodeError:
+                pass
+        
+        # Method 2: Look for inline JSON object
+        # Find all potential JSON objects
+        json_objects = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', llm_response)
+        for json_str in json_objects:
+            try:
+                data = json.loads(json_str)
+                tool_call = self._extract_tool_from_json(data)
+                if tool_call:
+                    return tool_call
+            except json.JSONDecodeError:
+                continue
+        
+        # Method 3: Nested JSON (for complex structures)
+        try:
+            # Find outermost curly braces
+            if '{' in llm_response and '}' in llm_response:
+                start = llm_response.find('{')
+                # Find matching closing brace
+                count = 0
+                for i, char in enumerate(llm_response[start:], start):
+                    if char == '{':
+                        count += 1
+                    elif char == '}':
+                        count -= 1
+                        if count == 0:
+                            json_str = llm_response[start:i+1]
+                            data = json.loads(json_str)
+                            return self._extract_tool_from_json(data)
+        except (json.JSONDecodeError, ValueError):
+            pass
+        
+        return None
+    
+    def _extract_tool_from_json(self, data: dict) -> Optional[Dict]:
+        """
+        Extract tool call information from parsed JSON
+        
+        Supports multiple formats:
+        - {"tool_call": "search_events", "arguments": {...}}
+        - {"function": "search_events", "parameters": {...}}
+        - {"name": "search_events", "args": {...}}
+        """
+        # Format 1: tool_call + arguments
+        if "tool_call" in data and isinstance(data["tool_call"], str):
+            return {
+                "tool_name": data["tool_call"],
+                "arguments": data.get("arguments", {})
+            }
+        
+        # Format 2: function + parameters
+        if "function" in data:
+            return {
+                "tool_name": data["function"],
+                "arguments": data.get("parameters", data.get("arguments", {}))
+            }
+        
+        # Format 3: name + args
+        if "name" in data:
+            return {
+                "tool_name": data["name"],
+                "arguments": data.get("args", data.get("arguments", {}))
+            }
+        
+        # Format 4: Direct tool name as key
+        valid_tools = ["search_events", "get_event_details", "get_purchased_events", "save_feedback", "save_lead"]
+        for tool in valid_tools:
+            if tool in data:
+                return {
+                    "tool_name": tool,
+                    "arguments": data[tool] if isinstance(data[tool], dict) else {}
+                }
+        
+        return None
+    
+    def _clean_response(self, response: str) -> str:
+        """Remove JSON artifacts from final response"""
+        # Remove JSON blocks
+        if "```json" in response:
+            response = response.split("```json")[0]
+        if "```" in response:
+            response = response.split("```")[0]
+        
+        # Remove tool call markers
+        if "{" in response and "tool_call" in response:
+            # Find the last natural sentence before JSON
+            lines = response.split("\n")
+            cleaned = []
+            for line in lines:
+                if "{" in line and "tool_call" in line:
+                    break
+                cleaned.append(line)
+            response = "\n".join(cleaned)
+        
+        return response.strip()

feedback_tracking_service.py

@@ -0,0 +1,103 @@
+"""
+Feedback Tracking Service
+Tracks which events users have already given feedback for
+"""
+from typing import Optional, Dict
+from pymongo.collection import Collection
+from datetime import datetime
+
+
+class FeedbackTrackingService:
+    """
+    Track feedback status per user per event
+    Prevents redundant "check purchase history" calls
+    """
+    
+    def __init__(self, mongo_collection: Collection):
+        self.collection = mongo_collection
+        self._ensure_indexes()
+    
+    def _ensure_indexes(self):
+        """Create indexes for fast lookup"""
+        try:
+            # Compound index for quick lookup
+            self.collection.create_index([("user_id", 1), ("event_code", 1)], unique=True)
+            self.collection.create_index("user_id")
+            print("✓ Feedback tracking indexes created")
+        except Exception as e:
+            print(f"Feedback tracking indexes exist: {e}")
+    
+    def has_given_feedback(self, user_id: str, event_code: str) -> bool:
+        """
+        Check if user has already given feedback for this event
+        
+        Args:
+            user_id: User ID
+            event_code: Event code
+        
+        Returns:
+            True if feedback already given, False otherwise
+        """
+        result = self.collection.find_one({
+            "user_id": user_id,
+            "event_code": event_code,
+            "is_feedback": True
+        })
+        return result is not None
+    
+    def mark_feedback_given(self, user_id: str, event_code: str, rating: int, comment: str = "") -> bool:
+        """
+        Mark that user has given feedback for this event
+        
+        Args:
+            user_id: User ID
+            event_code: Event code
+            rating: Rating given (1-5)
+            comment: Feedback comment
+        
+        Returns:
+            True if saved successfully
+        """
+        try:
+            self.collection.update_one(
+                {
+                    "user_id": user_id,
+                    "event_code": event_code
+                },
+                {
+                    "$set": {
+                        "is_feedback": True,
+                        "rating": rating,
+                        "comment": comment,
+                        "feedback_date": datetime.utcnow(),
+                        "updated_at": datetime.utcnow()
+                    },
+                    "$setOnInsert": {
+                        "created_at": datetime.utcnow()
+                    }
+                },
+                upsert=True
+            )
+            print(f"✅ Marked feedback: {user_id} → {event_code} (rating: {rating})")
+            return True
+        except Exception as e:
+            print(f"❌ Error marking feedback: {e}")
+            return False
+    
+    def get_pending_events(self, user_id: str, purchased_events: list) -> list:
+        """
+        Filter purchased events to only those without feedback
+        
+        Args:
+            user_id: User ID
+            purchased_events: List of events user has purchased
+        
+        Returns:
+            List of events that need feedback
+        """
+        pending = []
+        for event in purchased_events:
+            event_code = event.get("eventCode")
+            if event_code and not self.has_given_feedback(user_id, event_code):
+                pending.append(event)
+        return pending

main.py

@@ -21,6 +21,7 @@ from conversation_service import ConversationService
 from tools_service import ToolsService
 from agent_service import AgentService
 from agent_chat_stream import agent_chat_stream  # NEW: Agent Streaming
+from feedback_tracking_service import FeedbackTrackingService  # NEW: Feedback tracking
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -105,8 +106,16 @@ conversations_collection = db["conversations"]
 conversation_service = ConversationService(conversations_collection, max_history=10)
 print("✓ Conversation Service initialized")
 
+# Initialize Feedback Tracking Service
+feedback_tracking_collection = db["feedback_tracking"]
+feedback_tracking = FeedbackTrackingService(feedback_tracking_collection)
+print("✓ Feedback Tracking Service initialized")
+
 # Initialize Tools Service
-tools_service = ToolsService(base_url="https://hoalacrent.io.vn/api/v0")
+tools_service = ToolsService(
+    base_url="https://hoalacrent.io.vn/api/v0",
+    feedback_tracking=feedback_tracking
+)
 print("✓ Tools Service initialized (Function Calling enabled)")
 
 # Initialize Agent Service (Agentic Workflow)
@@ -115,7 +124,8 @@ agent_service = AgentService(
     embedding_service=embedding_service,
     qdrant_service=qdrant_service,
     advanced_rag=advanced_rag,
-    hf_token=hf_token
+    hf_token=hf_token,
+    feedback_tracking=feedback_tracking  # Pass feedback tracking
 )
 print("✓ Agent Service initialized (Agentic Workflow enabled)")
 
@@ -150,6 +160,7 @@ class ChatRequest(BaseModel):
     user_id: Optional[str] = None  # User identifier for session tracking
     access_token: Optional[str] = None  # NEW: For authenticated API calls (feedback mode)
     mode: str = "sales"  # NEW: "sales" or "feedback" for agent selection
+    event_code: Optional[str] = None  # NEW: For targeted feedback on specific event
     use_rag: bool = True
     top_k: int = 3
     system_message: Optional[str] = """Bạn là trợ lý AI chuyên biệt cho hệ thống quản lý sự kiện và bán vé. 

tools_service.py

@@ -13,9 +13,10 @@ class ToolsService:
     Manages external API tools that LLM can call via prompt engineering
     """
     
-    def __init__(self, base_url: str = "https://hoalacrent.io.vn/api/v0"):
+    def __init__(self, base_url: str = "https://hoalacrent.io.vn/api/v0", feedback_tracking=None):
         self.base_url = base_url
         self.client = httpx.AsyncClient(timeout=10.0)
+        self.feedback_tracking = feedback_tracking  # NEW: Feedback tracking
     
     def get_tools_definition(self) -> List[Dict]:
         """
@@ -201,10 +202,29 @@ class ToolsService:
             traceback.print_exc()
             return []
 
-    async def _save_feedback(self, event_id: str, rating: int, comment: str) -> Dict:
-        """Save feedback (Mock or Real API)"""
-        # TODO: Implement real API call when available
-        print(f"📝 Saving Feedback: Event={event_id}, Rating={rating}, Comment={comment}")
+    async def _save_feedback(self, event_id: str, rating: int, comment: str, user_id: str = None, event_code: str = None) -> Dict:
+        """Save feedback and mark as completed in tracking system"""
+        print(f"\n📝 ===== SAVE FEEDBACK =====")
+        print(f"Event ID: {event_id}")
+        print(f"Event Code: {event_code}")
+        print(f"User ID: {user_id}")
+        print(f"Rating: {rating}")
+        print(f"Comment: {comment}")
+        
+        # TODO: Implement real API call to save feedback
+        # For now, just mark in tracking system
+        if self.feedback_tracking and user_id and event_code:
+            success = self.feedback_tracking.mark_feedback_given(
+                user_id=user_id,
+                event_code=event_code,
+                rating=rating,
+                comment=comment
+            )
+            if success:
+                print(f"✅ Feedback tracked in database")
+            else:
+                print(f"⚠️ Failed to track feedback")
+        
         return {"success": True, "message": "Feedback recorded"}
 
     async def close(self):