Upload 164 files

src/apis/controllers/chat_controller.py

@@ -68,85 +68,114 @@ async def save_history(user_id, human_message, ai_message, intent):
 
 
 async def chat_streaming_function(user, data: Chat, background_tasks: BackgroundTasks):
-    human_message = data.message
-    history = data.history
-    lat = data.lat
-    long = data.long
-    language = data.language
-    logger.info(f"Language: {language}")
-    process_history = post_process_history(history) if history is not None else None
-    config = {
-        "configurable": {
-            "user_id": user["id"],
-            "user_email": user["email"],
-            "contact_number": user["contact_number"],
-            "session_id": user["id"],
-            "lat": lat,
-            "long": long,
+    try:
+        human_message = data.message
+        history = data.history
+        lat = data.lat
+        long = data.long
+        language = data.language
+        logger.info(f"Language: {language}")
+
+        try:
+            process_history = post_process_history(history) if history is not None else None
+        except Exception as e:
+            logger.error(f"Error processing chat history: {str(e)}")
+            yield json.dumps({"type": "error", "content": "Error processing chat history" + str(e)}, ensure_ascii=False) + "\n"
+            return
+
+        config = {
+            "configurable": {
+                "user_id": user["id"],
+                "user_email": user["email"],
+                "contact_number": user["contact_number"],
+                "session_id": user["id"],
+                "lat": lat,
+                "long": long,
+            }
         }
-    }
-    # try:
-    initial_input = {
-        "messages": [("user", human_message)],
-        "messages_history": process_history,
-        "entry_message": None,
-        "manual_save": False,
-        "intent": data.intent,
-        "language": language,
-        "tool_name": None,
-        "ever_leave_skill": False,
-    }
-    last_output_state = None
-    temp = ""
-    async for event in workflow.astream(
-        input=initial_input,
-        config=config,
-        stream_mode=["messages", "values"],
-    ):
-        event_type, event_message = event
-        if event_type == "messages":
-            message, metadata = event_message
-            if (
-                isinstance(message, AIMessageChunk)
-                and message.tool_calls
-                and message.tool_call_chunks[0]["name"] != "ClassifyUserIntent"
+
+        initial_input = {
+            "messages": [("user", human_message)],
+            "messages_history": process_history,
+            "entry_message": None,
+            "manual_save": False,
+            "intent": data.intent,
+            "language": language,
+            "tool_name": None,
+            "ever_leave_skill": False,
+        }
+
+        last_output_state = None
+        temp = ""
+
+        try:
+            async for event in workflow.astream(
+                input=initial_input,
+                config=config,
+                stream_mode=["messages", "values"],
             ):
-                tool_name = message.tool_call_chunks[0]["name"]
-                message_yield = json.dumps(
-                    {"type": "tool_call", "content": tool_name}, ensure_ascii=False
-                )
-                print(message_yield)
-                yield message_yield + "\n"
-            if metadata["langgraph_node"] in [
-                "primary_assistant",
-                "scheduling_agent",
-                "book_hotel_agent",
-            ]:
-
-                if message.content:
-                    temp += message.content
-                    message_yield = json.dumps(
-                        {"type": "message", "content": temp}, ensure_ascii=False
-                    )
-                    print(message_yield)
-                    yield message_yield + "\n"
-        if event_type == "values":
-            last_output_state = event_message
-
-    final_ai_output = last_output_state["messages"][-1].content
-    final_intent = last_output_state["intent"]
-    tool_name_important = last_output_state["tool_name"]
-
-    final_response = json.dumps(
-        {
-            "type": "final",
-            "content": final_ai_output,
-            "intent": final_intent,
-            "tool_name": tool_name_important,
-        },
-        ensure_ascii=False,
-    )
-    yield final_response
+                try:
+                    event_type, event_message = event
+                    if event_type == "messages":
+                        message, metadata = event_message
+                        if (
+                            isinstance(message, AIMessageChunk)
+                            and message.tool_calls
+                            and message.tool_call_chunks[0]["name"] != "ClassifyUserIntent"
+                        ):
+                            tool_name = message.tool_call_chunks[0]["name"]
+                            message_yield = json.dumps(
+                                {"type": "tool_call", "content": tool_name}, ensure_ascii=False
+                            )
+                            print(message_yield)
+                            yield message_yield + "\n"
+
+                        if metadata["langgraph_node"] in [
+                            "primary_assistant",
+                            "scheduling_agent",
+                            "book_hotel_agent",
+                        ]:
+                            if message.content:
+                                temp += message.content
+                                message_yield = json.dumps(
+                                    {"type": "message", "content": temp}, ensure_ascii=False
+                                )
+                                print(message_yield)
+                                yield message_yield + "\n"
+                    if event_type == "values":
+                        last_output_state = event_message
+                except Exception as e:
+                    logger.error(f"Error processing stream event: {str(e)}")
+                    yield json.dumps({"type": "error", "content": "Error processing response" + str(e)}, ensure_ascii=False) + "\n"
+                    return
+
+            if last_output_state is None:
+                raise ValueError("No output state received from workflow")
+
+            final_ai_output = last_output_state["messages"][-1].content
+            final_intent = last_output_state["intent"]
+            tool_name_important = last_output_state["tool_name"]
+
+            final_response = json.dumps(
+                {
+                    "type": "final",
+                    "content": final_ai_output,
+                    "intent": final_intent,
+                    "tool_name": tool_name_important,
+                },
+                ensure_ascii=False,
+            )
+            yield final_response
+
+        except Exception as e:
+            logger.error(f"Error in workflow stream processing: {str(e)}")
+            yield json.dumps({"type": "error", "content": "Error processing chat stream" + str(e)}, ensure_ascii=False) + "\n"
+            return
+
+    except Exception as e:
+        logger.error(f"Unexpected error in chat streaming: {str(e)}")
+        yield json.dumps({"type": "error", "content": "An unexpected error occurred" + str(e)}, ensure_ascii=False) + "\n"
+        return
 
     background_tasks.add_task(
         save_history, user["id"], human_message, final_ai_output, final_intent
@@ -156,84 +185,114 @@ async def chat_streaming_function(user, data: Chat, background_tasks: Background
 async def chat_streaming_no_login_function(
     data: Chat, background_tasks: BackgroundTasks
 ):
-    human_message = data.message
-    history = data.history
-    lat = data.lat
-    long = data.long
-    language = data.language
-    logger.info(f"Language: {language}")
-    process_history = post_process_history(history) if history is not None else None
-    config = {
-        "configurable": {
-            "user_id": None,
-            "user_email": None,
-            "contact_number": None,
-            "session_id": None,
-            "lat": lat,
-            "long": long,
+    try:
+        human_message = data.message
+        history = data.history
+        lat = data.lat
+        long = data.long
+        language = data.language
+        logger.info(f"Language: {language}")
+
+        try:
+            process_history = post_process_history(history) if history is not None else None
+        except Exception as e:
+            logger.error(f"Error processing chat history: {str(e)}")
+            yield json.dumps({"type": "error", "content": "Error processing chat history"}, ensure_ascii=False) + "\n"
+            return
+
+        config = {
+            "configurable": {
+                "user_id": None,
+                "user_email": None,
+                "contact_number": None,
+                "session_id": None,
+                "lat": lat,
+                "long": long,
+            }
         }
-    }
-    initial_input = {
-        "messages": [("user", human_message)],
-        "messages_history": process_history,
-        "entry_message": None,
-        "manual_save": False,
-        "intent": data.intent,
-        "language": language,
-        "tool_name": None,
-        "ever_leave_skill": False,
-    }
-    last_output_state = None
-    temp = ""
-    async for event in workflow.astream(
-        input=initial_input,
-        config=config,
-        stream_mode=["messages", "values"],
-    ):
-        event_type, event_message = event
-        if event_type == "messages":
-            message, metadata = event_message
-            if (
-                isinstance(message, AIMessageChunk)
-                and message.tool_calls
-                and message.tool_call_chunks[0]["name"] != "ClassifyUserIntent"
+
+        initial_input = {
+            "messages": [("user", human_message)],
+            "messages_history": process_history,
+            "entry_message": None,
+            "manual_save": False,
+            "intent": data.intent,
+            "language": language,
+            "tool_name": None,
+            "ever_leave_skill": False,
+        }
+
+        last_output_state = None
+        temp = ""
+
+        try:
+            async for event in workflow.astream(
+                input=initial_input,
+                config=config,
+                stream_mode=["messages", "values"],
             ):
-                tool_name = message.tool_call_chunks[0]["name"]
-                message_yield = json.dumps(
-                    {"type": "tool_call", "content": tool_name}, ensure_ascii=False
-                )
-                print(message_yield)
-                yield message_yield + "\n"
-            if metadata["langgraph_node"] in [
-                "primary_assistant",
-                "scheduling_agent",
-                "book_hotel_agent",
-            ]:
-
-                if message.content:
-                    temp += message.content
-                    message_yield = json.dumps(
-                        {"type": "message", "content": temp}, ensure_ascii=False
-                    )
-                    print(message_yield)
-                    yield message_yield + "\n"
-        if event_type == "values":
-            last_output_state = event_message
-
-    final_ai_output = last_output_state["messages"][-1].content
-    final_intent = last_output_state["intent"]
-    tool_name_important = last_output_state["tool_name"]
-
-    final_response = json.dumps(
-        {
-            "type": "final",
-            "content": final_ai_output,
-            "intent": final_intent,
-            "tool_name": tool_name_important,
-        },
-        ensure_ascii=False,
-    )
-    yield final_response
+                try:
+                    event_type, event_message = event
+                    if event_type == "messages":
+                        message, metadata = event_message
+                        if (
+                            isinstance(message, AIMessageChunk)
+                            and message.tool_calls
+                            and message.tool_call_chunks[0]["name"] != "ClassifyUserIntent"
+                        ):
+                            tool_name = message.tool_call_chunks[0]["name"]
+                            message_yield = json.dumps(
+                                {"type": "tool_call", "content": tool_name}, ensure_ascii=False
+                            )
+                            print(message_yield)
+                            yield message_yield + "\n"
+
+                        if metadata["langgraph_node"] in [
+                            "primary_assistant",
+                            "scheduling_agent",
+                            "book_hotel_agent",
+                        ]:
+                            if message.content:
+                                temp += message.content
+                                message_yield = json.dumps(
+                                    {"type": "message", "content": temp}, ensure_ascii=False
+                                )
+                                print(message_yield)
+                                yield message_yield + "\n"
+                    if event_type == "values":
+                        last_output_state = event_message
+                except Exception as e:
+                    logger.error(f"Error processing stream event: {str(e)}")
+                    yield json.dumps({"type": "error", "content": "Error processing response" + str(e)}, ensure_ascii=False) + "\n"
+                    return
+
+            if last_output_state is None:
+                raise ValueError("No output state received from workflow")
+
+            final_ai_output = last_output_state["messages"][-1].content
+            final_intent = last_output_state["intent"]
+            tool_name_important = last_output_state["tool_name"]
+
+            final_response = json.dumps(
+                {
+                    "type": "final",
+                    "content": final_ai_output,
+                    "intent": final_intent,
+                    "tool_name": tool_name_important,
+                },
+                ensure_ascii=False,
+            )
+            yield final_response
+
+        except Exception as e:
+            logger.error(f"Error in workflow stream processing: {str(e)}")
+            yield json.dumps({"type": "error", "content": "Error processing chat stream" + str(e)}, ensure_ascii=False) + "\n"
+            return
+
+    except Exception as e:
+        logger.error(f"Unexpected error in chat streaming: {str(e)}")
+        yield json.dumps({"type": "error", "content": "An unexpected error occurred" + str(e)}, ensure_ascii=False) + "\n"
+        return
 
 
 async def chat_function(user, data: Chat, background_tasks: BackgroundTasks):

src/apis/controllers/destination_controller.py

@@ -14,18 +14,19 @@ from src.apis.controllers.location_controller import (
     get_places,
 )
 from src.langgraph.config.constant import available_categories
+from src.utils.logger import logger
 
 
 async def destination_suggestion_controller(
-    question: str, top_k: int = 5
+    question: str, user_id: str, top_k: int = 5
 ) -> List[Dict[str, Any]]:
-
+    url = f"https://abao77-destination-suggestion.hf.space/model/get_destinations_list_by_question/{question}/{top_k}"
+    if user_id:
+        url += f"/{user_id}"
+        logger.info("Call recommend with user_id")
     async with aiohttp.ClientSession() as session:
-        # Get question tags
         try:
-            async with session.get(
-                f"https://abao77-destination-suggestion.hf.space/model/get_destinations_list_by_question/{question}/{top_k}"
-            ) as response:
+            async with session.get(url) as response:
                 if response.status == 200:
                     data = await response.json()
                     logger.info(f"Destination suggestion for question: {data}")
@@ -40,11 +41,22 @@ async def destination_suggestion_controller(
             raise HTTPException(status_code=500, detail=f"Request failed: {str(e)}")
 
 
-async def destination_recommendation_func(query, top_k=5, tool_chat=False):
-    routing: RoutingRecommender = routing_recommender_chain.invoke({"query": query})
-    print("label", routing.label)
-    if routing.label == "characteristic":
-        output = await destination_suggestion_controller(query, top_k)
+async def destination_recommendation_func(
+    query, user_id: str, top_k=5, tool_chat=False
+):
+    routing: RoutingRecommender = await routing_recommender_chain.ainvoke(
+        {"query": query}
+    )
+    print("routing", routing)
+    if routing.label == "invalid":
+        if tool_chat:
+            return "the input message is not related to travel or destination"
+        raise HTTPException(
+            status_code=400,
+            detail="The input is not related to travel or destination recommendations. Please provide a travel-related query.",
+        )
+    elif routing.label == "characteristic":
+        output = await destination_suggestion_controller(query, user_id, top_k)
         if tool_chat:
             return output
         output = [

src/apis/controllers/planner_controller.py

@@ -2,39 +2,68 @@ import json
 from fastapi import BackgroundTasks
 from src.langgraph.multi_agent.planner.planner_flow import planner_app
 from src.utils.helper import parse_itinerary
+from src.utils.logger import logger
 
 
 async def message_generator(input_graph, config, background: BackgroundTasks):
+    try:
+        last_output_state = None
+        temp = ""
 
-    last_output_state = None
-    temp = ""
-    async for event in planner_app.astream(
-        input=input_graph,
-        config=config,
-        stream_mode=["messages", "values"],
-    ):
-        event_type, event_message = event
-        if event_type == "messages":
-            message, _ = event_message
-            if message.content:
-                temp += message.content
-                message_yield = json.dumps(
-                    {"type": "message", "content": temp},
+        try:
+            async for event in planner_app.astream(
+                input=input_graph,
+                config=config,
+                stream_mode=["messages", "values"],
+            ):
+                try:
+                    event_type, event_message = event
+                    if event_type == "messages":
+                        message, _ = event_message
+                        if message.content:
+                            temp += message.content
+                            message_yield = json.dumps(
+                                {"type": "message", "content": temp},
+                                ensure_ascii=False,
+                            )
+                            yield message_yield + "\n\n"
+                    if event_type == "values":
+                        last_output_state = event_message
+                except Exception as e:
+                    logger.error(f"Error processing stream event: {str(e)}")
+                    yield json.dumps({"type": "error", "content": "Error processing planner response " + str(e)}, ensure_ascii=False) + "\n\n"
+                    return
+
+            if last_output_state is None:
+                raise ValueError("No output state received from planner workflow")
+
+            if "final_answer" not in last_output_state:
+                raise ValueError("No final answer in planner output")
+
+            try:
+                parser_ouput = parse_itinerary(last_output_state["final_answer"])
+                final_response = json.dumps(
+                    {
+                        "type": "final",
+                        "content": parser_ouput,
+                    },
                     ensure_ascii=False,
                 )
-                yield message_yield + "\n\n"
-        if event_type == "values":
-            last_output_state = event_message
-    if last_output_state and "final_answer" in last_output_state:
-        parser_ouput = parse_itinerary(last_output_state["final_answer"])
-        final_response = json.dumps(
-            {
-                "type": "final",
-                "content": parser_ouput,
-            },
-            ensure_ascii=False,
-        )
-        yield final_response + "\n\n"
+                yield final_response + "\n\n"
+            except Exception as e:
+                logger.error(f"Error parsing itinerary: {str(e)}")
+                yield json.dumps({"type": "error", "content": "Error parsing the generated itinerary" + str(e)}, ensure_ascii=False) + "\n\n"
+                return
+
+        except Exception as e:
+            logger.error(f"Error in planner workflow stream: {str(e)}")
+            yield json.dumps({"type": "error", "content": "Error processing planner stream" + str(e)}, ensure_ascii=False) + "\n\n"
+            return
+
+    except Exception as e:
+        logger.error(f"Unexpected error in planner: {str(e)}")
+        yield json.dumps({"type": "error", "content": "An unexpected error occurred in the planner" + str(e)}, ensure_ascii=False) + "\n\n"
+        return
 
 
 from pydantic import BaseModel, Field

src/apis/routes/travel_dest_route.py

@@ -1,260 +1,267 @@
-from fastapi import APIRouter, Depends, HTTPException, Query
-from typing import Annotated, List
-from fastapi.responses import JSONResponse
-import pandas as pd
-import math
-from src.apis.models.user_models import User
-from src.apis.models.destination_models import Destination
-from src.apis.middlewares.auth_middleware import get_current_user
-from src.utils.logger import logger
-from src.apis.controllers.destination_controller import (
-    destination_recommendation_func,
-)
-from fastapi.responses import JSONResponse
-from src.utils.mongo import DestinationCRUD
-from datetime import datetime
-from bson import ObjectId
-
-router = APIRouter(prefix="/dest", tags=["Destination"])
-
-user_dependency = Annotated[User, Depends(get_current_user)]
-EXCEL_FILE_PATH = "./src/data/destination_1_new_tag.xlsx"
-
-
-@router.get("/get_tourist")
-def get_tourist(page: int = Query(default=1, ge=1)):
-    try:
-        PAGE_SIZE = 10
-        df = pd.read_excel(EXCEL_FILE_PATH)
-        required_columns = ["name", "description", "image"]
-        if not all(col in df.columns for col in required_columns):
-            raise HTTPException(
-                status_code=400, detail="Missing required columns in Excel file"
-            )
-        total_items = len(df)
-        total_pages = math.ceil(total_items / PAGE_SIZE)
-        start_idx = (page - 1) * PAGE_SIZE
-        end_idx = start_idx + PAGE_SIZE
-        paginated_df = df[required_columns].iloc[start_idx:end_idx]
-        tourist_data = paginated_df.to_dict(orient="records")
-        return JSONResponse(
-            content={
-                "data": tourist_data,
-                "page": page,
-                "total_pages": total_pages,
-                "total_items": total_items,
-                "page_size": PAGE_SIZE,
-            }
-        )
-    except Exception as e:
-        logger.error(f"Error reading the Excel file: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error reading the Excel file: {str(e)}"
-        )
-
-
-@router.get("/destination_detail")
-async def get_destinations(destination_id: str = Query(min_length=1, max_length=50)):
-    try:
-        destination_data = await DestinationCRUD.find_by_id(destination_id)
-        if not destination_data:
-            return JSONResponse(
-                content={"message": "Destination not found"}, status_code=404
-            )
-        destination_data.pop("created_at")
-        destination_data.pop("updated_at")
-        destination_data.pop("expire_at")
-        destination_data["id"] = str(destination_data["_id"])
-        destination_data.pop("_id")
-        print("destination_data", destination_data)
-        return JSONResponse(content=destination_data, status_code=200)
-
-    except Exception as e:
-        logger.error(f"Error fetching destination: {str(e)}")
-
-
-@router.get("/paginate")
-async def get_paginated_destinations(
-    page: int = Query(default=1, ge=1), page_size: int = Query(default=10, ge=1, le=100)
-):
-    """
-    Get paginated destinations from database
-
-    Args:
-        page: Page number (starts from 1)
-        page_size: Number of items per page
-
-    Returns:
-        Paginated list of destinations with pagination metadata
-    """
-    try:
-        # Calculate skip value for pagination
-        skip = (page - 1) * page_size
-
-        # Query destinations with pagination
-        destination_data = await DestinationCRUD.find_many(
-            filter={},  # Empty filter means get all
-            skip=skip,
-            limit=page_size,
-            sort=[("created_at", -1)],  # Sort by created_at descending
-        )
-
-        # Get total count for pagination metadata
-        total_items = await DestinationCRUD.count({})
-        total_pages = math.ceil(total_items / page_size)
-
-        # Process results
-        serialized_data = []
-        for dest in destination_data:
-            dest.pop("created_at")
-            dest.pop("updated_at")
-            dest.pop("expire_at")
-
-            dest_dict = {
-                "id": dest["_id"],
-                **{k: v for k, v in dest.items() if k != "_id"},
-            }
-            serialized_data.append(dest_dict)
-
-        return JSONResponse(
-            content={
-                "data": serialized_data,
-                "page": page,
-                "total_pages": total_pages,
-                "total_items": total_items,
-                "page_size": page_size,
-            },
-            status_code=200,
-        )
-    except Exception as e:
-        logger.error(f"Error fetching paginated destinations: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error fetching paginated destinations: {str(e)}"
-        )
-
-
-@router.get("/get_tourist_names")
-async def get_tourist_names():
-    try:
-        destination_data = await DestinationCRUD.find_all()
-        serialized_data = []
-        for dest in destination_data:
-            dest.pop("created_at")
-            dest.pop("updated_at")
-            dest.pop("expire_at")
-            dest["id"] = str(dest["_id"])
-            dest.pop("_id")
-            serialized_data.append(dest)
-        return JSONResponse(content={"data": serialized_data}, status_code=200)
-    except Exception as e:
-        logger.error(f"Error getting tourist names: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error getting tourist names: {str(e)}"
-        )
-
-
-@router.get("/suggest")
-async def destination_suggestion(question: str, top_k: int = Query(default=5, ge=1)):
-    return JSONResponse(await destination_recommendation_func(question))
-
-
-@router.post("/")
-async def create_destination(
-    destination_data: Destination, current_user: user_dependency
-):
-    if current_user["role"] != "admin":
-        raise HTTPException(status_code=403, detail="Unauthorized")
-    try:
-        destination_id = await DestinationCRUD.create(destination_data.model_dump())
-
-        if not destination_id:
-            raise HTTPException(status_code=400, detail="Failed to create destination")
-
-        return JSONResponse(
-            content={
-                "message": "Destination created successfully",
-                "id": destination_id,
-            },
-            status_code=201,
-        )
-    except Exception as e:
-        logger.error(f"Error creating destination: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error creating destination: {str(e)}"
-        )
-
-
-@router.put("/{destination_id}")
-async def update_destination(
-    destination_id: str, destination_data: dict, current_user: user_dependency
-):
-    if current_user["role"] != "admin":
-        raise HTTPException(status_code=403, detail="Unauthorized")
-    try:
-        # Add updated_at timestamp
-        destination_data["updated_at"] = datetime.utcnow()
-
-        # Update destination
-        result = await DestinationCRUD.update(
-            {"_id": ObjectId(destination_id)}, destination_data
-        )
-
-        if not result:
-            raise HTTPException(status_code=404, detail="Destination not found")
-
-        return JSONResponse(
-            content={"message": "Destination updated successfully"}, status_code=200
-        )
-    except Exception as e:
-        logger.error(f"Error updating destination: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error updating destination: {str(e)}"
-        )
-
-
-@router.delete("/{destination_id}")
-async def delete_destination(destination_id: str, current_user: user_dependency):
-    if current_user["role"] != "admin":
-        raise HTTPException(status_code=403, detail="Unauthorized")
-    try:
-        # Delete destination
-        result = await DestinationCRUD.delete_one({"_id": ObjectId(destination_id)})
-
-        if not result:
-            raise HTTPException(status_code=404, detail="Destination not found")
-
-        return JSONResponse(
-            content={"message": "Destination deleted successfully"}, status_code=200
-        )
-    except Exception as e:
-        logger.error(f"Error deleting destination: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error deleting destination: {str(e)}"
-        )
-
-
-@router.get("/")
-async def get_all_destinations(current_user: user_dependency):
-    print("current_user", current_user)
-    if current_user["role"] != "admin":
-        raise HTTPException(status_code=403, detail="Unauthorized")
-    try:
-        # Get all destinations
-        destinations = await DestinationCRUD.find_all()
-
-        # Process results
-        serialized_data = []
-        for dest in destinations:
-            dest.pop("created_at")
-            dest.pop("updated_at")
-            dest.pop("expire_at")
-            dest["id"] = str(dest["_id"])
-            dest.pop("_id")
-            serialized_data.append(dest)
-
-        return JSONResponse(content={"data": serialized_data}, status_code=200)
-    except Exception as e:
-        logger.error(f"Error fetching destinations: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Error fetching destinations: {str(e)}"
-        )
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Annotated, List
+from fastapi.responses import JSONResponse
+import pandas as pd
+import math
+from src.apis.models.user_models import User
+from src.apis.models.destination_models import Destination
+from src.apis.middlewares.auth_middleware import get_current_user
+from src.utils.logger import logger
+from src.apis.controllers.destination_controller import (
+    destination_recommendation_func,
+)
+from fastapi.responses import JSONResponse
+from src.utils.mongo import DestinationCRUD
+from datetime import datetime
+from bson import ObjectId
+
+router = APIRouter(prefix="/dest", tags=["Destination"])
+
+user_dependency = Annotated[User, Depends(get_current_user)]
+EXCEL_FILE_PATH = "./src/data/destination_1_new_tag.xlsx"
+
+
+@router.get("/get_tourist")
+def get_tourist(page: int = Query(default=1, ge=1)):
+    try:
+        PAGE_SIZE = 10
+        df = pd.read_excel(EXCEL_FILE_PATH)
+        required_columns = ["name", "description", "image"]
+        if not all(col in df.columns for col in required_columns):
+            raise HTTPException(
+                status_code=400, detail="Missing required columns in Excel file"
+            )
+        total_items = len(df)
+        total_pages = math.ceil(total_items / PAGE_SIZE)
+        start_idx = (page - 1) * PAGE_SIZE
+        end_idx = start_idx + PAGE_SIZE
+        paginated_df = df[required_columns].iloc[start_idx:end_idx]
+        tourist_data = paginated_df.to_dict(orient="records")
+        return JSONResponse(
+            content={
+                "data": tourist_data,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": PAGE_SIZE,
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error reading the Excel file: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error reading the Excel file: {str(e)}"
+        )
+
+
+@router.get("/destination_detail")
+async def get_destinations(destination_id: str = Query(min_length=1, max_length=50)):
+    try:
+        destination_data = await DestinationCRUD.find_by_id(destination_id)
+        if not destination_data:
+            return JSONResponse(
+                content={"message": "Destination not found"}, status_code=404
+            )
+        destination_data.pop("created_at")
+        destination_data.pop("updated_at")
+        destination_data.pop("expire_at")
+        destination_data["id"] = str(destination_data["_id"])
+        destination_data.pop("_id")
+        print("destination_data", destination_data)
+        return JSONResponse(content=destination_data, status_code=200)
+
+    except Exception as e:
+        logger.error(f"Error fetching destination: {str(e)}")
+
+
+@router.get("/paginate")
+async def get_paginated_destinations(
+    page: int = Query(default=1, ge=1), page_size: int = Query(default=10, ge=1, le=100)
+):
+    """
+    Get paginated destinations from database
+
+    Args:
+        page: Page number (starts from 1)
+        page_size: Number of items per page
+
+    Returns:
+        Paginated list of destinations with pagination metadata
+    """
+    try:
+        # Calculate skip value for pagination
+        skip = (page - 1) * page_size
+
+        # Query destinations with pagination
+        destination_data = await DestinationCRUD.find_many(
+            filter={},  # Empty filter means get all
+            skip=skip,
+            limit=page_size,
+            sort=[("created_at", -1)],  # Sort by created_at descending
+        )
+
+        # Get total count for pagination metadata
+        total_items = await DestinationCRUD.count({})
+        total_pages = math.ceil(total_items / page_size)
+
+        # Process results
+        serialized_data = []
+        for dest in destination_data:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+
+            dest_dict = {
+                "id": dest["_id"],
+                **{k: v for k, v in dest.items() if k != "_id"},
+            }
+            serialized_data.append(dest_dict)
+
+        return JSONResponse(
+            content={
+                "data": serialized_data,
+                "page": page,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "page_size": page_size,
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        logger.error(f"Error fetching paginated destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching paginated destinations: {str(e)}"
+        )
+
+
+@router.get("/get_tourist_names")
+async def get_tourist_names():
+    try:
+        destination_data = await DestinationCRUD.find_all()
+        serialized_data = []
+        for dest in destination_data:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+            dest["id"] = str(dest["_id"])
+            dest.pop("_id")
+            serialized_data.append(dest)
+        return JSONResponse(content={"data": serialized_data}, status_code=200)
+    except Exception as e:
+        logger.error(f"Error getting tourist names: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error getting tourist names: {str(e)}"
+        )
+
+
+@router.get("/suggest")
+async def destination_suggestion(
+    question: str,
+    user_id: str = Query(
+        default=None, description="User ID for personalized recommendations"
+    ),
+    top_k: int = Query(default=5, ge=1, description="Number of destinations to return"),
+):
+    result = await destination_recommendation_func(question, user_id, top_k)
+    return JSONResponse(content=result)
+
+
+@router.post("/")
+async def create_destination(
+    destination_data: Destination, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        destination_id = await DestinationCRUD.create(destination_data.model_dump())
+
+        if not destination_id:
+            raise HTTPException(status_code=400, detail="Failed to create destination")
+
+        return JSONResponse(
+            content={
+                "message": "Destination created successfully",
+                "id": destination_id,
+            },
+            status_code=201,
+        )
+    except Exception as e:
+        logger.error(f"Error creating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error creating destination: {str(e)}"
+        )
+
+
+@router.put("/{destination_id}")
+async def update_destination(
+    destination_id: str, destination_data: dict, current_user: user_dependency
+):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Add updated_at timestamp
+        destination_data["updated_at"] = datetime.utcnow()
+
+        # Update destination
+        result = await DestinationCRUD.update(
+            {"_id": ObjectId(destination_id)}, destination_data
+        )
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination updated successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error updating destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error updating destination: {str(e)}"
+        )
+
+
+@router.delete("/{destination_id}")
+async def delete_destination(destination_id: str, current_user: user_dependency):
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Delete destination
+        result = await DestinationCRUD.delete_one({"_id": ObjectId(destination_id)})
+
+        if not result:
+            raise HTTPException(status_code=404, detail="Destination not found")
+
+        return JSONResponse(
+            content={"message": "Destination deleted successfully"}, status_code=200
+        )
+    except Exception as e:
+        logger.error(f"Error deleting destination: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error deleting destination: {str(e)}"
+        )
+
+
+@router.get("/")
+async def get_all_destinations(current_user: user_dependency):
+    print("current_user", current_user)
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    try:
+        # Get all destinations
+        destinations = await DestinationCRUD.find_all()
+
+        # Process results
+        serialized_data = []
+        for dest in destinations:
+            dest.pop("created_at")
+            dest.pop("updated_at")
+            dest.pop("expire_at")
+            dest["id"] = str(dest["_id"])
+            dest.pop("_id")
+            serialized_data.append(dest)
+
+        return JSONResponse(content={"data": serialized_data}, status_code=200)
+    except Exception as e:
+        logger.error(f"Error fetching destinations: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching destinations: {str(e)}"
+        )

src/langgraph/langchain/llm.py

@@ -8,10 +8,10 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 llm = ChatGoogleGenerativeAI(
     model="gemini-2.0-flash",
     temperature=0.1,
-    max_retries=2,
+    # max_retries=2,
 )
 llm_flash = ChatGoogleGenerativeAI(
     model="gemini-1.5-flash",
     temperature=0.1,
-    max_retries=2,
+    # max_retries=2,
 )

src/langgraph/langchain/prompt.py

@@ -144,10 +144,11 @@ routing_recommender_prompt = PromptTemplate.from_template(
     """You are a tour guide.
 ### Instruction:
 You are given a query sentence
-Classify the query as 'characteristic' or 'geographic' based on its content.
+Classify the query as 'characteristic', 'geographic' or 'invalid' based on its content.
 
 - 'Characteristic' if it asks about a place's features (e.g., camping, relaxing, scenic).
 - 'Geographic' if it involves location specifics (e.g., near a city, in a province, on a road).
+- 'Invalid' if the query is not related to travel or destination.
 
 ###
 Query sentence: {query}
@@ -167,7 +168,7 @@ Query sentence: {query}
 
 
 class RoutingRecommender(BaseModel):
-    label: str = Field(..., description="is 'characteristic' or 'geographic'")
+    label: str = Field(..., description="is 'characteristic', 'geographic' or 'invalid'")
 
 
 class CharacteristicExtractor(BaseModel):

src/langgraph/multi_agent/planner/planner_flow.py

@@ -104,8 +104,19 @@ async def excute_tools_fn(state: State):
     llm_response: AgentAction = state["llm_response"][-1]
     tool_call_name = llm_response.tool
     tool_args = llm_response.tool_input
-    logger.info(f"-> Tool name: {tool_call_name}")
+    
+    # Preprocess tool name to remove markdown formatting
+    if tool_call_name.startswith("**") and tool_call_name.endswith("**"):
+        tool_call_name = tool_call_name[2:-2]  # Remove ** from start and end
+    elif tool_call_name.startswith("*") and tool_call_name.endswith("*"):
+        tool_call_name = tool_call_name[1:-1]  # Remove * from start and end
+    elif tool_call_name.startswith("`") and tool_call_name.endswith("`"):
+        tool_call_name = tool_call_name[1:-1]  # Remove ` from start and end
+    
+    logger.info(f"-> Original tool name: {llm_response.tool}")
+    logger.info(f"-> Processed tool name: {tool_call_name}")
     logger.info(f"-> Tool args: {tool_args}")
+    
     if tool_call_name == "destination_suggestion":
         tool_response = await destination_suggestion.ainvoke(
             {"query": tool_args, "config": ""}

src/langgraph/tools/destination_tools.py

@@ -14,8 +14,13 @@ async def destination_suggestion(query: str, config: RunnableConfig):
     query (str): query related to wanting to go somewhere locations near a certain area/location or location's characteristics user want to go. Auto extracted from user's message.
     Using Vietnamese language for better results
     """
+    configuration = config.get("configurable", {})
+    user_id = configuration.get("user_id", None)
+    if not user_id:
+        logger.info("User ID is not provided")
+
     logger.info(f"Destination recommendation query: {query}")
-    response = await destination_recommendation_func(query, tool_chat=True)
+    response = await destination_recommendation_func(query, user_id, tool_chat=True)
     logger.info(f"Destination recommendation output: {response}")
     return response