fix: resolve remaining HIGH/MEDIUM issues from code review

Chatbot ML Service:
- Replace all print() calls with logger.info/warning in load_models() startup path
- Remove LLM provider name and model ID from unauthenticated /health endpoint;
replace with generic llm_ready boolean to prevent vendor enumeration
- Reuse shared httpx.AsyncClient across weather requests (lazy-init property +
close() called in lifespan shutdown); eliminates per-request TCP handshake
- Cap ChromaDB query input at 256 chars before embedding for retrieval quality
- Add optional language param to IntentClassifier.predict() to skip redundant
language detection when caller has already detected it; update both call sites
in routes.py predict and stream handlers
- Remove 'anh' from NER false-positive blocklist so England/London alias resolves
correctly; add comment explaining deliberate omission
- Replace hardcoded timestamped TripAdvisor dataset filename with glob-based
auto-discovery of latest matching file in scraped_data/TripAdvisor/

Frontend:
- PaginationUI: replace href="#" with href="javascript:void(0)" and remove
e.preventDefault() calls to prevent scroll-to-top on page navigation
- HotelListPage: add destination?.id to hotel-fetch useEffect dependency array
so re-fetch triggers when destination ID changes with same name
- ActivityDetailPage: replace hardcoded "Vietnam" fallback with t('common.vietnam')

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/api/routes.py

@@ -155,7 +155,7 @@ async def predict(request: PredictRequest):
 
     # 2. Intent classification
     try:
-        intent_result = await asyncio.to_thread(intent_clf.predict, text)
+        intent_result = await asyncio.to_thread(intent_clf.predict, text, language)
     except Exception as e:
         logger.error(f"Intent classification failed: {e}")
         intent_result = {'intent': 'fallback', 'confidence': 0.0, 'method': 'error_fallback'}
@@ -1273,7 +1273,7 @@ async def predict_stream(request: PredictRequest):
 
             # Intent classification
             try:
-                intent_result = await asyncio.to_thread(intent_clf.predict, text)
+                intent_result = await asyncio.to_thread(intent_clf.predict, text, language)
             except Exception:
                 intent_result = {'intent': 'fallback', 'confidence': 0.0, 'method': 'error_fallback'}
             intent = intent_result['intent']

app/config/settings.py

@@ -1,9 +1,19 @@
+import glob as _glob
 import os
 from dotenv import load_dotenv
 
 load_dotenv()
 
 
+def _find_latest_tripadvisor_dataset(base_dir: str) -> str:
+    pattern = os.path.join(base_dir, "scraped_data", "TripAdvisor", "dataset_tripadvisor_*.json")
+    matches = _glob.glob(pattern)
+    if matches:
+        return max(matches, key=os.path.getmtime)
+    # fallback to a stable name if no timestamped file found
+    return os.path.join(base_dir, "scraped_data", "TripAdvisor", "dataset_tripadvisor.json")
+
+
 def _env_bool(name: str, default: bool) -> bool:
     return os.getenv(name, str(default)).lower() == "true"
 
@@ -61,10 +71,7 @@ class Settings:
     VECTOR_STORE_PATH: str = os.path.join(MODEL_DIR, "vector_store")
     KB_PATH: str = os.path.join(DATA_DIR, "knowledge_base", "destinations.json")
     EVENTS_PATH: str = os.path.join(DATA_DIR, "knowledge_base", "events_calendar.json")
