fix: dependency

app.py

@@ -62,7 +62,7 @@ def generate_trip_plan(request: PlanRequest):
             tripOverview=f"Error: {str(e)}",
             query_params=request,
             retrieved_data=[],
-            trip_plan=TripPlan(overview="Error occurred", total_estimated_cost=0.0, steps=[]),
+            trip_plan=TripPlan(overview="Error occurred"),
             meta={"status": "error", "error": str(e)}
         )
 

interface.py

@@ -20,14 +20,26 @@ class YoutubeLinkResponse(BaseModel):
 
 
 class PlanRequest(BaseModel):
-    start_place: str
-    destination_place: str
+    # Core location fields
+    start_place: str = Field(..., description="Starting location")
+    destination: str = Field(..., description="Destination location") 
+    
+    # Trip details
+    travelDates: Optional[str] = Field(None, description="Travel dates in format 'YYYY-MM-DD to YYYY-MM-DD'")
+    duration: int = Field(..., description="Duration in days")
+    
+    # Group and preferences
+    groupSize: int = Field(4, description="Number of people in the group")
+    interests: List[str] = Field(default_factory=list, description="List of interests like 'Cultural immersion', 'Mountain views'")
+    
+    # Budget and accommodation
+    budgetTier: Optional[str] = Field(None, description="Budget tier: 'Budget', 'Mid-range', 'Luxury'")
     trip_price: Optional[float] = Field(None, description="Total budget in local currency")
-    trip_context: Optional[str] = Field(None, description="e.g. adventure, rest, date")
-    trip_duration_days: Optional[int] = 1
-    group_size: Optional[int] = 1
-    preferences: Optional[List[str]] = None
-    top_k: Optional[int] = 3
+    stayPref: Optional[str] = Field(None, description="Accommodation preference like 'Tea houses and lodges'")
+    
+    # Transport and theme
+    transportPref: Optional[str] = Field(None, description="Transport preference like 'Local bus'")
+    theme: Optional[str] = Field(None, description="Trip theme like 'Adventure', 'Relaxation'")
 
 
 class RetrievedItem(BaseModel):
@@ -35,35 +47,59 @@ class RetrievedItem(BaseModel):
     place_name: str
     score: float
 
-class TransportInfo(BaseModel):
-    mode: Optional[str]
-    departure: Optional[str]
-    arrival: Optional[str]
-    duration_minutes: Optional[int]
-    price: Optional[float]
-    details: Optional[str]
-
-class PlanStep(BaseModel):
-    day: Optional[int]
-    title: Optional[str]
-    description: Optional[str]
-    transport: Optional[TransportInfo]
-    booking_info: Optional[List[Dict[str, str]]]
-    map_coordinates: Optional[Dict[str, float]]
-    images: Optional[List[str]]
-    tips: Optional[List[str]]
+class Timeline(BaseModel):
+    t: str = Field(..., description="Time in HH:MM format")
+    detail: str = Field(..., description="Activity description")
+
+class Spot(BaseModel):
+    name: str = Field(..., description="Location name")
+    time: str = Field(..., description="Time range like '09:30 – 11:45'")
+    notes: str = Field(..., description="Description and tips")
+
+class Budget(BaseModel):
+    transport: Optional[float] = Field(None, description="Transport cost")
+    entrance: Optional[float] = Field(None, description="Entrance fees")
+    meals: Optional[float] = Field(None, description="Meal costs")
+    accommodation: Optional[float] = Field(None, description="Accommodation costs")
+    activities: Optional[float] = Field(None, description="Activity costs")
+    total: Optional[float] = Field(None, description="Total estimated cost")
+
+class Permits(BaseModel):
+    needed: bool = Field(False, description="Whether permits are required")
+    notes: str = Field("", description="Permit requirements")
+    seasonal: str = Field("", description="Seasonal considerations")
+
+class Contact(BaseModel):
+    name: str = Field(..., description="Contact name")
+    phone: str = Field(..., description="Phone number")
+
+class SafetyContacts(BaseModel):
+    ranger: Optional[Contact] = Field(None, description="Ranger station contact")
+    hospital: Optional[Contact] = Field(None, description="Hospital contact")
+    police: Optional[Contact] = Field(None, description="Police contact")
+
+class Safety(BaseModel):
+    registration: str = Field("", description="Safety registration info")
+    checkins: str = Field("", description="Check-in procedures")
+    sos: str = Field("", description="Emergency procedures")
+    contacts: Optional[SafetyContacts] = Field(None, description="Emergency contacts")
 
 class TripPlan(BaseModel):
