fix intent and add plan

app/agent/mmca_agent.py

@@ -24,7 +24,9 @@ from app.shared.logger import agent_logger, AgentWorkflow, WorkflowStep
 from app.shared.prompts import (
     MMCA_SYSTEM_PROMPT as SYSTEM_PROMPT,
     GREETING_SYSTEM_PROMPT,
+    INTENT_SYSTEM_PROMPT,
     build_greeting_prompt,
+    build_intent_prompt,
     build_synthesis_prompt,
 )
 
@@ -133,19 +135,24 @@ class MMCAAgent:
         # Add user message to internal history
         self.conversation_history.append(ChatMessage(role="user", content=message))
 
-        # Step 1: Analyze intent and decide tool usage
+        # Step 1: Analyze intent and plan tools (LLM-based)
         workflow.add_step(WorkflowStep(
             step_name="Intent Analysis",
             purpose="Phân tích câu hỏi để chọn tool phù hợp"
         ))
         
         agent_logger.workflow_step("Step 1: Intent Analysis", message[:80])
-        intent = self._detect_intent(message, image_url)
-        workflow.intent_detected = intent
-        agent_logger.workflow_step("Intent detected", intent)
         
         tool_calls = await self._plan_tool_calls(message, image_url)
         
+        # Set intent based on selected tools (from LLM)
+        if not tool_calls:
+            intent = "greeting"
+        else:
+            intent = " + ".join([tc.tool_name for tc in tool_calls])
+        workflow.intent_detected = intent
+        agent_logger.workflow_step("Intent detected", intent)
+        
         workflow.add_step(WorkflowStep(
             step_name="Tool Planning",
             purpose=f"Chọn {len(tool_calls)} tool(s) để thực thi",
@@ -217,27 +224,6 @@ class MMCAAgent:
             selected_place_ids=selected_place_ids,
         )
 
-    def _detect_intent(self, message: str, image_url: str | None) -> str:
-        """Detect user intent for logging."""
-        intents = []
-        
-        if image_url:
-            intents.append("visual_search")
-        
-        location_keywords = ["gần", "cách", "nearby", "gần đây", "quanh", "xung quanh"]
-        if any(kw in message.lower() for kw in location_keywords):
-            intents.append("location_search")
-        
-        if not intents:
-            intents.append("text_search")
-        
-        # Social intent detection
-        social_keywords = ["review", "tin hot", "trend", "tin mới", "tiktok", "facebook", "reddit", "youtube", "mạng xã hội"]
-        if any(kw in message.lower() for kw in social_keywords):
-            intents.append("social_search")
-            
-        return " + ".join(intents)
-
     def _get_tool_purpose(self, tool_name: str) -> str:
         """Get human-readable purpose for tool."""
         purposes = {
@@ -248,116 +234,116 @@ class MMCAAgent:
         }
         return purposes.get(tool_name, tool_name)
 
-    def _is_greeting_or_simple_query(self, message: str) -> bool:
-        """
-        Check if message is a simple greeting/small-talk that doesn't need tools.
-        
-        Returns True for greetings, thanks, simple acknowledgments.
-        """
-        simple_patterns = [
-            # English
-            "hello", "hi", "hey", "yo", "sup",
-            "thank", "thanks", "bye", "goodbye",
-            "ok", "okay", "yes", "no", "good", "great", "nice",
-            # Vietnamese
-            "xin chào", "chào", "chào bạn", "ê", "alo",
-            "cảm ơn", "cám ơn", "thanks", "tạm biệt", "bye",
-            "ok", "được", "tốt", "hay", "ừ", "ờ", "vâng", "dạ",
-        ]
-        msg_lower = message.lower().strip()
-        
-        # Very short messages are likely greetings
-        if len(msg_lower) < 15:
-            for pattern in simple_patterns:
-                if pattern in msg_lower:
-                    return True
-            # Also check if message is just a single word greeting
-            if msg_lower in simple_patterns:
-                return True
-        
-        return False
-
     async def _plan_tool_calls(
         self,
         message: str,
         image_url: str | None = None,
     ) -> list[ToolCall]:
         """
-        Analyze message and plan which tools to call.
+        Use LLM to analyze message and plan which tools to call.
 
         Returns list of ToolCall objects with tool_name and arguments.
-        Returns empty list for simple greetings (no tools needed).
+        Returns empty list for greetings/small-talk (LLM detects via is_greeting).
         """
-        # Early exit for greetings - no tools needed
-        if self._is_greeting_or_simple_query(message) and not image_url:
-            agent_logger.workflow_step("Greeting detected", "Skipping tools")
-            return []
-        
-        tool_calls = []
-
-        # If image is provided, always use visual search
+        # If image is provided, always use visual search (fast path)
         if image_url:
-            tool_calls.append(ToolCall(
+            return [ToolCall(
                 tool_name="retrieve_similar_visuals",
                 arguments={"image_url": image_url, "limit": 5},
-            ))
-
-        # Check for social media intent FIRST
-        social_keywords = ["review", "tin hot", "trend", "tin mới", "tiktok", "facebook", "reddit", "youtube", "mạng xã hội"]
-        if any(kw in message.lower() for kw in social_keywords):
-            # Determine freshness
-            freshness = "pw" # Default past week
-            if "tháng" in message.lower() or "month" in message.lower():
-                freshness = "pm"
+            )]
+        
+        # Use LLM to detect intent and select tools
+        intent_prompt = build_intent_prompt(message, has_image=bool(image_url))
+        
+        try:
+            intent_response = await self.llm_client.generate(
+                prompt=intent_prompt,
+                temperature=0.2,  # Low temperature for consistent JSON
+                system_instruction=INTENT_SYSTEM_PROMPT,
+            )
             
-            # Determine platforms
-            platforms = []
-            for p in ["tiktok", "facebook", "reddit", "youtube", "twitter", "instagram"]:
-                if p in message.lower():
-                    platforms.append(p)
+            agent_logger.workflow_step("LLM Intent Detection", intent_response[:200])
             
-            tool_calls.append(ToolCall(
-                tool_name="search_social_media",
-                arguments={
-                    "query": message,
-                    "limit": 5,
-                    "freshness": freshness,
-                    "platforms": platforms if platforms else None
-                }
-            ))
-
-        # Analyze message for location/proximity queries
-        location_keywords = ["gần", "cách", "nearby", "gần đây", "quanh", "xung quanh"]
-        if any(kw in message.lower() for kw in location_keywords):
-            # Extract location name from message
-            location = self._extract_location(message)
-            category = self._extract_category(message)
-
-            # Get coordinates for the location
-            coords = await self.tools.get_location_coordinates(location) if location else None
-            lat, lng = coords if coords else DANANG_CENTER
-
-            tool_calls.append(ToolCall(
-                tool_name="find_nearby_places",
-                arguments={
-                    "lat": lat,
-                    "lng": lng,
-                    "category": category,
-                    "max_distance_km": 3.0,
-                    "limit": 5,
-                },
-            ))
-
-        # For general queries without location keywords AND NO SOCIAL INTENT, use text search
-        # If social search is already triggered, we might skip text search to avoid noise, 
-        # or keep it if query is mixed. For now, let's keep text search only if no other tools used.
-        if not tool_calls:
-            tool_calls.append(ToolCall(
+            # Parse JSON response
+            tool_calls = self._parse_intent_response(intent_response, message)
+            return tool_calls
+            
+        except Exception as e:
+            agent_logger.error(f"Intent detection failed: {e}", None)
+            # Fallback to text search
+            return [ToolCall(
                 tool_name="retrieve_context_text",
                 arguments={"query": message, "limit": 5},
-            ))
+            )]
+    
+    def _parse_intent_response(self, response: str, original_message: str) -> list[ToolCall]:
+        """Parse LLM intent detection response into ToolCall list."""
+        try:
+            # Extract JSON from response
+            json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', response, re.DOTALL)
+            if json_match:
+                response = json_match.group(1)
+            
+            # Find JSON object
+            json_start = response.find('{')
+            json_end = response.rfind('}')
+            if json_start != -1 and json_end != -1:
+                response = response[json_start:json_end + 1]
+            
+            data = json.loads(response)
+            
+            # Check if greeting
+            if data.get("is_greeting", False):
+                return []
+            
+            # Parse tools
+            tools = data.get("tools", [])
+            tool_calls = []
+            
+            for tool in tools:
+                name = tool.get("name")
+                arguments = tool.get("arguments", {})
+                
+                # Validate tool name
+                valid_tools = ["retrieve_context_text", "find_nearby_places", 
+                              "search_social_media", "retrieve_similar_visuals"]
+                if name not in valid_tools:
+                    continue
+                
+                # Ensure required arguments
+                if name == "retrieve_context_text":
+                    arguments.setdefault("query", original_message)
+                    arguments.setdefault("limit", 5)
+                elif name == "find_nearby_places":
+                    # Need to geocode location if provided
+                    location = arguments.get("location", "")
+                    arguments.setdefault("max_distance_km", 3.0)
+                    arguments.setdefault("limit", 5)
+                    # Will handle geocoding in execute step
+                elif name == "search_social_media":
+                    arguments.setdefault("query", original_message)
+                    arguments.setdefault("limit", 5)
+                    arguments.setdefault("freshness", "pw")
+                
+                tool_calls.append(ToolCall(tool_name=name, arguments=arguments))
+            
+            # If no tools selected, default to text search
+            if not tool_calls:
+                tool_calls.append(ToolCall(
+                    tool_name="retrieve_context_text",
+                    arguments={"query": original_message, "limit": 5},
+                ))
+            
+            return tool_calls
+            
+        except (json.JSONDecodeError, KeyError) as e:
+            agent_logger.error(f"Failed to parse intent JSON: {e}", None)
+            # Fallback to text search
+            return [ToolCall(
+                tool_name="retrieve_context_text",
+                arguments={"query": original_message, "limit": 5},
+            )]
 
-        return tool_calls
 
     async def _execute_tool(
         self,
@@ -405,9 +391,25 @@ class MMCAAgent:
                 ]
 
             elif tool_call.tool_name == "find_nearby_places":
+                # Handle geocoding if location name provided instead of lat/lng
+                lat = tool_call.arguments.get("lat")
+                lng = tool_call.arguments.get("lng")
+                
+                if lat is None or lng is None:
+                    # Try to geocode from location name
+                    location = tool_call.arguments.get("location", "")
+                    if location:
+                        coords = await self.tools.get_location_coordinates(location)
+                        if coords:
+                            lat, lng = coords
+                        else:
+                            lat, lng = DANANG_CENTER
+                    else:
+                        lat, lng = DANANG_CENTER
+                
                 results = await self.tools.find_nearby_places(
-                    lat=tool_call.arguments.get("lat", DANANG_CENTER[0]),
-                    lng=tool_call.arguments.get("lng", DANANG_CENTER[1]),
+                    lat=lat,
+                    lng=lng,
                     max_distance_km=tool_call.arguments.get("max_distance_km", 5.0),
                     category=tool_call.arguments.get("category"),
                     limit=tool_call.arguments.get("limit", 10),

app/itineraries/router.py

@@ -588,3 +588,157 @@ async def optimize_itinerary_route(
         "stop_count": len(stops),
         "note": "TSP optimization will be implemented in future update"
     }
+
+
+# ==================== SMART PLAN ENDPOINT ====================
+
+from app.planner.models import (
+    GetPlanRequest,
+    GetPlanResponse,
+    SmartPlanResponse,
+    DayPlanResponse,
+    PlaceDetailResponse,
+)
+from app.planner.smart_plan import smart_plan_service
+import time as time_module
+
+
+@router.post(
+    "/{itinerary_id}/get-plan",
+    response_model=GetPlanResponse,
+    summary="Generate Smart Plan from Itinerary",
+    description="""
+Generates an optimized, enriched plan from an itinerary with:
+- Social media research for each stop
+- Optimal timing (e.g., Dragon Bridge at 21h for fire show)
+- Tips and highlights per place
+- Multi-day organization
+""",
+)
+async def get_itinerary_smart_plan(
+    itinerary_id: str,
+    request: GetPlanRequest = GetPlanRequest(),
+    user_id: str = Query(..., description="User ID"),
+    db: AsyncSession = Depends(get_db),
+) -> GetPlanResponse:
+    """
+    Generate a smart, enriched travel plan from an itinerary.
+    
+    Uses Social Media Tool to research each place and LLM to optimize
+    timing based on Da Nang local knowledge.
+    """
+    start_time = time_module.time()
+    
+    # Validate UUIDs
+    validate_uuid(user_id, "user_id")
+    validate_uuid(itinerary_id, "itinerary_id")
+    
+    # Get itinerary with stops
+    result = await db.execute(
+        text("""
+            SELECT id, title, total_days, start_date
+            FROM itineraries
+            WHERE id = :id AND user_id = :user_id
+        """),
+        {"id": itinerary_id, "user_id": user_id}
+    )
+    row = result.fetchone()
+    
+    if not row:
+        raise HTTPException(status_code=404, detail="Itinerary not found")
+    
+    # Get all stops with snapshots
+    stops_result = await db.execute(
+        text("""
+            SELECT id, place_id, day_index, order_index, snapshot
+            FROM itinerary_stops
+            WHERE itinerary_id = :itinerary_id
+            ORDER BY day_index, order_index
+        """),
+        {"itinerary_id": itinerary_id}
+    )
+    stops = stops_result.fetchall()
+    
+    if len(stops) == 0:
+        raise HTTPException(status_code=400, detail="Itinerary has no stops. Add stops first.")
+    
+    # Convert stops to places format
+    places = []
+    for stop in stops:
+        snapshot = stop.snapshot or {}
+        places.append({
+            "place_id": stop.place_id,
+            "name": snapshot.get("name", f"Place {stop.place_id[:8]}"),
+            "category": snapshot.get("category", ""),
+            "lat": snapshot.get("lat", 0.0),
+            "lng": snapshot.get("lng", 0.0),
+            "rating": snapshot.get("rating"),
+        })
+    
+    # Generate smart plan
+    smart_plan = await smart_plan_service.generate_smart_plan(
+        places=places,
+        title=row.title,
+        itinerary_id=str(row.id),
+        total_days=row.total_days,
+        start_date=row.start_date,
+        include_social_research=request.include_social_research,
+        freshness=request.freshness,
+    )
+    
+    # Count social research results
+    research_count = sum(
+        len(p.social_mentions)
+        for day in smart_plan.days
+        for p in day.places
+    )
+    
+    generation_time = (time_module.time() - start_time) * 1000
+    
+    # Convert to Pydantic response
+    days_response = []
+    for day in smart_plan.days:
+        places_response = [
+            PlaceDetailResponse(
+                place_id=p.place_id,
+                name=p.name,
+                category=p.category,
+                lat=p.lat,
+                lng=p.lng,
+                recommended_time=p.recommended_time,
+                suggested_duration_min=p.suggested_duration_min,
+                tips=p.tips,
+                highlights=p.highlights,
+                social_mentions=p.social_mentions,
+                order=p.order,
+            )
+            for p in day.places
+        ]
+        days_response.append(
+            DayPlanResponse(
+                day_index=day.day_index,
+                date=str(day.date) if day.date else None,
+                places=places_response,
+                day_summary=day.day_summary,
+                day_distance_km=day.day_distance_km,
+            )
+        )
+    
+    plan_response = SmartPlanResponse(
+        itinerary_id=smart_plan.itinerary_id,
+        title=smart_plan.title,
+        total_days=smart_plan.total_days,
+        days=days_response,
+        summary=smart_plan.summary,
+        total_distance_km=smart_plan.total_distance_km,
+        estimated_total_duration_min=smart_plan.estimated_total_duration_min,
+        generated_at=smart_plan.generated_at,
+    )
+    
+    return GetPlanResponse(
+        plan=plan_response,
+        research_count=research_count,
+        generation_time_ms=round(generation_time, 2),
+        message=f"Smart plan generated for {row.total_days}-day itinerary with {research_count} social mentions",
+    )
+

app/mcp/tools/__init__.py

@@ -9,10 +9,7 @@ Tools:
 from app.mcp.tools.text_tool import (
     TextSearchResult,
     retrieve_context_text,
-    detect_category_intent,
     TOOL_DEFINITION as TEXT_TOOL_DEFINITION,
-    CATEGORY_KEYWORDS,
-    CATEGORY_TO_DB,
 )
 from app.mcp.tools.visual_tool import (
     ImageSearchResult,
@@ -111,7 +108,7 @@ mcp_tools = MCPTools()
 
 
 # Re-export for convenience
-__all__ = [
+_all_ = [
     "MCPTools",
     "mcp_tools",
     "TextSearchResult",

app/mcp/tools/social_tool.py

@@ -1,16 +1,8 @@
-
 import os
 import httpx
 from dataclasses import dataclass
 from typing import Optional, List, Dict, Any
 
-from dotenv import load_dotenv
-load_dotenv()  # Ensure .env is loaded before os.getenv()
-
-# Tool definition for agent - imported from centralized prompts
-from app.shared.prompts import SEARCH_SOCIAL_MEDIA_TOOL as TOOL_DEFINITION
-
-
 @dataclass
 class SocialSearchResult:
     title: str
@@ -18,6 +10,67 @@ class SocialSearchResult:
     description: str
     age: str = ""
     platform: str = "Web"
+
+# Da Nang & Vietnam Travel Keywords
+DANANG_KEYWORDS = {
+    'beaches': ['mỹ khê', 'my khe', 'non nuoc', 'bai bien'],
+    'attractions': ['bà nà', 'ba na', 'bana hills', 'cầu vàng', 'golden bridge', 
+                    'hội an', 'hoi an', 'marble mountains', 'ngũ hành sơn'],
+    'food': ['mì quảng', 'mi quang', 'bún chả cá', 'banh xeo', 'cao lầu'],
+    'activities': ['surfing', 'diving', 'lặn', 'du lịch'],
+}
+
+VIETNAM_HASHTAGS = {
+    'general': ['#vietnam', '#vietnamtravel', '#travelvietnam', '#explorevietnam'],
+    'danang': ['#danang', '#danangcity', '#danangtravel', '#traveldanang', '#danangtrip'],
+    'attractions': ['#banahills', '#hoian', '#halongbay', '#hanoi', '#saigon'],
+    'travel': ['#travel', '#wanderlust', '#traveltiktok', '#adventure', '#explore'],
+}
+
+TIKTOK_TRAVEL_HASHTAGS = [
+    '#traveltiktok', '#travelgram', '#instatravel', '#bucketlist',
+    '#vietnamtravel', '#southeastasia', '#travel', '#adventure'
+]
+
+def enhance_travel_query(
+    query: str, 
+    location: str = "danang",
+    platform: str = None,
+    enhance: bool = True
+) -> str:
+    """
+    Enhance query với travel-specific keywords và hashtags.
+    
+    Args:
+        query: Original search query
+        location: Primary location (danang, vietnam, hoian)
+        platform: Target platform (tiktok, instagram, etc.)
+        enhance: Enable/disable auto-enhancement
+    
+    Returns:
+        Enhanced query string
+    """
+    if not enhance:
+        return query
+    
+    enhanced = query
+    query_lower = query.lower()
+    
+    # Detect location context
+    is_danang = any(loc in query_lower for loc in ['đà nẵng', 'da nang', 'danang'])
+    is_vietnam = any(loc in query_lower for loc in ['vietnam', 'việt nam', 'viet nam'])
+    
+    # Add location if not present and location parameter provided
+    if location == "danang" and not (is_danang or is_vietnam):
+        enhanced = f"{enhanced} Da Nang"
+    
+    # Platform-specific enhancements
+    if platform and 'tiktok' in platform.lower():
+        # Only add #danang hashtag if it's Da Nang context and not already present
+        if (is_danang or location == "danang") and '#danang' not in query_lower:
+            enhanced = f"{enhanced} #danang"
+    
+    return enhanced
     
 class BraveSocialSearch:
     """
@@ -33,11 +86,35 @@ class BraveSocialSearch:
             # Fallback or warning? For now assume it will be provided or env
             pass
             
-    async def search(self, query: str, limit: int = 10, freshness: str = "pw", platforms: List[str] = None) -> List[SocialSearchResult]:
+    async def search(
+        self, 
+        query: str, 
+        limit: int = 10, 
+        freshness: str = None, 
+        platforms: List[str] = None,
+        enhance: bool = True,
+        location: str = "danang"
+    ) -> List[SocialSearchResult]:
         if not self.api_key:
             print("Warning: BRAVE_API_KEY not found.")
             return []
 
+        # Enhancement for travel content
+        primary_platform = platforms[0] if platforms else None
+        enhanced_query = enhance_travel_query(
+            query, 
+            location=location,
+            platform=primary_platform,
+            enhance=enhance
+        )
+        
+        # Platform-specific freshness defaults
+        if freshness is None:
+            if platforms and any('tiktok' in p.lower() for p in platforms):
+                freshness = "pm"  # Past month for TikTok (trending)
+            else:
+                freshness = "pw"  # Past week for others
+
         headers = {
             "Accept": "application/json",
             "Accept-Encoding": "gzip",
@@ -46,26 +123,35 @@ class BraveSocialSearch:
         
         # Default social sites if none provided
         if not platforms:
-            # Use general search with social/news filter - don't add complex site: operators
-            # as they can cause issues with Brave API for non-English queries
-            full_query = f"{query} review tin tức"  # Add context for social/news
+            social_sites = [
+                'site:twitter.com', 'site:x.com', 
+                'site:facebook.com', 
+                'site:reddit.com', 
+                'site:linkedin.com', 
+                'site:tiktok.com',
+                'site:instagram.com',
+                'site:threads.net'
+            ]
         else:
-            # Add platform names as context keywords instead of site: operators
-            platform_keywords = []
+            social_sites = []
             for p in platforms:
                 p = p.lower()
-                if "facebook" in p: platform_keywords.append("facebook")
-                elif "reddit" in p: platform_keywords.append("reddit")
-                elif "twitter" in p or "x" == p: platform_keywords.append("twitter")
-                elif "linkedin" in p: platform_keywords.append("linkedin")
-                elif "tiktok" in p: platform_keywords.append("tiktok")
-                elif "instagram" in p: platform_keywords.append("instagram")
-                elif "youtube" in p: platform_keywords.append("youtube")
-            
-            if platform_keywords:
-                full_query = f"{query} {' '.join(platform_keywords)}"
-            else:
-                full_query = query
+                if "facebook" in p: social_sites.append("site:facebook.com")
+                elif "reddit" in p: social_sites.append("site:reddit.com")
+                elif "twitter" in p or "x" == p: social_sites.extend(["site:twitter.com", "site:x.com"])
+                elif "linkedin" in p: social_sites.append("site:linkedin.com")
+                elif "tiktok" in p: social_sites.append("site:tiktok.com")
+                elif "instagram" in p: social_sites.append("site:instagram.com")
+                elif "site:" in p: social_sites.append(p) # Direct operator
+        
+        # Construct query with site OR operator
+        if len(social_sites) > 1:
+            sites_query = " OR ".join(social_sites)
+            full_query = f"{enhanced_query} ({sites_query})"
+        elif len(social_sites) == 1:
+            full_query = f"{enhanced_query} {social_sites[0]}"
+        else:
+            full_query = enhanced_query
             
         params = {
             "q": full_query,
@@ -97,11 +183,14 @@ class BraveSocialSearch:
                         if "profile" in item and "name" in item["profile"]:
                             platform = item["profile"]["name"]
                         else:
-                            # Simple heuristic
+                            # Enhanced platform detection
                             domain = item.get("url", "").split("//")[-1].split("/")[0]
                             if "reddit" in domain: platform = "Reddit"
                             elif "twitter" in domain or "x.com" in domain: platform = "X (Twitter)"
                             elif "facebook" in domain: platform = "Facebook"
+                            elif "tiktok" in domain: platform = "TikTok"
+                            elif "instagram" in domain: platform = "Instagram"
+                            elif "linkedin" in domain: platform = "LinkedIn"
                             
                         results.append(SocialSearchResult(
                             title=item.get("title", ""),
@@ -117,12 +206,60 @@ class BraveSocialSearch:
                 print(f"Error calling Brave Search API: {e}")
                 return []
 
+# Tool definition for agent
+TOOL_DEFINITION = {
+    "name": "search_social_media",
+    "description": """Tìm kiếm nội dung mạng xã hội về địa điểm, du lịch Đà Nẵng/Vietnam.
+
+ĐẶC BIỆT TỐI ƯU CHO TIKTOK - nền tảng #1 cho travel content!
+
+Dùng khi:
+- Tìm trending videos, viral content về Đà Nẵng
+- Xem review, tips, tricks từ du khách thực tế
+- Khám phá hidden gems, fun facts về địa điểm
+- Thu thập ý kiến cộng đồng về nhà hàng, khách sạn
+- Tìm kiếm trải nghiệm và hành trình du lịch
+
+Tính năng thông minh:
+- Tự động thêm hashtag #danang
+- Query enhancement cho travel content
+- Platform-specific optimization (TikTok, Instagram)
+- Adaptive freshness (trending vs. comprehensive)
+
+Nền tảng hỗ trợ: 
+- TikTok 🔥 (Ưu tiên cho travel content)
+- Instagram 📸
+- X (Twitter), Facebook, Reddit, LinkedIn, Threads
+
+Tips:
+- Để platforms=["tiktok"] cho trending visual content
+- Để platforms=None để tìm trên tất cả nền tảng
+- Set enhance=False nếu muốn query chính xác (không auto-thêm hashtags)""",
+    "parameters": {
+        "query": "Query tìm kiếm (VD: 'best beaches', 'quán ăn ngon')",
+        "limit": "Số kết quả (mặc định 10, tối đa 20)",
+        "freshness": "Độ mới: None (auto), 'pw' (week), 'pm' (month), 'py' (year)",
+        "platforms": "Platforms: ['tiktok'], ['instagram'], hoặc None (all)",
+        "enhance": "Auto-enhance query (default True)",
+        "location": "Location context: 'danang', 'hoian', 'vietnam' (default 'danang')",
+    },
+}
+
+
 # Singleton instance
 social_search_tool = BraveSocialSearch()
 
-async def search_social_media(query: str, limit: int = 10, freshness: str = "pw", platforms: List[str] = None) -> List[SocialSearchResult]:
+async def search_social_media(
+    query: str, 
+    limit: int = 10, 
+    freshness: str = None,
+    platforms: List[str] = None,
+    enhance: bool = True,
+    location: str = "danang"
+) -> List[SocialSearchResult]:
     """
-    Search for social media content (news, discussions) about a topic.
+    Search for social media content (news, discussions) with travel optimization.
     """
-    return await social_search_tool.search(query, limit, freshness, platforms)
-
+    return await social_search_tool.search(
+        query, limit, freshness, platforms, enhance, location
+    )

app/mcp/tools/text_tool.py

@@ -27,24 +27,11 @@ class TextSearchResult:
     source_text: str = ""
     content_type: str = ""
 
-# Category constants - imported from centralized prompts
-from app.shared.prompts import CATEGORY_KEYWORDS, CATEGORY_TO_DB
-
 
 # Tool definition for agent - imported from centralized prompts
 from app.shared.prompts import RETRIEVE_CONTEXT_TEXT_TOOL as TOOL_DEFINITION
 
 
-def detect_category_intent(query: str) -> Optional[str]:
-    """Detect if query is asking for specific category."""
-    query_lower = query.lower()
-
-    for category, keywords in CATEGORY_KEYWORDS.items():
-        if any(kw in query_lower for kw in keywords):
-            return category
-    return None
-
-
 async def retrieve_context_text(
     db: AsyncSession,
     query: str,
@@ -71,9 +58,6 @@ async def retrieve_context_text(
     # Convert to PostgreSQL vector format
     embedding_str = "[" + ",".join(str(x) for x in query_embedding) + "]"
 
-    # Detect category intent for boosting
-    category_intent = detect_category_intent(query)
-    category_filter = CATEGORY_TO_DB.get(category_intent, []) if category_intent else []
 
     # Search with JOIN to places_metadata
     # Note: Use format string for embedding since SQLAlchemy param binding 
@@ -102,16 +86,12 @@ async def retrieve_context_text(
 
     rows = results.fetchall()
 
-    # Process and score results with category boosting
+    # Process and score results with rating boost
     scored_results = []
     for r in rows:
         score = float(r.similarity)
         
-        # Category boost (15%)
-        if category_filter and r.category in category_filter:
-            score += 0.15
-        
-        # Rating boost (5% for >= 4.5)
+        # Rating boost (5% for >= 4.5, 2% for >= 4.0)
         if r.rating and r.rating >= 4.5:
             score += 0.05
         elif r.rating and r.rating >= 4.0:

app/planner/models.py

@@ -98,3 +98,63 @@ class PlanResponse(BaseModel):
     
     plan: Plan
     message: str
+
+
+# =============================================================================
+# SMART PLAN MODELS
+# =============================================================================
+
+class PlaceDetailResponse(BaseModel):
+    """Rich detail for a place in smart plan."""
+    
+    place_id: str = Field(..., description="Place ID")
+    name: str = Field(..., description="Place name")
+    category: str = Field(default="", description="Category")
+    lat: float = Field(default=0.0, description="Latitude")
+    lng: float = Field(default=0.0, description="Longitude")
+    recommended_time: str = Field(default="", description="Recommended visit time (HH:MM)")
+    suggested_duration_min: int = Field(default=60, description="Suggested duration in minutes")
+    tips: list[str] = Field(default_factory=list, description="Tips for this place")
+    highlights: str = Field(default="", description="Highlights from research")
+    social_mentions: list[str] = Field(default_factory=list, description="Social media mentions")
+    order: int = Field(default=0, description="Order in day")
+
+
+class DayPlanResponse(BaseModel):
+    """Single day plan."""
+    
+    day_index: int = Field(..., description="Day number (1-indexed)")
+    date: Optional[str] = Field(None, description="Date (YYYY-MM-DD)")
+    places: list[PlaceDetailResponse] = Field(default_factory=list)
+    day_summary: str = Field(default="", description="Day summary")
+    day_distance_km: float = Field(default=0.0, description="Total distance for the day")
+
+
+class SmartPlanResponse(BaseModel):
+    """Complete optimized plan with enriched details."""
+    
+    itinerary_id: str = Field(..., description="Reference ID")
+    title: str = Field(..., description="Plan title")
+    total_days: int = Field(..., description="Number of days")
+    days: list[DayPlanResponse] = Field(default_factory=list)
+    summary: str = Field(default="", description="Plan summary")
+    total_distance_km: float = Field(default=0.0, description="Total route distance")
+    estimated_total_duration_min: int = Field(default=0, description="Total estimated duration")
+    generated_at: datetime = Field(default_factory=datetime.now)
+
+
+class GetPlanRequest(BaseModel):
+    """Request for smart plan generation."""
+    
+    include_social_research: bool = Field(default=True, description="Include social media research")
+    freshness: str = Field(default="pw", description="Social search freshness: pw=past week, pm=past month")
+
+
+class GetPlanResponse(BaseModel):
+    """Response with smart plan."""
+    
+    plan: SmartPlanResponse
+    research_count: int = Field(default=0, description="Number of social results found")
+    generation_time_ms: float = Field(default=0, description="Plan generation time in ms")
+    message: str = Field(default="Smart plan generated successfully")
+

app/planner/router.py

@@ -1,5 +1,6 @@
 """Trip Planner Router - API endpoints for plan management."""
 
+import time
 from fastapi import APIRouter, HTTPException, Query
 
 from app.planner.models import (
@@ -12,8 +13,14 @@ from app.planner.models import (
     ReplaceRequest,
     OptimizeResponse,
     PlanResponse,
+    GetPlanRequest,
+    GetPlanResponse,
+    SmartPlanResponse,
+    DayPlanResponse,
+    PlaceDetailResponse,
 )
 from app.planner.service import planner_service
+from app.planner.smart_plan import smart_plan_service
 
 
 router = APIRouter(prefix="/planner", tags=["Trip Planner"])
@@ -251,3 +258,120 @@ async def delete_plan(
         raise HTTPException(status_code=404, detail="Plan not found")
     
     return {"status": "success", "message": f"Deleted plan {plan_id}"}
+
+
+# =============================================================================
+# SMART PLAN ENDPOINT
+# =============================================================================
+
+@router.post(
+    "/{plan_id}/get-plan",
+    response_model=GetPlanResponse,
+    summary="Generate Smart Plan",
+    description="""
+Generates an optimized, enriched plan with:
+- Social media research for each place
+- Optimal timing (e.g., Dragon Bridge at 21h for fire show)
+- Tips and highlights per place
+- Route optimization
+""",
+)
+async def get_smart_plan(
+    plan_id: str,
+    request: GetPlanRequest = GetPlanRequest(),
+    user_id: str = Query(default="anonymous", description="User ID"),
+) -> GetPlanResponse:
+    """
+    Generate a smart, enriched travel plan.
+    
+    Uses Social Media Tool to research each place and LLM to optimize
+    timing based on Da Nang local knowledge.
+    """
+    start_time = time.time()
+    
+    # Get the plan
+    plan = planner_service.get_plan(user_id, plan_id)
+    if not plan:
+        raise HTTPException(status_code=404, detail="Plan not found")
+    
+    if len(plan.items) == 0:
+        raise HTTPException(status_code=400, detail="Plan is empty. Add places first.")
+    
+    # Convert PlanItems to dict format for smart plan service
+    places = [
+        {
+            "place_id": item.place_id,
+            "name": item.name,
+            "category": item.category,
+            "lat": item.lat,
+            "lng": item.lng,
+            "rating": item.rating,
+        }
+        for item in plan.items
+    ]
+    
+    # Generate smart plan
+    smart_plan = await smart_plan_service.generate_smart_plan(
+        places=places,
+        title=plan.name,
+        itinerary_id=plan_id,
+        total_days=1,  # Planner is single-day by default
+        include_social_research=request.include_social_research,
+        freshness=request.freshness,
+    )
+    
+    # Count social research results
+    research_count = sum(
+        len(p.social_mentions)
+        for day in smart_plan.days
+        for p in day.places
+    )
+    
+    generation_time = (time.time() - start_time) * 1000
+    
+    # Convert to Pydantic response
+    days_response = []
+    for day in smart_plan.days:
+        places_response = [
+            PlaceDetailResponse(
+                place_id=p.place_id,
+                name=p.name,
+                category=p.category,
+                lat=p.lat,
+                lng=p.lng,
+                recommended_time=p.recommended_time,
+                suggested_duration_min=p.suggested_duration_min,
+                tips=p.tips,
+                highlights=p.highlights,
+                social_mentions=p.social_mentions,
+                order=p.order,
+            )
+            for p in day.places
+        ]
+        days_response.append(
+            DayPlanResponse(
+                day_index=day.day_index,
+                date=str(day.date) if day.date else None,
+                places=places_response,
+                day_summary=day.day_summary,
+                day_distance_km=day.day_distance_km,
+            )
+        )
+    
+    plan_response = SmartPlanResponse(
+        itinerary_id=smart_plan.itinerary_id,
+        title=smart_plan.title,
+        total_days=smart_plan.total_days,
+        days=days_response,
+        summary=smart_plan.summary,
+        total_distance_km=smart_plan.total_distance_km,
+        estimated_total_duration_min=smart_plan.estimated_total_duration_min,
+        generated_at=smart_plan.generated_at,
+    )
+    
+    return GetPlanResponse(
+        plan=plan_response,
+        research_count=research_count,
+        generation_time_ms=round(generation_time, 2),
+        message=f"Smart plan generated with {research_count} social mentions",
+    )

app/planner/smart_plan.py

@@ -0,0 +1,401 @@
+"""Smart Plan Service - Generate optimized, enriched travel plans.
+
+Uses Social Media Tool for research and LLM for intelligent scheduling.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import datetime, date, timedelta
+from dataclasses import dataclass, field
+
+from app.mcp.tools.social_tool import search_social_media, SocialSearchResult
+from app.shared.integrations.gemini_client import GeminiClient
+from app.shared.prompts import SMART_PLAN_SYSTEM_PROMPT, build_smart_plan_prompt
+from app.planner.tsp import optimize_route, haversine
+
+
+@dataclass
+class PlaceDetail:
+    """Rich detail for a place in smart plan."""
+    place_id: str
+    name: str
+    category: str = ""
+    lat: float = 0.0
+    lng: float = 0.0
+    recommended_time: str = ""           # "21:00"
+    suggested_duration_min: int = 60     # Default 1 hour
+    tips: list[str] = field(default_factory=list)
+    highlights: str = ""                  # Summary from research
+    social_mentions: list[str] = field(default_factory=list)
+    order: int = 0
+
+
+@dataclass
+class DayPlan:
+    """Single day plan."""
+    day_index: int
+    date: date | None = None
+    places: list[PlaceDetail] = field(default_factory=list)
+    day_summary: str = ""
+    day_distance_km: float = 0.0
+
+
+@dataclass 
+class SmartPlan:
+    """Complete optimized plan with enriched details."""
+    itinerary_id: str
+    title: str
+    total_days: int
+    days: list[DayPlan]
+    summary: str = ""
+    total_distance_km: float = 0.0
+    estimated_total_duration_min: int = 0
+    generated_at: datetime = field(default_factory=datetime.now)
+
+
+class SmartPlanService:
+    """Service for generating smart, enriched travel plans."""
+    
+    # Da Nang local knowledge - special timing for attractions
+    DANANG_TIMING_HINTS = {
+        "cầu rồng": {"time": "21:00", "tip": "Xem cầu rồng phun lửa/nước (T7, CN)"},
+        "dragon bridge": {"time": "21:00", "tip": "Fire/water show (Sat, Sun)"},
+        "cầu tình yêu": {"time": "19:00", "tip": "Đẹp nhất khi lên đèn"},
+        "bà nà hills": {"time": "08:00", "tip": "Đến sớm tránh đông, mát mẻ"},
+        "bãi biển mỹ khê": {"time": "05:30", "tip": "Ngắm bình minh tuyệt đẹp"},
+        "my khe beach": {"time": "05:30", "tip": "Beautiful sunrise"},
+        "chợ hàn": {"time": "07:00", "tip": "Sáng sớm đồ tươi, giá tốt"},
+        "chợ cồn": {"time": "06:00", "tip": "Chợ lớn nhất, đi sớm"},
+        "sơn trà": {"time": "05:00", "tip": "Săn mây, ngắm voọc"},
+        "ngũ hành sơn": {"time": "07:00", "tip": "Mát mẻ, ít đông"},
+        "hội an": {"time": "16:00", "tip": "Chiều tối đẹp nhất, thả đèn hoa đăng"},
+    }
+    
+    # Default category timings
+    CATEGORY_TIMING = {
+        "cafe": {"time": "09:00", "duration": 60},
+        "restaurant": {"time": "12:00", "duration": 90},
+        "beach": {"time": "06:00", "duration": 120},
+        "attraction": {"time": "09:00", "duration": 90},
+        "shopping": {"time": "10:00", "duration": 60},
+        "nightlife": {"time": "20:00", "duration": 120},
+    }
+    
+    def __init__(self, model: str = "gemini-3-flash-preview"):
+        """Initialize with Gemini model."""
+        self.llm = GeminiClient(model=model)
+    
+    async def research_places(
+        self, 
+        place_names: list[str],
+        freshness: str = "pw"
+    ) -> dict[str, list[SocialSearchResult]]:
+        """
+        Use Social Tool to gather info about each place.
+        
+        Args:
+            place_names: List of place names to research
+            freshness: Brave Search freshness param (pw=past week)
+            
+        Returns:
+            Dict mapping place_name to list of social results
+        """
+        research = {}
+        
+        # Parallel research for all places
+        async def research_one(name: str):
+            query = f"{name} Đà Nẵng review"
+            results = await search_social_media(
+                query=query,
+                limit=5,
+                freshness=freshness
+            )
+            return name, results
+        
+        tasks = [research_one(name) for name in place_names]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, tuple):
+                name, social_results = result
+                research[name] = social_results
+            else:
+                # Exception occurred, skip
+                pass
+                
+        return research
+    
+    def _get_timing_hint(self, place_name: str, category: str) -> tuple[str, str]:
+        """Get recommended time and tip for a place."""
+        name_lower = place_name.lower()
+        
+        # Check specific place hints first
+        for keyword, hints in self.DANANG_TIMING_HINTS.items():
+            if keyword in name_lower:
+                return hints["time"], hints["tip"]
+        
+        # Fall back to category timing
+        cat_lower = category.lower() if category else ""
+        for cat_key, timing in self.CATEGORY_TIMING.items():
+            if cat_key in cat_lower:
+                return timing["time"], ""
+        
+        # Default
+        return "10:00", ""
+    
+    def _format_social_mentions(self, results: list[SocialSearchResult]) -> list[str]:
+        """Format social results as readable mentions."""
+        mentions = []
+        for r in results[:3]:  # Top 3
+            platform = r.platform if r.platform != "Web" else ""
+            if platform:
+                mentions.append(f"[{platform}] {r.title[:80]}...")
+            else:
+                mentions.append(r.title[:80])
+        return mentions
+    
+    async def generate_smart_plan(
+        self,
+        places: list[dict],  # List of {place_id, name, category, lat, lng, ...}
+        title: str = "My Trip",
+        itinerary_id: str = "",
+        total_days: int = 1,
+        start_date: date | None = None,
+        include_social_research: bool = True,
+        freshness: str = "pw"
+    ) -> SmartPlan:
+        """
+        Generate optimized smart plan with enriched details.
+        
+        Args:
+            places: List of places with basic info
+            title: Plan title
+            itinerary_id: Reference ID
+            total_days: Number of days
+            start_date: Optional start date
+            include_social_research: Whether to search social media
+            freshness: Social search freshness
+            
+        Returns:
+            SmartPlan with optimized timing and enriched details
+        """
+        start_time = time.time()
+        
+        # Step 1: Research places (if enabled)
+        research = {}
+        if include_social_research:
+            place_names = [p.get("name", "") for p in places if p.get("name")]
+            research = await self.research_places(place_names, freshness)
+        
+        # Step 2: Get timing hints and build place details
+        place_details = []
+        for i, place in enumerate(places):
+            name = place.get("name", f"Place {i+1}")
+            category = place.get("category", "")
+            
+            rec_time, tip = self._get_timing_hint(name, category)
+            
+            # Get social mentions
+            social_results = research.get(name, [])
+            social_mentions = self._format_social_mentions(social_results)
+            
+            # Build highlights from social research
+            highlights = ""
+            if social_results:
+                descriptions = [r.description for r in social_results[:2] if r.description]
+                if descriptions:
+                    highlights = " ".join(descriptions)[:300]
+            
+            tips = [tip] if tip else []
+            
+            detail = PlaceDetail(
+                place_id=place.get("place_id", ""),
+                name=name,
+                category=category,
+                lat=place.get("lat", 0.0),
+                lng=place.get("lng", 0.0),
+                recommended_time=rec_time,
+                suggested_duration_min=self.CATEGORY_TIMING.get(category.lower(), {}).get("duration", 60),
+                tips=tips,
+                highlights=highlights,
+                social_mentions=social_mentions,
+                order=i + 1
+            )
+            place_details.append(detail)
+        
+        # Step 3: Use LLM to optimize and enhance
+        enhanced_plan = await self._llm_enhance_plan(
+            place_details=place_details,
+            total_days=total_days,
+            research=research
+        )
+        
+        # Step 4: Organize into days
+        days = self._organize_into_days(
+            place_details=enhanced_plan if enhanced_plan else place_details,
+            total_days=total_days,
+            start_date=start_date
+        )
+        
+        # Step 5: Calculate distances
+        total_distance = 0.0
+        for day in days:
+            day.day_distance_km = self._calculate_day_distance(day.places)
+            total_distance += day.day_distance_km
+        
+        # Step 6: Build summary
+        summary = await self._generate_summary(title, days, research)
+        
+        generation_time = (time.time() - start_time) * 1000
+        
+        return SmartPlan(
+            itinerary_id=itinerary_id,
+            title=title,
+            total_days=total_days,
+            days=days,
+            summary=summary,
+            total_distance_km=round(total_distance, 2),
+            estimated_total_duration_min=sum(p.suggested_duration_min for d in days for p in d.places),
+            generated_at=datetime.now()
+        )
+    
+    async def _llm_enhance_plan(
+        self,
+        place_details: list[PlaceDetail],
+        total_days: int,
+        research: dict
+    ) -> list[PlaceDetail] | None:
+        """Use LLM to enhance timing and tips."""
+        try:
+            # Build context for LLM
+            places_info = []
+            for p in place_details:
+                info = {
+                    "name": p.name,
+                    "category": p.category,
+                    "current_time": p.recommended_time,
+                    "social_info": p.highlights[:200] if p.highlights else ""
+                }
+                places_info.append(info)
+            
+            prompt = build_smart_plan_prompt(places_info, total_days)
+            
+            response = await self.llm.generate(
+                prompt=prompt,
+                system_instruction=SMART_PLAN_SYSTEM_PROMPT,
+                temperature=0.7
+            )
+            
+            # Parse LLM response and update place details
+            import json
+            import re
+            
+            # Extract JSON from response
+            json_match = re.search(r'\{[\s\S]*\}', response)
+            if json_match:
+                llm_result = json.loads(json_match.group())
+                
+                # Update place details with LLM suggestions
+                if "places" in llm_result:
+                    for llm_place in llm_result["places"]:
+                        for p in place_details:
+                            if p.name.lower() == llm_place.get("name", "").lower():
+                                if "time" in llm_place:
+                                    p.recommended_time = llm_place["time"]
+                                if "tips" in llm_place:
+                                    p.tips = llm_place["tips"]
+                                if "duration" in llm_place:
+                                    p.suggested_duration_min = llm_place["duration"]
+                                break
+            
+            return place_details
+            
+        except Exception as e:
+            print(f"LLM enhancement failed: {e}")
+            return None
+    
+    def _organize_into_days(
+        self,
+        place_details: list[PlaceDetail],
+        total_days: int,
+        start_date: date | None
+    ) -> list[DayPlan]:
+        """Organize places into days based on timing."""
+        if total_days <= 0:
+            total_days = 1
+            
+        # Sort by recommended time
+        sorted_places = sorted(place_details, key=lambda p: p.recommended_time)
+        
+        # Distribute across days
+        places_per_day = max(1, len(sorted_places) // total_days)
+        
+        days = []
+        for day_idx in range(total_days):
+            start_idx = day_idx * places_per_day
+            end_idx = start_idx + places_per_day if day_idx < total_days - 1 else len(sorted_places)
+            
+            day_places = sorted_places[start_idx:end_idx]
+            
+            # Sort day places by time
+            day_places = sorted(day_places, key=lambda p: p.recommended_time)
+            
+            # Update order within day
+            for i, p in enumerate(day_places):
+                p.order = i + 1
+            
+            day_date = None
+            if start_date:
+                day_date = start_date + timedelta(days=day_idx)
+            
+            day = DayPlan(
+                day_index=day_idx + 1,
+                date=day_date,
+                places=day_places,
+                day_summary=f"Ngày {day_idx + 1}: {len(day_places)} địa điểm"
+            )
+            days.append(day)
+        
+        return days
+    
+    def _calculate_day_distance(self, places: list[PlaceDetail]) -> float:
+        """Calculate total distance for a day's route."""
+        if len(places) < 2:
+            return 0.0
+            
+        total = 0.0
+        for i in range(len(places) - 1):
+            p1, p2 = places[i], places[i + 1]
+            if p1.lat and p1.lng and p2.lat and p2.lng:
+                total += haversine(p1.lat, p1.lng, p2.lat, p2.lng)
+        
+        return round(total, 2)
+    
+    async def _generate_summary(
+        self,
+        title: str,
+        days: list[DayPlan],
+        research: dict
+    ) -> str:
+        """Generate a brief summary of the plan."""
+        total_places = sum(len(d.places) for d in days)
+        
+        # Get highlights from research
+        highlights = []
+        for results in research.values():
+            for r in results[:1]:
+                if r.description:
+                    highlights.append(r.description[:100])
+        
+        summary = f"Lịch trình {title} với {total_places} địa điểm trong {len(days)} ngày."
+        
+        if highlights:
+            summary += f" Điểm nhấn: {'; '.join(highlights[:2])}"
+        
+        return summary
+
+
+# Global service instance
+smart_plan_service = SmartPlanService()

app/shared/prompts/__init__.py

@@ -5,6 +5,9 @@ from app.shared.prompts.prompts import (
     REACT_SYSTEM_PROMPT,
     GREETING_SYSTEM_PROMPT,
     SYNTHESIS_SYSTEM_PROMPT,
+    INTENT_SYSTEM_PROMPT,
+    INTENT_DETECTION_PROMPT,
+    SMART_PLAN_SYSTEM_PROMPT,
     TOOL_DEFINITIONS,
     TOOL_PURPOSES,
     # Tool-specific definitions
@@ -14,12 +17,12 @@ from app.shared.prompts.prompts import (
     SEARCH_SOCIAL_MEDIA_TOOL,
     # Database constants
     AVAILABLE_CATEGORIES,
-    CATEGORY_KEYWORDS,
-    CATEGORY_TO_DB,
     # Prompt builders
     build_greeting_prompt,
+    build_intent_prompt,
     build_synthesis_prompt,
     build_reasoning_prompt,
+    build_smart_plan_prompt,
 )
 
 __all__ = [
@@ -27,6 +30,9 @@ __all__ = [
     "REACT_SYSTEM_PROMPT",
     "GREETING_SYSTEM_PROMPT",
     "SYNTHESIS_SYSTEM_PROMPT",
+    "INTENT_SYSTEM_PROMPT",
+    "INTENT_DETECTION_PROMPT",
+    "SMART_PLAN_SYSTEM_PROMPT",
     "TOOL_DEFINITIONS",
     "TOOL_PURPOSES",
     "FIND_NEARBY_PLACES_TOOL",
@@ -34,9 +40,9 @@ __all__ = [
     "RETRIEVE_SIMILAR_VISUALS_TOOL",
     "SEARCH_SOCIAL_MEDIA_TOOL",
     "AVAILABLE_CATEGORIES",
-    "CATEGORY_KEYWORDS",
-    "CATEGORY_TO_DB",
     "build_greeting_prompt",
+    "build_intent_prompt",
     "build_synthesis_prompt",
     "build_reasoning_prompt",
+    "build_smart_plan_prompt",
 ]

app/shared/prompts/prompts.py

@@ -107,6 +107,7 @@ Với mỗi bước, bạn phải:
 ```
 
 **Quan trọng:**
+- Nếu là lời chào/small talk → action = "finish" với response thân thiện
 - Nếu cần biết vị trí → dùng get_location_coordinates trước
 - Nếu tìm theo khoảng cách → dùng find_nearby_places
 - Nếu tìm review/trend MXH → dùng search_social_media
@@ -121,10 +122,74 @@ GREETING_SYSTEM_PROMPT = "Bạn là LocalMate - trợ lý du lịch thân thiệ
 SYNTHESIS_SYSTEM_PROMPT = "Bạn là trợ lý du lịch thông minh cho Đà Nẵng. Trả lời format JSON."
 
 
+# Intent detection prompt for LLM-based tool selection
+INTENT_SYSTEM_PROMPT = "Bạn là AI phân tích intent. Trả lời CHÍNH XÁC format JSON, không giải thích thêm."
+
+INTENT_DETECTION_PROMPT = """Phân tích câu hỏi của user và chọn tool(s) phù hợp nhất.
+
+**Tools có sẵn:**
+1. `retrieve_context_text` - Tìm kiếm semantic trong văn bản (review, mô tả, đặc điểm)
+   - Dùng khi: hỏi về chất lượng, đặc điểm, menu, giá cả, không khí
+   - Ví dụ: "quán cafe view đẹp", "phở ngon giá rẻ", "nơi lãng mạn"
+
+2. `find_nearby_places` - Tìm địa điểm theo vị trí/khoảng cách
+   - Dùng khi: hỏi về vị trí, khoảng cách, "gần X", "quanh Y"
+   - Ví dụ: "quán gần Cầu Rồng", "cafe gần bãi biển"
+   - **Category mapping** (QUAN TRỌNG - dùng tiếng Anh):
+     - nhà hàng/quán ăn → "Restaurant"
+     - cafe/cà phê → "Coffee shop"  
+     - bar/pub → "Bar"
+     - hotel/khách sạn → "Hotel"
+     - phở → "Pho restaurant"
+     - hải sản → "Seafood restaurant"
+     - Nhật/sushi → "Japanese restaurant"
+     - Hàn/BBQ → "Korean restaurant"
+
+3. `search_social_media` - Tìm review/trend từ mạng xã hội
+   - Dùng khi: hỏi về review, tin hot, trend, viral, TikTok, Facebook
+   - Ví dụ: "review quán ăn trên TikTok", "tin hot tuần này"
+
+4. `retrieve_similar_visuals` - Tìm theo hình ảnh tương tự
+   - Dùng khi: user gửi ảnh, hoặc mô tả về decor/không gian
+   - Ví dụ: "quán có không gian giống ảnh này"
+
+**Trả lời theo format JSON:**
+```json
+{
+  "tools": [
+    {
+      "name": "tool_name",
+      "arguments": {"param": "value"},
+      "reason": "lý do ngắn gọn"
+    }
+  ],
+  "is_greeting": false
+}
+```
+
+**Quy tắc QUAN TRỌNG:**
+1. **Greeting/Small talk** (chào, cảm ơn, ok, được, tốt, bye):
+   → `{"tools": [], "is_greeting": true}`
+   
+2. **Câu hỏi vị trí** (gần, quanh, cách):
+   → `find_nearby_places` với location và category (DÙNG TIẾNG ANH cho category!)
+
+3. **Câu hỏi chất lượng/đặc điểm** (ngon, đẹp, rẻ, view):
+   → `retrieve_context_text`
+
+4. **Review/Trend MXH** (tiktok, facebook, viral):
+   → `search_social_media`
+
+5. Có thể chọn **NHIỀU tool** nếu query phức tạp
+"""
+
+
+
 # =============================================================================
 # PROMPT TEMPLATES
 # =============================================================================
 
+
 def build_greeting_prompt(message: str, history: str | None = None) -> str:
     """
     Build prompt for greeting/simple message response.
@@ -145,6 +210,29 @@ def build_greeting_prompt(message: str, history: str | None = None) -> str:
 Hãy trả lời thân thiện bằng tiếng Việt. Đây là lời chào hoặc tin nhắn đơn giản, không cần tìm kiếm địa điểm."""
 
 
+def build_intent_prompt(message: str, has_image: bool = False) -> str:
+    """
+    Build prompt for LLM-based intent detection.
+    
+    Args:
+        message: User's query
+        has_image: Whether user provided an image
+        
+    Returns:
+        Formatted prompt for intent detection
+    """
+    image_hint = ""
+    if has_image:
+        image_hint = "\n\n**Lưu ý:** User đã gửi kèm ảnh → nên dùng `retrieve_similar_visuals`"
+    
+    return f"""{INTENT_DETECTION_PROMPT}
+{image_hint}
+**Câu hỏi của user:** "{message}"
+
+Trả lời JSON:"""
+
+
+
 def build_synthesis_prompt(
     message: str,
     context: str,
@@ -186,11 +274,17 @@ Câu hỏi hiện tại: {message}
 
 {context}
 
-**QUAN TRỌNG:** Trả lời theo format JSON:
+**QUAN TRỌNG - ĐỌC KỸ:**
+1. KHÔNG viết code, KHÔNG gọi tool, KHÔNG output tool_code
+2. Chỉ trả lời bằng văn bản tiếng Việt thân thiện
+3. Giới thiệu 2-3 địa điểm phù hợp nhất từ kết quả trên
+4. Nếu không có kết quả phù hợp, thông báo và đề xuất thử cách khác
+
+**Trả lời theo format JSON:**
 ```json
 {{
-  "response": "Câu trả lời tiếng Việt, thân thiện. Giới thiệu top 2-3 địa điểm phù hợp nhất.",
-  "selected_place_ids": ["place_id_1", "place_id_2", "place_id_3"]
+  "response": "Câu trả lời tiếng Việt thân thiện, giới thiệu địa điểm cụ thể với tên, rating, mô tả ngắn.",
+  "selected_place_ids": ["place_id_1", "place_id_2"]
 }}
 ```
 
@@ -362,31 +456,75 @@ AVAILABLE_CATEGORIES = [
     "Vietnamese restaurant",
 ]
 
-# Category keywords for intent detection (user query -> category)
-CATEGORY_KEYWORDS = {
-    'cafe': ['cafe', 'cà phê', 'coffee', 'caphe', 'caphê'],
-    'pho': ['phở', 'pho'],
-    'banh_mi': ['bánh mì', 'banh mi', 'bread'],
-    'seafood': ['hải sản', 'hai san', 'seafood', 'cá', 'tôm', 'cua'],
-    'restaurant': ['nhà hàng', 'restaurant', 'quán ăn', 'ăn'],
-    'bar': ['bar', 'pub', 'cocktail', 'beer', 'bia'],
-    'hotel': ['hotel', 'khách sạn', 'resort', 'villa'],
-    'japanese': ['nhật', 'japan', 'sushi', 'ramen'],
-    'korean': ['hàn', 'korea', 'bbq'],
-}
 
-# Category keyword -> Database category name mapping
-CATEGORY_TO_DB = {
-    'cafe': ['Coffee shop', 'Cafe', 'Coffee house', 'Espresso bar'],
-    'pho': ['Pho restaurant', 'Bistro', 'Restaurant', 'Vietnamese restaurant'],
-    'banh_mi': ['Bakery', 'Tiffin center', 'Restaurant'],
-    'seafood': ['Seafood restaurant', 'Restaurant', 'Asian restaurant'],
-    'restaurant': ['Restaurant', 'Vietnamese restaurant', 'Asian restaurant'],
-    'bar': ['Bar', 'Cocktail bar', 'Pub', 'Night club', 'Live music bar'],
-    'hotel': ['Hotel', 'Resort', 'Apartment', 'Villa', 'Holiday apartment rental'],
-    'japanese': ['Japanese restaurant', 'Sushi restaurant', 'Ramen restaurant'],
-    'korean': ['Korean restaurant', 'Korean barbecue restaurant'],
-}
+# =============================================================================
+# SMART PLAN PROMPTS
+# =============================================================================
+
+SMART_PLAN_SYSTEM_PROMPT = """Bạn là chuyên gia lập lịch trình du lịch Đà Nẵng.
+
+**Kiến thức đặc biệt về Đà Nẵng:**
+- Cầu Rồng phun lửa/nước: 21h Thứ 7, Chủ Nhật
+- Bãi biển Mỹ Khê: 5-7h sáng (bình minh đẹp) hoặc 16-18h (hoàng hôn)
+- Chợ Hàn: Sáng sớm 6-9h (đồ tươi, giá tốt) hoặc chiều tối 16-20h
+- Bà Nà Hills: Đến sớm 8h để tránh đông, mát mẻ hơn
+- Sơn Trà: Sáng sớm 5-6h để săn mây, ngắm voọc
+- Ngũ Hành Sơn: Sớm 7-8h, mát và ít đông
+- Hội An: Chiều tối 16-20h đẹp nhất, thả đèn hoa đăng tối
+
+**Nhiệm vụ:**
+1. Sắp xếp thời gian tối ưu cho từng địa điểm
+2. Thêm tips hữu ích dựa trên kiến thức địa phương
+3. Ước tính thời gian hợp lý tại mỗi nơi
+
+Trả lời format JSON."""
+
+
+def build_smart_plan_prompt(places: list[dict], total_days: int = 1) -> str:
+    """
+    Build prompt for LLM to optimize smart plan timing.
+    
+    Args:
+        places: List of place info dicts with name, category, social_info
+        total_days: Number of days for the trip
+        
+    Returns:
+        Formatted prompt string
+    """
+    places_text = ""
+    for i, p in enumerate(places, 1):
+        places_text += f"{i}. {p.get('name', 'Unknown')}"
+        if p.get('category'):
+            places_text += f" [{p['category']}]"
+        if p.get('social_info'):
+            places_text += f"\n   Social: {p['social_info'][:150]}"
+        places_text += "\n"
+    
+    return f"""Hãy tối ưu lịch trình {total_days} ngày với các địa điểm sau:
+
+{places_text}
+
+**Yêu cầu:**
+1. Gợi ý thời gian đến (time) tối ưu cho mỗi địa điểm
+2. Thêm tips hữu ích (dựa trên kiến thức địa phương Đà Nẵng)
+3. Ước tính thời gian ở (duration) tính bằng phút
+
+**Trả lời JSON:**
+```json
+{{
+  "places": [
+    {{
+      "name": "Tên địa điểm",
+      "time": "HH:MM",
+      "duration": 60,
+      "tips": ["Tip 1", "Tip 2"]
+    }}
+  ],
+  "day_summaries": [
+    "Ngày 1: Khám phá bãi biển và ẩm thực"
+  ]
+}}
+```"""
 
 
 # =============================================================================
@@ -409,10 +547,15 @@ __all__ = [
     "SEARCH_SOCIAL_MEDIA_TOOL",
     # Database constants
     "AVAILABLE_CATEGORIES",
-    "CATEGORY_KEYWORDS",
-    "CATEGORY_TO_DB",
+    # Intent detection
+    "INTENT_SYSTEM_PROMPT",
+    "INTENT_DETECTION_PROMPT",
+    "build_intent_prompt",
     # Prompt builders
     "build_greeting_prompt",
     "build_synthesis_prompt",
     "build_reasoning_prompt",
+    # Smart Plan
+    "SMART_PLAN_SYSTEM_PROMPT",
+    "build_smart_plan_prompt",
 ]

docs/API_REFERENCE.md

@@ -541,6 +541,99 @@ Delete a plan.
 
 ---
 
+### POST `/planner/{plan_id}/get-plan`
+
+Generate an optimized Smart Plan with social media research and optimal timing.
+
+**Query:** `?user_id=user_123`
+
+**Request:**
+```json
+{
+  "include_social_research": true,
+  "freshness": "pw"
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `include_social_research` | boolean | Enable Brave Search for reviews (default: true) |
+| `freshness` | string | "pw" = past week, "pm" = past month |
+
+**Response:**
+```json
+{
+  "plan": {
+    "itinerary_id": "plan_abc123",
+    "title": "Da Nang Test Trip",
+    "total_days": 1,
+    "days": [
+      {
+        "day_index": 1,
+        "date": null,
+        "places": [
+          {
+            "place_id": "my_khe_1",
+            "name": "Bãi biển Mỹ Khê",
+            "category": "beach",
+            "lat": 16.0544,
+            "lng": 108.245,
+            "recommended_time": "05:30",
+            "suggested_duration_min": 90,
+            "tips": [
+              "Đón bình minh đẹp nhất vào khoảng 5h30 - 6h00 sáng.",
+              "Xem ngư dân kéo lưới và mua hải sản tươi sống."
+            ],
+            "highlights": "Summary from social research...",
+            "social_mentions": ["[TikTok] Review Mỹ Khê..."],
+            "order": 1
+          },
+          {
+            "place_id": "cau_rong_1",
+            "name": "Cầu Rồng",
+            "category": "attraction",
+            "recommended_time": "20:30",
+            "suggested_duration_min": 60,
+            "tips": [
+              "Nếu đi vào Thứ 7 hoặc Chủ Nhật, Rồng sẽ phun lửa và nước vào lúc 21:00.",
+              "Đứng ở phía đầu Rồng để xem rõ nhất."
+            ],
+            "order": 2
+          }
+        ],
+        "day_summary": "Ngày 1: 2 địa điểm",
+        "day_distance_km": 3.57
+      }
+    ],
+    "summary": "Lịch trình với 2 địa điểm trong 1 ngày.",
+    "total_distance_km": 3.57,
+    "estimated_total_duration_min": 150,
+    "generated_at": "2025-12-20T06:20:59"
+  },
+  "research_count": 5,
+  "generation_time_ms": 9486.47,
+  "message": "Smart plan generated with 5 social mentions"
+}
+```
+
+> **Features:**
+> - **Optimal Timing**: Da Nang local knowledge (Dragon Bridge 21h, Mỹ Khê sunrise)
+> - **Social Research**: Pulls reviews from TikTok, Facebook, Reddit via Brave API
+> - **LLM Enhancement**: Uses Gemini 3 Flash for tips and scheduling
+> - **Distance Calculation**: Haversine formula for route distances
+
+---
+
+### POST `/itineraries/{itinerary_id}/get-plan`
+
+Same as above, but for multi-day itineraries (persistent storage).
+
+**Query:** `?user_id=uuid-here`
+
+**Request/Response:** Same format as planner get-plan
+
+---
+
 ## Utility Endpoints
 
 ### GET `/health`
@@ -604,6 +697,42 @@ interface WorkflowStep {
 }
 ```
 
+### SmartPlan (Get Plan Response)
+```typescript
+interface SmartPlan {
+  itinerary_id: string;
+  title: string;
+  total_days: number;
+  days: DayPlan[];
+  summary: string;
+  total_distance_km: number;
+  estimated_total_duration_min: number;
+  generated_at: string;
+}
+
+interface DayPlan {
+  day_index: number;
+  date?: string;
+  places: PlaceDetail[];
+  day_summary: string;
+  day_distance_km: number;
+}
+
+interface PlaceDetail {
+  place_id: string;
+  name: string;
+  category: string;
+  lat: number;
+  lng: number;
+  recommended_time: string;     // "05:30", "21:00"
+  suggested_duration_min: number;
+  tips: string[];               // ["Xem cầu rồng phun lửa..."]
+  highlights: string;           // Summary from social research
+  social_mentions: string[];    // ["[TikTok] Review..."]
+  order: number;
+}
+```
+
 ---
 
 ## Usage Examples

tests/react_comparison_report.md

@@ -1,8 +1,8 @@
 # LocalMate Agent Comprehensive Test Report
 
-**Generated:** 2025-12-19 21:59:06  
-**Provider:** MegaLLM  
-**Model:** deepseek-ai/deepseek-v3.1-terminus
+**Generated:** 2025-12-20 06:39:19  
+**Provider:** Google  
+**Model:** gemini-2.5-flash
 
 ---
 
@@ -11,8 +11,8 @@
 | Metric | Single Mode | ReAct Mode |
 |--------|:-----------:|:----------:|
 | Success Rate | 5/5 | 5/5 |
-| Avg Duration | 13255ms | 24551ms |
-| Unique Tools | 3 | 4 |
+| Avg Duration | 11740ms | 3264ms |
+| Unique Tools | 3 | 3 |
 
 ### Tools Covered
 
@@ -20,7 +20,7 @@
 |------|:-----------:|:----------:|
 | `retrieve_context_text` | ✅ | ✅ |
 | `find_nearby_places` | ✅ | ✅ |
-| `search_social_media` | ✅ | ✅ |
+| `search_social_media` | ✅ | ❌ |
 | No tools (greeting) | ✅ | ✅ |
 
 ---
@@ -30,10 +30,10 @@
 | ID | Description | Single Tools | ReAct Tools | Match |
 |----|-------------|--------------|-------------|-------|
 | 1 | Greeting - No tools expected | ∅ (none) | ∅ (none) | ✅ Match/✅ Match |
-| 2 | Text search - Semantic search  | retrieve_context_text | retrieve_context_text, get_location_coordinates, find_nearby_places | ✅ Match/⚠️ Extra tools |
+| 2 | Text search - Semantic search  | retrieve_context_text | retrieve_context_text | ✅ Match/✅ Match |
 | 3 | Location search - Neo4j spatia | find_nearby_places | get_location_coordinates, find_nearby_places | ✅ Match/⚠️ Extra tools |
 | 4 | Social search - Brave API news | search_social_media | ∅ (none) | ✅ Match/❌ Mismatch |
-| 5 | Complex query - Multiple tools | search_social_media, find_nearby_places | get_location_coordinates, find_nearby_places, retrieve_context_text, search_social_media | ⚠️ Partial/⚠️ Extra tools |
+| 5 | Complex query - Multiple tools | find_nearby_places, retrieve_context_text | ∅ (none) | ✅ Match/❌ Mismatch |
 
 ---
 
@@ -46,12 +46,12 @@
 
 | Mode | Status | Duration | Tools Used | Places |
 |------|--------|----------|------------|--------|
-| Single | ✅ | 3818ms | None | 0 |
-| ReAct | ✅ | 3504ms | None | 0 |
+| Single | ✅ | 2855ms | None | 0 |
+| ReAct | ✅ | 1598ms | None | 0 |
 
-**Single Response:** Xin chào! ❤️ Rất vui được gặp bạn! Mình là LocalMate - trợ lý du lịch Đà Nẵng của bạn. Cần mình giúp gì về ăn uống, vui chơi, hay địa điểm check-in nà...
+**Single Response:** Chào bạn! Mình là LocalMate, rất vui được hỗ trợ bạn khám phá Đà Nẵng. 😊...
 
-**ReAct Response:** Xin chào bạn! 😊 Mình là trợ lý du lịch thông minh cho Đà Nẵng. Mình có thể giúp bạn tìm kiếm nhà hàng ngon, quán cafe đẹp, điểm vui chơi và nhiều địa ...
+**ReAct Response:** Chào bạn! Mình là trợ lý du lịch thông minh của Đà Nẵng, rất vui được hỗ trợ bạn. Bạn đang muốn tìm kiếm thông tin gì về Đà Nẵng ạ? Hãy cho mình biết ...
 
 ---
 
@@ -62,18 +62,16 @@
 
 | Mode | Status | Duration | Tools Used | Places |
 |------|--------|----------|------------|--------|
-| Single | ✅ | 24590ms | retrieve_context_text | 3 |
-| ReAct | ✅ | 31407ms | retrieve_context_text, get_location_coordinates, find_nearby_places | 3 |
+| Single | ✅ | 14155ms | retrieve_context_text | 3 |
+| ReAct | ✅ | 5694ms | retrieve_context_text | 2 |
 
-**Single Response:** Chào bạn! 😊 Mình tìm được một số quán cafe view đẹp ở Đà Nẵng cho bạn đây:
+**Single Response:** Chào bạn! Với yêu cầu tìm quán cà phê view đẹp ở Đà Nẵng, mình có một vài gợi ý tuyệt vời dành cho bạn đây:
 
-🌟 **Nhớ Một Người** - Rating 4.9
-- View đẹp với không gian lãng mạn, view ...
+1.  **Nhớ Một Người**: Quán này có rating...
 
-**ReAct Response:** Chào bạn! 😊 Mình tìm được những quán cafe có view đẹp ở Đà Nẵng cho bạn đây:
+**ReAct Response:** Chào bạn! Mình đã tìm thấy một vài quán cà phê có thể có "view đẹp" ở Đà Nẵng để bạn tham khảo đây: 
 
-🌟 **NAM house Cafe** - Rating 4.7
-- Quán cafe với không gian retro ấm cú...
+1.  **FIRGUN CORNER COFFEE**: Với rating 4.5/5, ...
 
 ---
 
@@ -84,17 +82,16 @@
 
 | Mode | Status | Duration | Tools Used | Places |
 |------|--------|----------|------------|--------|
-| Single | ✅ | 12070ms | find_nearby_places | 3 |
-| ReAct | ✅ | 23010ms | get_location_coordinates, find_nearby_places | 3 |
+| Single | ✅ | 19588ms | find_nearby_places | 3 |
+| ReAct | ✅ | 7989ms | get_location_coordinates, find_nearby_places | 3 |
 
-**Single Response:** Chào bạn! 😊 Dựa trên tìm kiếm của bạn về các nhà hàng gần Cầu Rồng, mình gợi ý cho bạn những địa điểm này:
+**Single Response:** Chào bạn! Mình đã tìm thấy một vài nhà hàng ngon gần Cầu Rồng cho bạn đây:
 
-🍕 **Pizza 4P's Hoang Van Thu** - Rating 4....
+1.  **Cơm Gà Lan**: Nổi tiếng với các món cơm gà, quán này có rating khá c...
 
-**ReAct Response:** Chào bạn! ��� Dưới đây là những nhà hàng ngon gần Cầu Rồng mà mình tìm được cho bạn:
+**ReAct Response:** Chào bạn! Gần Cầu Rồng có khá nhiều nhà hàng ngon để bạn lựa chọn đây:
 
-🌟 **Pizza 4P's Hoang Van Thu** - Rating 4.8
-- Nhà hàng pizza với đ...
+1.  **Pizza 4P's Hoang Van Thu**: Quán pizza nổi tiếng này chỉ cách Cầu Rồng k...
 
 ---
 
@@ -105,15 +102,12 @@
 
 | Mode | Status | Duration | Tools Used | Places |
 |------|--------|----------|------------|--------|
-| Single | ✅ | 15918ms | search_social_media | 0 |
-| ReAct | ✅ | 15744ms | None | 0 |
+| Single | ✅ | 7301ms | search_social_media | 0 |
+| ReAct | ✅ | 507ms | None | 0 |
 
-**Single Response:** Chào bạn! 😊 Mình tìm được một số quán ăn đang hot trên TikTok Đà Nẵng cho bạn đây:
+**Single Response:** Chào bạn! Hiện tại mình chưa có thông tin cụ thể về các quán ăn đang hot trên TikTok ở Đà Nẵng ngay lúc này. Bạn có muốn mình thử tìm kiếm các quán ăn...
 
-🌟 **Cà Mèn Quán Đà Nẵng** - Trend TikTok
-- Đang được cộng đồng Tik...
-
-**ReAct Response:** Xin lỗi, đã xảy ra lỗi: Unknown error...
+**ReAct Response:** Xin lỗi, đã xảy ra lỗi: 429 RESOURCE_EXHAUSTED. {'error': {'code': 429, 'message': 'You exceeded your current quota, please check your plan and billin...
 
 ---
 
@@ -124,15 +118,14 @@
 
 | Mode | Status | Duration | Tools Used | Places |
 |------|--------|----------|------------|--------|
-| Single | ✅ | 9881ms | search_social_media, find_nearby_places | 2 |
-| ReAct | ✅ | 49088ms | get_location_coordinates, find_nearby_places, retrieve_context_text, search_social_media | 0 |
+| Single | ✅ | 14802ms | find_nearby_places, retrieve_context_text | 3 |
+| ReAct | ✅ | 531ms | None | 0 |
 
-**Single Response:** Chào bạn! 😊 Mình tìm được những quán cafe không gian đẹp gần biển Mỹ Khê có review tốt cho bạn đây:
+**Single Response:** Chào bạn! Mình đã tìm thấy một vài quán cà phê có không gian đẹp và được đánh giá tốt, lại còn gần biển Mỹ Khê nữa đây:
 
-🌟 **Sound Cafe** - Rating 4.7
-- Quán cafe acousti...
+1.  **VUN**: Quán này chỉ các...
 
-**ReAct Response:** Xin lỗi, đã xảy ra lỗi: Unknown error...
+**ReAct Response:** Xin lỗi, đã xảy ra lỗi: 429 RESOURCE_EXHAUSTED. {'error': {'code': 429, 'message': 'You exceeded your current quota, please check your plan and billin...
 
 ---
 
@@ -141,7 +134,7 @@
 | Criteria | Single Mode | ReAct Mode |
 |----------|:-----------:|:----------:|
 | All tests passed | ✅ | ✅ |
-| All 3 search tools covered | ✅ | ✅ |
+| All 3 search tools covered | ✅ | ❌ |
 | Greeting detection works | ✅ | ✅ |
 
 **Overall:** 🎉 ALL TESTS PASSED!

tests/test_react_comparison.py

@@ -22,18 +22,22 @@ import httpx
 # =============================================================================
 
 # API Settings - Use localhost for local testing
+# API_BASE = "https://cuong2004-localmate.hf.space/api/v1"
 API_BASE = "http://localhost:8000/api/v1"
 USER_ID = "test_comprehensive"
 
 # Delay Settings (in seconds)
-SINGLE_MODE_DELAY = 5        # Delay between queries in single mode
-REACT_MODE_DELAY = 20        # Delay between queries in ReAct mode
-MODE_SWITCH_DELAY = 5        # Delay between switching modes
+SINGLE_MODE_DELAY = 20        # Delay between queries in single mode
+REACT_MODE_DELAY = 60        # Delay between queries in ReAct mode
+MODE_SWITCH_DELAY = 60        # Delay between switching modes
 REQUEST_TIMEOUT = 60        # Timeout for each API request
 
 # Provider settings
-PROVIDER = "MegaLLM"
-MODEL = "deepseek-ai/deepseek-v3.1-terminus"
+# PROVIDER = "MegaLLM"
+# MODEL = "deepseek-ai/deepseek-v3.1-terminus"
+PROVIDER = "Google"
+# MODEL = "gemini-3-flash-preview"
+MODEL = "gemini-2.5-flash"
 
 # =============================================================================
 # 5 TEST CASES - Covering ALL tools