-    TA_DATASET_PATH: str = os.getenv(
-        "TA_DATASET_PATH",
-        os.path.join(BASE_DIR, "scraped_data", "TripAdvisor", "dataset_tripadvisor_2026-04-19_05-48-05-642.json"),
-    )
+    TA_DATASET_PATH: str = os.getenv("TA_DATASET_PATH", _find_latest_tripadvisor_dataset(BASE_DIR))
 
     # Vector store
     EMBEDDING_MODEL: str = os.getenv(

app/main.py

@@ -32,7 +32,9 @@ async def lifespan(app):
     """Application lifespan: load models on startup, cleanup on shutdown."""
     await load_models()
     yield
-    # Cleanup on shutdown (if needed)
+    # Cleanup on shutdown
+    if realtime_service is not None:
+        await realtime_service.close()
     logger.info("Shutting down Wanderlust AI Chatbot Service")
 
 
@@ -219,16 +221,16 @@ async def load_models():
     # User profiler
     user_profiler = UserProfiler()
 
-    print("Core models loaded successfully!")
-    print("Enhanced modules loaded: BudgetOptimizer, CuisineRecommender, UserProfiler, RouteOptimizer")
+    logger.info("Core models loaded successfully!")
+    logger.info("Enhanced modules loaded: BudgetOptimizer, CuisineRecommender, UserProfiler, RouteOptimizer")
 
     # Load TripAdvisor enrichment index (always — lightweight, no GPU needed)
     ta_enricher = TripAdvisorEnricher(dataset_path=settings.TA_DATASET_PATH)
     ta_enricher.load()
     if ta_enricher.is_ready:
-        print(f"TripAdvisor enricher loaded: {settings.TA_DATASET_PATH}")
+        logger.info(f"TripAdvisor enricher loaded: {settings.TA_DATASET_PATH}")
     else:
-        print("TripAdvisor enricher: dataset not found, enrichment disabled")
+        logger.warning("TripAdvisor enricher: dataset not found, enrichment disabled")
 
     # Load LLM-related services if enabled
     if settings.USE_LLM_GENERATOR:
@@ -238,7 +240,7 @@ async def load_models():
             from app.models.llm.context_builder import ContextBuilder
             from app.models.llm.openai_generator import OpenAICompatibleGenerator
 
-            print("Initializing vector store...")
+            logger.info("Initializing vector store...")
             vector_store = VectorStore(
                 kb_path=kb_path,
                 persist_dir=settings.VECTOR_STORE_PATH,
@@ -246,7 +248,7 @@ async def load_models():
             )
             vector_store.initialize()
 
-            print("Initializing real-time data service...")
+            logger.info("Initializing real-time data service...")
             realtime_service = RealtimeDataService(
                 weather_api_url=settings.WEATHER_API_URL,
                 cache_ttl=settings.WEATHER_CACHE_TTL,
@@ -264,14 +266,14 @@ async def load_models():
             cloud_gen = OpenAICompatibleGenerator(context_builder=context_builder)
             if cloud_gen.is_ready():
                 llm_generator = cloud_gen
-                print(f"Cloud LLM ready: {cloud_gen._provider['name']} / {cloud_gen._model}")
+                logger.info("Cloud LLM ready")
             else:
                 # Fallback: local HuggingFace model (needs GPU)
                 _use_local = os.getenv("USE_LOCAL_LLM", "false").lower() == "true"
                 if _use_local:
                     from app.models.llm.model_loader import LLMModelLoader
                     from app.models.llm.inference import LLMGenerator
-                    print(f"Loading local LLM: {settings.BASE_MODEL_NAME} ({settings.LLM_QUANTIZATION})...")
+                    logger.info(f"Loading local LLM: {settings.BASE_MODEL_NAME} ({settings.LLM_QUANTIZATION})...")
                     model_loader = LLMModelLoader(
                         base_model_name=settings.BASE_MODEL_NAME,
                         adapter_path=settings.LLM_ADAPTER_PATH,
@@ -282,9 +284,9 @@ async def load_models():
                         model_loader=model_loader,
                         context_builder=context_builder,
                     )
-                    print("Local LLM loaded as fallback.")
+                    logger.info("Local LLM loaded as fallback.")
                 else:
-                    print("No cloud API key and USE_LOCAL_LLM=false — LLM disabled, using templates.")
+                    logger.info("No cloud API key and USE_LOCAL_LLM=false — LLM disabled, using templates.")
 
         except ImportError as e:
             logger.warning(f"LLM dependencies not installed, falling back to templates: {e}")
@@ -324,13 +326,13 @@ async def load_models():
                 cloud_gen = OpenAICompatibleGenerator(context_builder=context_builder)
                 if cloud_gen.is_ready():
                     llm_generator = cloud_gen
-                    print(f"Cloud LLM auto-enabled via API key: {cloud_gen._provider['name']} / {cloud_gen._model}")
+                    logger.info("Cloud LLM auto-enabled via API key")
             except Exception as e:
                 logger.warning(f"Cloud LLM auto-init failed: {e}")
         else:
-            print("LLM mode disabled (USE_LLM_GENERATOR=false, no API key). Using template-based responses.")
+            logger.info("LLM mode disabled (USE_LLM_GENERATOR=false, no API key). Using template-based responses.")
 
-    print("All models loaded successfully!")
+    logger.info("All models loaded successfully!")
     global _models_loaded_at
     _models_loaded_at = time.time()
 
@@ -358,8 +360,7 @@ async def health_check():
         "llm": {
             "enabled": settings.USE_LLM_GENERATOR or (llm_generator is not None),
             "ready": llm_generator is not None and llm_generator.is_ready(),
-            "provider": getattr(llm_generator, '_provider', {}).get('name', 'local') if llm_generator else None,
-            "model": getattr(llm_generator, '_model', settings.BASE_MODEL_NAME) if llm_generator else None,
+            "llm_ready": llm_generator is not None,
             "vector_store": vector_store is not None and vector_store.is_ready,
             "realtime_service": realtime_service is not None,
         },

app/models/intent_classifier/model.py

@@ -2,6 +2,7 @@ import os
 import json
 import joblib
 import numpy as np
+from typing import Optional
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.linear_model import LogisticRegression
 from sklearn.pipeline import Pipeline, FeatureUnion
@@ -138,9 +139,9 @@ class IntentClassifier:
             "report": classification_report(y_test, y_pred, output_dict=True)
         }
 
-    def predict(self, text: str) -> dict:
+    def predict(self, text: str, language: Optional[str] = None) -> dict:
         """Predict intent for a given text."""
-        lang = detect_language(text)
+        lang = language or detect_language(text)
         processed = preprocess(text, lang)
 
         if self.is_trained and self.pipeline is not None:

app/models/ner/model.py

@@ -532,8 +532,14 @@ class TravelNER:
         'con', 'hay', 'bay', 'cho', 'coi', 'den', 'mot', 'nha', 'gia',
         'tam', 'tan', 'tay', 'hoa', 'van', 'mon',
         'massa', 'massage', 'tura', 'tour',
-        # Common nouns that happen to be short KB location keys
-        'anh', 'batu', 'sunrise', 'temple', 'shrine', 'market', 'beach',
+        # Common nouns that happen to be short KB location keys.
+        # NOTE: 'anh' is intentionally excluded here — it is a curated alias for
+        # England (→ london) in ALIAS_LOCATIONS, so blocking it would prevent
+        # queries like "tôi muốn đi Anh" from extracting a location.  The alias
+        # mapping takes higher priority than KB entries and is specific enough
+        # that occasional false-positives from the Vietnamese pronoun "anh" are
+        # acceptable.
+        'batu', 'sunrise', 'temple', 'shrine', 'market', 'beach',
     })
 
     def _extract_locations(self, text: str) -> list:

app/services/realtime_data.py

@@ -5,6 +5,8 @@ import time
 from datetime import datetime
 from typing import Optional
 
+import httpx
+
 logger = logging.getLogger(__name__)
 
 # Fallback destination coordinates (used when KB doesn't have the entry)
@@ -34,6 +36,7 @@ class RealtimeDataService:
         self._weather_cache: dict[str, dict] = {}
         self._events: list[dict] = []
         self._destinations: dict[str, dict] = {}
+        self._http_client: Optional[httpx.AsyncClient] = None
 
         # Load events calendar
         if os.path.exists(events_path):
@@ -59,6 +62,17 @@ class RealtimeDataService:
 
         logger.info(f"Weather coords loaded: {len(self._dest_coords)} destinations")
 
+    @property
+    def http_client(self) -> httpx.AsyncClient:
+        if self._http_client is None:
+            self._http_client = httpx.AsyncClient(timeout=5.0)
+        return self._http_client
+
+    async def close(self) -> None:
+        if self._http_client is not None:
+            await self._http_client.aclose()
+            self._http_client = None
+
     async def get_weather(self, destination_id: str) -> Optional[dict]:
         """Get current weather for a destination. Uses cache with TTL."""
         cache_key = destination_id
@@ -71,26 +85,24 @@ class RealtimeDataService:
             return None
 
         try:
-            import httpx
             url = f"{self.weather_api_url}/{coords['name']}?format=j1"
-            async with httpx.AsyncClient(timeout=5.0) as client:
-                response = await client.get(url)
-                if response.status_code == 200:
-                    raw = response.json()
-                    current = raw.get("current_condition", [{}])[0]
-                    weather_data = {
-                        "temp_c": current.get("temp_C", "N/A"),
-                        "feels_like_c": current.get("FeelsLikeC", "N/A"),
-                        "humidity": current.get("humidity", "N/A"),
-                        "description": current.get("weatherDesc", [{}])[0].get("value", "N/A"),
-                        "wind_kmph": current.get("windspeedKmph", "N/A"),
-                        "destination": coords["name"],
-                    }
-                    self._weather_cache[cache_key] = {
-                        "data": weather_data,
-                        "timestamp": time.time()
-                    }
-                    return weather_data
+            response = await self.http_client.get(url)
+            if response.status_code == 200:
+                raw = response.json()
+                current = raw.get("current_condition", [{}])[0]
+                weather_data = {
+                    "temp_c": current.get("temp_C", "N/A"),
+                    "feels_like_c": current.get("FeelsLikeC", "N/A"),
+                    "humidity": current.get("humidity", "N/A"),
+                    "description": current.get("weatherDesc", [{}])[0].get("value", "N/A"),
+                    "wind_kmph": current.get("windspeedKmph", "N/A"),
+                    "destination": coords["name"],
+                }
+                self._weather_cache[cache_key] = {
+                    "data": weather_data,
+                    "timestamp": time.time()
+                }
+                return weather_data
         except Exception as e:
             logger.warning(f"Failed to fetch weather for {destination_id}: {e}")
 

app/services/vector_store.py

@@ -288,10 +288,11 @@ class VectorStore:
             return []
 
         where_filter = {"dest_id": dest_id} if dest_id else None
+        query_text = query[:256]  # cap for embedding quality
 
         try:
             results = self.collection.query(
-                query_texts=[query],
+                query_texts=[query_text],
                 n_results=top_k,
                 where=where_filter
             )