-    overview: str
-    total_estimated_cost: Optional[float]
-    steps: List[PlanStep]
+    title: str = Field(..., description="Descriptive title for the trip")
+    date: str = Field(..., description="Suggested date/timing")
+    timeline: List[Timeline] = Field(default_factory=list, description="Daily timeline")
+    spots: List[Spot] = Field(default_factory=list, description="Points of interest")
+    budget: Budget = Field(..., description="Budget breakdown")
+    permits: Optional[Permits] = Field(None, description="Permit information")
+    safety: Optional[Safety] = Field(None, description="Safety information")
 
 class PlanResponse(BaseModel):
-    tripOverview: str
-    query_params: PlanRequest
-    retrieved_data: List[RetrievedItem]
-    trip_plan: TripPlan
-    meta: Dict[str, Any]
+    tripOverview: str = Field(..., description="Overview of the trip")
+    query_params: PlanRequest = Field(..., description="Original request parameters")
+    retrieved_data: List[RetrievedItem] = Field(default_factory=list, description="Retrieved context data")
+    trip_plan: TripPlan = Field(..., description="Detailed trip plan")
+    meta: Dict[str, Any] = Field(default_factory=dict, description="Metadata")
+
     
 class ChatRequest(BaseModel):
     message: str

utils/llm_caller.py

@@ -7,7 +7,8 @@ from dataclasses import dataclass
 from qdrant_client import QdrantClient
 from openai import OpenAI
 from sentence_transformers import SentenceTransformer
-from interface import PlanResponse, TripPlan, PlanStep, TransportInfo, RetrievedItem, PlanRequest
+from interface import PlanResponse, TripPlan, RetrievedItem, PlanRequest
+from interface import Timeline, Spot, Budget, Permits, Safety, Contact, SafetyContacts
 from class_mod.rest_qdrant import RestQdrantClient
 import json 
 
@@ -54,192 +55,254 @@ class LLMCaller:
             print(f"Error calling LLM: {e}")
             return f"Error: Unable to get LLM response - {str(e)}"
     
-    async def query_with_rag(self, plan_request: PlanRequest, collection_name: Optional[str] = None) -> 'PlanResponse':
-        """
-        Perform RAG query using PlanRequest, embed query, search Qdrant, and generate complete PlanResponse via LLM
-        """
-        print(plan_request)
-        try:
-            # 1. Create query string from PlanRequest
-            query_text = f"Trip from {plan_request.start_place} to {plan_request.destination_place}"
-            if plan_request.trip_context:
-                query_text += f" for {plan_request.trip_context}"
-            if plan_request.trip_duration_days:
-                query_text += f" for {plan_request.trip_duration_days} days"
-            if plan_request.trip_price:
-                query_text += f" with budget {plan_request.trip_price}"
-            
-            # 2. Generate embedding for the query
-            query_embedding = self.embedding_model.encode(query_text, normalize_embeddings=True).tolist()
-            
-            # 3. Search Qdrant for similar content
-            collection = collection_name or self.collection_name
-            top_k = plan_request.top_k or self.top_k
-            
-            search_results = self.qdrant.search(
-                collection_name=collection,
-                query_vector=query_embedding,
-                limit=top_k,
-                with_payload=True
-            )
-            
-            # 4. Convert search results to RetrievedItem format
-            retrieved_data = []
-            context_text = ""
+async def query_with_rag(self, plan_request: PlanRequest, collection_name: Optional[str] = None) -> 'PlanResponse':
+    """
+    Perform RAG query using PlanRequest, embed query, search Qdrant, and generate complete PlanResponse via LLM
+    """
+    print(plan_request)
+    try:
+        # 1. Create query string from PlanRequest - updated for new fields
+        destination = plan_request.destination or plan_request.destination_place or "unknown destination"
+        duration = plan_request.duration or plan_request.trip_duration_days or 1
+        budget = plan_request.trip_price or 0
+        
+        query_text = f"Trip from {plan_request.start_place} to {destination}"
+        
+        # Add new fields to query
+        if plan_request.travelDates:
+            query_text += f" on {plan_request.travelDates}"
+        if duration:
+            query_text += f" for {duration} days"
+        if budget:
+            query_text += f" with budget {budget}"
+        if plan_request.theme:
+            query_text += f" {plan_request.theme} themed trip"
+        if plan_request.interests:
+            query_text += f" interested in {', '.join(plan_request.interests)}"
+        if plan_request.budgetTier:
+            query_text += f" {plan_request.budgetTier} budget tier"
+        
+        # 2. Generate embedding for the query
+        query_embedding = self.embedding_model.encode(query_text, normalize_embeddings=True).tolist()
+        
+        # 3. Search Qdrant for similar content
+        collection = collection_name or self.collection_name
+        top_k = plan_request.top_k or self.top_k
+        
+        search_results = self.qdrant.search(
+            collection_name=collection,
+            query_vector=query_embedding,
+            limit=top_k,
+            with_payload=True
+        )
+        
+        # 4. Convert search results to RetrievedItem format
+        retrieved_data = []
+        context_text = ""
 
-            print(f"Search results: {search_results['result']}")
-            for result in search_results['result']:
-                retrieved_item = RetrievedItem(
-                    place_id="Unkown",
-                    place_name=result['payload'].get("place_name", "Unknown"),
-                    score=result['score'],
-                )
-                retrieved_data.append(retrieved_item)
-                context_text += f"\n{result['payload'].get('text', '')}"
+        print(f"Search results: {search_results['result']}")
+        for result in search_results['result']:
+            retrieved_item = RetrievedItem(
+                place_id=result.get('id', 'Unknown'),
+                place_name=result['payload'].get("place_name", "Unknown"),
+                score=result['score'],
+            )
+            retrieved_data.append(retrieved_item)
+            context_text += f"\n{result['payload'].get('text', '')}"
 
-            # 5. Create detailed prompt for LLM to generate structured response
-            llm_prompt = f"""
-            You are a travel planning assistant. Based on the trip request and travel context provided, generate a comprehensive trip plan in the exact JSON format specified below.
+        # 5. Create detailed prompt for LLM - updated with new fields
+        llm_prompt = f"""
+        You are a travel planning assistant. Based on the trip request and travel context provided, generate a comprehensive trip plan in the exact JSON format specified below.
 
-            Trip Request:
-            - From: {plan_request.start_place}
-            - To: {plan_request.destination_place}
-            - Duration: {plan_request.trip_duration_days} days
-            - Budget: {plan_request.trip_price}
-            - Context: {plan_request.trip_context}
-            - Group Size: {plan_request.group_size}
-            - Preferences: {plan_request.preferences}
+        Trip Request:
+        - From: {plan_request.start_place}
+        - To: {destination}
+        - Travel Dates: {plan_request.travelDates or 'Flexible'}
+        - Duration: {duration} days
+        - Budget: {budget} ({plan_request.budgetTier or 'Not specified'} tier)
+        - Group Size: {plan_request.groupSize} people
+        - Interests: {', '.join(plan_request.interests) if plan_request.interests else 'Not specified'}
+        - Theme: {plan_request.theme or 'General travel'}
+        - Transport Preference: {plan_request.transportPref or 'Any'}
+        - Stay Preference: {plan_request.stayPref or 'Any'}
+        - Legacy Context: {getattr(plan_request, 'trip_context', None) or 'None'}
 
-            Relevant Travel Context:
-            {context_text}
-            ***Don't Explain or add any additional text outside the JSON format***.
-            Generate a response in this EXACT JSON format (no additional text before or after):
-            {{
-                "tripOverview": "A comprehensive 2-3 paragraph overview of the entire trip",
-                "trip_plan": {{
-                    "overview": "Brief summary of the trip plan",
-                    "total_estimated_cost": estimated_total_cost_as_number,
-                    "steps": [
-                        {{
-                            "day": 1,
-                            "title": "Day 1 title",
-                            "description": "Detailed description of day 1 activities",
-                            "transport": {{
-                                "mode": "transportation method",
-                                "departure": "departure location",
-                                "arrival": "arrival location", 
-                                "duration_minutes": estimated_duration_in_minutes,
-                                "price": estimated_price,
-                                "details": "additional transport details"
-                            }},
-                            "booking_info": [{{"name": "name of place or transport that need to be booked before", "description": "description to explain user that this place need to be booked or not or can walk in"}}],
-                            "map_coordinates": {{"lat": latitude_number, "lon": longitude_number}},
-                            "images": ["url1", "url2"],
-                            "tips": ["tip1", "tip2", "tip3"],
-                        }}
-                    ]
+        Relevant Travel Context:
+        {context_text}
+        
+        ***Don't Explain or add any additional text outside the JSON format***.
+        Generate a response in this EXACT JSON format (no additional text before or after):
+        {{
+            "tripOverview": "A comprehensive 2-3 paragraph overview of the entire {duration}-day trip from {plan_request.start_place} to {destination}, highlighting the {plan_request.theme or 'travel'} theme and {', '.join(plan_request.interests) if plan_request.interests else 'general sightseeing'} interests",
+            "trip_plan": {{
+                "title": "Descriptive title for the {duration}-day {plan_request.theme or 'travel'} trip to {destination}",
+                "date": "{plan_request.travelDates or 'Flexible dates'}",
+                "timeline": [
+                    {{"t": "08:30", "detail": "Start of day activity"}},
+                    {{"t": "12:00", "detail": "Lunch break"}},
+                    {{"t": "14:00", "detail": "Afternoon activity"}},
+                    {{"t": "18:00", "detail": "Evening activity"}}
+                ],
+                "spots": [
+                    {{"name": "Location name", "time": "09:30 – 11:45", "notes": "Description and tips for this location"}},
+                    {{"name": "Another location", "time": "14:00 – 16:30", "notes": "More details and recommendations"}}
+                ],
+                "budget": {{
+                    "transport": estimated_transport_cost,
+                    "entrance": estimated_entrance_fees,
+                    "meals": estimated_meal_costs,
+                    "accommodation": estimated_accommodation_costs,
+                    "activities": estimated_activity_costs,
+                    "total": total_estimated_cost
+                }},
+                "permits": {{
+                    "needed": true_or_false,
+                    "notes": "Permit requirements and how to obtain them",
+                    "seasonal": "Seasonal considerations and restrictions"
+                }},
+                "safety": {{
+                    "registration": "Safety registration procedures",
+                    "checkins": "Check-in procedures and requirements",
+                    "sos": "Emergency procedures and protocols",
+                    "contacts": {{
+                        "ranger": {{"name": "Local ranger station name", "phone": "+66-XX-XXX-XXXX"}},
+                        "hospital": {{"name": "Nearest hospital name", "phone": "+66-XX-XXX-XXXX"}},
+                        "police": {{"name": "Local police station", "phone": "1155"}}
+                    }}
                 }}
             }}
-            Rules:
-            - Use the provided context to fill in details.
-            - Ensure all fields are filled with realistic and practical information.
-            - Use local currency for prices.
-            - DONT ADD ANY INLINE NOTE IN JSON
-            - In booking_info field, include a list of places in the day that need to be booked.
+        }}
+        Rules:
+        - Use the provided context to fill in details.
+        - Ensure all fields are filled with realistic and practical information.
+        - Use local currency for prices and consider the {plan_request.budgetTier or 'moderate'} budget tier.
+        - Accommodate {plan_request.groupSize} people in all recommendations.
+        - Focus on {plan_request.theme or 'general'} themed activities.
+        - Prioritize interests: {', '.join(plan_request.interests) if plan_request.interests else 'general sightseeing'}.
+        - Consider transport preference: {plan_request.transportPref or 'any'}.
+        - Consider accommodation preference: {plan_request.stayPref or 'any'}.
+        - DONT ADD ANY INLINE NOTE IN JSON
+        
+        ***Don't Explain or add any additional text outside the JSON format***.
+        Ensure the JSON is valid and well-structured.
+
+        Create {duration} days of detailed activities. Include realistic prices, coordinates, and practical tips. Make it specific to the destinations, theme, interests, and budget tier provided.
+        """
+        
+        # 6. Call LLM to generate structured trip plan
+        llm_response = await self.basic_query(user_prompt=llm_prompt, max_tokens=24048)
+        print(f"LLM Response: {llm_response}")
+        
+        # 7. Parse LLM response as JSON
+        try:
+            # Clean the response and parse JSON
+            json_str = llm_response.strip()
+            if json_str.startswith("```json"):
+                json_str = json_str[7:]
+            if json_str.endswith("```"):
+                json_str = json_str[:-3]
             
+            llm_data = json.loads(json_str)
+            print(f"LLM Data: {llm_data}")
             
-            ***Don't Explain or add any additional text outside the JSON format***.
-            Ensure the JSON is valid and well-structured.
+            # Convert to PlanResponse structure
+            trip_plan_data = llm_data.get("trip_plan", {})
 
-            Create {plan_request.trip_duration_days or 1} days of detailed activities. Include realistic prices, coordinates, and practical tips. Make it specific to the destinations and context provided.
-            """
-            
-            # 6. Call LLM to generate structured trip plan
-            llm_response = await self.basic_query(user_prompt=llm_prompt, max_tokens=24048)
-            print(f"LLM Response: {llm_response}")
-            # 7. Parse LLM response as JSON
-            try:
-                # Clean the response and parse JSON
-                json_str = llm_response.strip()
-                if json_str.startswith("```json"):
-                    json_str = json_str[7:]
-                if json_str.endswith("```"):
-                    json_str = json_str[:-3]
-                
-                llm_data = json.loads(json_str)
-                print(f"LLM Data: {llm_data}")
-                # Convert to PlanResponse structure
-                trip_plan_data = llm_data.get("trip_plan", {})
-                steps_data = trip_plan_data.get("steps", [])
-                
-                # Convert steps to PlanStep objects
-                plan_steps = []
-                for step in steps_data:
-                    transport_data = step.get("transport", {})
-                    transport = TransportInfo(
-                        mode=transport_data.get("mode"),
-                        departure=transport_data.get("departure"),
-                        arrival=transport_data.get("arrival"),
-                        duration_minutes=transport_data.get("duration_minutes"),
-                        price=transport_data.get("price"),
-                        details=transport_data.get("details")
-                    )
-                    
-                    plan_step = PlanStep(
-                        day=step.get("day"),
-                        title=step.get("title"),
-                        description=step.get("description"),
-                        transport=transport,
-                        booking_info=step.get("booking_info", []),
-                        map_coordinates=step.get("map_coordinates", {}),
-                        images=step.get("images", []),
-                        tips=step.get("tips", [])
-                    )
-                    plan_steps.append(plan_step)
-                
-                trip_plan = TripPlan(
-                    overview=trip_plan_data.get("overview", ""),
-                    total_estimated_cost=trip_plan_data.get("total_estimated_cost"),
-                    steps=plan_steps
+            # Parse timeline
+            timeline_data = trip_plan_data.get("timeline", [])
+            timeline = [Timeline(t=item["t"], detail=item["detail"]) for item in timeline_data]
+
+            # Parse spots
+            spots_data = trip_plan_data.get("spots", [])
+            spots = [Spot(name=item["name"], time=item["time"], notes=item["notes"]) for item in spots_data]
+
+            # Parse budget
+            budget_data = trip_plan_data.get("budget", {})
+            budget = Budget(
+                transport=budget_data.get("transport"),
+                entrance=budget_data.get("entrance"),
+                meals=budget_data.get("meals"),
+                accommodation=budget_data.get("accommodation"),
+                activities=budget_data.get("activities"),
+                total=budget_data.get("total")
+            )
+
+            # Parse permits
+            permits_data = trip_plan_data.get("permits", {})
+            permits = Permits(
+                needed=permits_data.get("needed", False),
+                notes=permits_data.get("notes", ""),
+                seasonal=permits_data.get("seasonal", "")
+            ) if permits_data else None
+
+            # Parse safety
+            safety_data = trip_plan_data.get("safety", {})
+            safety = None
+            if safety_data:
+                contacts_data = safety_data.get("contacts", {})
+                contacts = SafetyContacts(
+                    ranger=Contact(**contacts_data["ranger"]) if contacts_data.get("ranger") else None,
+                    hospital=Contact(**contacts_data["hospital"]) if contacts_data.get("hospital") else None,
+                    police=Contact(**contacts_data["police"]) if contacts_data.get("police") else None
                 )
-                
-                return PlanResponse(
-                    tripOverview=llm_data.get("tripOverview", ""),
-                    query_params=plan_request,
-                    retrieved_data=retrieved_data,
-                    trip_plan=trip_plan,
-                    meta={
-                        "status": "success",
-                        "query_text": query_text,
-                        "results_count": len(retrieved_data)
-                    }
-                )
-                
-            except json.JSONDecodeError as e:
-                print(f"Error parsing LLM JSON response: {e}")
-                print(f"LLM Response: {llm_response}")
-                
-                # Fallback: create basic response with LLM text
-                return PlanResponse(
-                    tripOverview=llm_response,
-                    query_params=plan_request,
-                    retrieved_data=retrieved_data,
-                    trip_plan=TripPlan(
-                        overview="Generated plan (parsing error)",
-                        total_estimated_cost=plan_request.trip_price,
-                        steps=[]
-                    ),
-                    meta={"status": "json_parse_error", "error": str(e)}
+                safety = Safety(
+                    registration=safety_data.get("registration", ""),
+                    checkins=safety_data.get("checkins", ""),
+                    sos=safety_data.get("sos", ""),
+                    contacts=contacts
                 )
+
+            trip_plan = TripPlan(
+                title=trip_plan_data.get("title", ""),
+                date=trip_plan_data.get("date", ""),
+                timeline=timeline,
+                spots=spots,
+                budget=budget,
+                permits=permits,
+                safety=safety
+            )
+
+            return PlanResponse(
+                tripOverview=llm_data.get("tripOverview", ""),
+                query_params=plan_request,
+                retrieved_data=retrieved_data,
+                trip_plan=trip_plan,
+                meta={
+                    "status": "success",
+                    "query_text": query_text,
+                    "results_count": len(retrieved_data),
+                    "theme": plan_request.theme,
+                    "interests": plan_request.interests,
+                    "budget_tier": plan_request.budgetTier,
+                    "group_size": plan_request.groupSize
+                }
+            )
             
-        except Exception as e:
-            print(f"Error in RAG query: {e}")
+        except json.JSONDecodeError as e:
+            print(f"Error parsing LLM JSON response: {e}")
+            print(f"LLM Response: {llm_response}")
+            
+            # Fallback: create basic response with LLM text
             return PlanResponse(
-                tripOverview=f"Error generating trip plan: {str(e)}",
+                tripOverview=llm_response,
                 query_params=plan_request,
-                retrieved_data=[],
-                trip_plan=TripPlan(overview="Error occurred", total_estimated_cost=0.0, steps=[]),
-                meta={"status": "error", "error": str(e)}
+                retrieved_data=retrieved_data,
+                trip_plan=TripPlan(
+                    overview="Generated plan (parsing error)",
+                    total_estimated_cost=budget,
+                    steps=[]
+                ),
+                meta={"status": "json_parse_error", "error": str(e)}
             )
         
+    except Exception as e:
+        print(f"Error in RAG query: {e}")
+        return PlanResponse(
+            tripOverview=f"Error generating trip plan: {str(e)}",
+            query_params=plan_request,
+            retrieved_data=[],
+            trip_plan=TripPlan(overview="Error occurred", total_estimated_cost=0.0, steps=[]),
+            meta={"status": "error", "error": str(e)}
+        )
+