Update tools and itinerary generation

app.py

@@ -12,11 +12,10 @@ load_dotenv()
 print("🔍 GOOGLE_MAPS_API_KEY found:", bool(os.getenv("GOOGLE_MAPS_API_KEY")))
 print("🔍 OPENAI_API_KEY found:", bool(os.getenv("OPENAI_API_KEY")))
 
-# ✅ Ensure LiteLLM knows you’re using OpenAI models
 os.environ["LITELLM_PROVIDER"] = "openai"
 os.environ["OPENAI_API_BASE"] = "https://api.openai.com/v1"
 
-# ✅ Confirm key is available
+# Confirm key is available
 if not os.getenv("OPENAI_API_KEY"):
     raise ValueError("Missing OPENAI_API_KEY")
 if not os.getenv("GOOGLE_MAPS_API_KEY"):
@@ -56,7 +55,7 @@ retriever_agent = Agent(
     tools=[maps_tool],
     llm="gpt-4o-mini",
     temperature=0.2,
-    verbose=True
+    verbose=False
 )
 
 weather_agent = Agent(
@@ -66,7 +65,7 @@ weather_agent = Agent(
     tools=[weather_tool],
     llm="gpt-4o-mini",
     temperature=0.2,
-    verbose=True
+    verbose=False
 )
 
 route_agent = Agent(
@@ -74,9 +73,9 @@ route_agent = Agent(
     goal="Calculate walking, driving, cycling, public transport times between trip locations to optimize daily routes.",
     backstory="A navigtion expert skilled at minimizing time and building efficient routes.",
     tools=[route_tool],
-    llm="gpt-5-mini",
+    llm="gpt-4o-mini",
     temperature=0.25,
-    verbose=True
+    verbose=False
 )
 
 planner_agent = Agent(
@@ -91,7 +90,7 @@ planner_agent = Agent(
     temperature=0.3,
     output_schema=ItineraryModel,
     reasoning=True,
-    verbose=True
+    verbose=False
 )
 
 writer_agent = Agent(
@@ -108,15 +107,20 @@ writer_agent = Agent(
     ),
     llm="gpt-4o",
     temperature=0.7,
-    verbose=True
+    verbose=False
 )
 
 # Core logic
 def generate_itinerary(location, start_date, end_date, preferences, transport_modes ):
-    trip_duration_days = len(expand_dates(start_date, end_date))
-    transport_modes_str = ', '.join(transport_modes) if isinstance(transport_modes, list) else transport_modes
+    days, date_list = expand_dates(start_date, end_date)
+    trip_duration_days = days
+    
+    if isinstance(transport_modes, str):
+        transport_modes = [transport_modes]
+    
+    transport_modes_str = ", ".join(transport_modes)
 
-#Define the tasks
+    #Define the tasks
 
     retrieval_task = Task(
         description=f"Gather restaurants, landmarks, and activities for the trip in {location}.",
@@ -133,13 +137,18 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
     )
 
     route_task = Task(
-        description=(f"Using the candidate places retrieved, compute optimal routes using the following transport modes: {transport_modes_str}. "
-            "Use walking for short distances (<2km) and public transport for longer ones. "
-            "Return route data including mode, distance, and estimated time."
+        description=(
+            f"From the RetrieverTask output, build a destinations list (strings) using the "
+            f"top 10 places across categories (prefer formatted address if present, else name + city). "
+            f"Use origin='{location}'. Then call Route Planner Tool exactly once with:\n"
+            f"- origin: '{location}'\n"
+            f"- destinations: <that list>\n"
+            f"- modes: {transport_modes}\n"
+            f"Return the tool output as JSON."
         ),
-        expected_output="A list of routes with mode, distance and duration in minutes.",
+        expected_output="A JSON list of routes with mode, distance_km, duration_min, destination.",
         agent=route_agent,
-        inputs = {"mode": {transport_modes_str}}
+        context=[retrieval_task]
     )
 
     planning_task = Task(
@@ -174,9 +183,40 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
             "   - weather_forecast (if applicable)\n"
             "   - distance_from_prev (km)\n"
             "   - travel_duration_min (if applicable)\n\n"
-            "🔟 Return a structured JSON object grouped by day with weather, schedule, and reasoning "
-            "following the ItineraryModel format. Ensure the JSON output strictly follows the ItineraryModel schema fields "
-            "(days[], events[], metadata, reasoning)."
+            "🔟 Output format (MUST match ItineraryModel exactly):\n"
+            "{\n"
+            '  "destination": "<city/region>",\n'
+            '  "trip_duration_days": <int>,\n'
+            '  "transport_mode": ["walking", "public_transport", "driving", "cycling"],\n'
+            '  "start_date": "YYYY-MM-DD",\n'
+            '  "end_date": "YYYY-MM-DD",\n'
+            '  "traveler_profile": "<short preference summary>",\n'
+            '  "days": [\n'
+            "    {\n"
+            '      "date": "YYYY-MM-DD",\n'
+            '      "weather_summary": "<string>",\n'
+            '      "summary": "<string>",\n'
+            '      "activities": [\n'
+            "        {\n"
+            '          "name": "<place name>",\n'
+            '          "category": "<breakfast|lunch|dinner|museum|park|landmark|...>",\n'
+            '          "start_time": "HH:MM",\n'
+            '          "end_time": "HH:MM",\n'
+            '          "location": "<address>",\n'
+            '          "map_url": "<optional>",\n'
+            '          "rating": <optional float>,\n'
+            '          "reasoning": "<optional>",\n'
+            '          "weather_forecast": "<optional>",\n'
+            '          "distance_from_prev": <optional float>,\n'
+            '          "duration_minutes": <optional int>\n'
+            "        }\n"
+            "      ]\n"
+            "    }\n"
+            "  ],\n"
+            '  "total_distance_km": <optional float>,\n'
+            '  "notes": "<optional>"\n'
+            "}\n"
+            "⚠️ Use field name 'activities' (NOT events). Use 'duration_minutes' (NOT travel_duration_min)."
         ),
         expected_output="A structured JSON itinerary with complete metadata and travel-aware timestamps for each activity.",
         context=[retrieval_task, weather_task, route_task],
@@ -190,9 +230,9 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
         description=(
             "You are a professional travel writer. Given a structured itinerary JSON with detailed fields "
             "(rating, reasoning, distance_from_prev, weather_forecast), write an engaging Markdown itinerary.\n\n"
-            "Make sure the itinerary is covering the period {start_date} to {end_date}.\n\n"
+            f"Make sure the itinerary is covering the period {start_date} to {end_date}.\n\n"
             "At the top of the Markdown output, include a summary line like:\n"
-            "'**Trip Dates:** {start_date} → {end_date} \n"
+            f"'**Trip Dates:** {start_date} → {end_date} \n"
             "Each day must include:\n"
             "- The date and weather summary from the JSON.\n"
             "- Chronological itinerary entries with start and end times.\n"
@@ -229,15 +269,10 @@ def generate_itinerary(location, start_date, end_date, preferences, transport_mo
     })
 
     # Safely extract the result
-    if hasattr(writing_task.output, "result"):
-        markdown_itinerary = writing_task.output.result
-    else:
-        markdown_itinerary = str(writing_task.output) if writing_task.output else "⚠️ No Markdown itinerary generated."
-
-    # Ensure final output is always a string
-    if not isinstance(markdown_itinerary, str):
-        markdown_itinerary = str(markdown_itinerary)
-
+    markdown_itinerary = (
+        result if isinstance(result, str)
+        else getattr(result, "raw", None) or str(result)
+    )
     return markdown_itinerary
 
 # Gradio UI

models/itinerary_model.py

@@ -14,10 +14,10 @@ class Activity(BaseModel):
     rating: Optional[float] = Field(None, description="Average rating score (if available)")
     reasoning: Optional[str] = Field(None, description="Reason why this activity was selected")
     weather_forecast: Optional[str] = Field(None, description="Expected weather at this time/location")
+    travel_mode: Optional[str] = Field(None, description="Mode used to reach this activity (walking/public_transport/driving/cycling)")
     distance_from_prev: Optional[float] = Field(None, description="Distance from previous activity in kilometers")
     duration_minutes: Optional[int] = Field(None, description="Automatically computed duration in minutes.")
 
-
 # 📅 Daily itinerary
 class DayPlan(BaseModel):
     date: str = Field(..., description="Date of the plan, ISO format YYYY-MM-DD")
@@ -25,12 +25,11 @@ class DayPlan(BaseModel):
     summary: Optional[str] = Field(None, description="High-level overview of the day")
     activities: List[Activity] = Field(..., description="Ordered list of daily activities and meals")
 
-
 # 🌍 Entire trip plan
 class ItineraryModel(BaseModel):
     destination: str = Field(..., description="City or region of the trip")
     trip_duration_days: int = Field(..., description="Number of days in the itinerary")
-    transport_mode: Optional[str] = Field(None, description="User's preferred mode of transport (walking, public_transport, driving)")
+    transport_modes: List[str] = Field(default_factory=list, description="Allowed modes: walking, public_transport, driving, cycling")
     start_date: Optional[str] = Field(None, description="Trip start date (ISO format)")
     end_date: Optional[str] = Field(None, description="End date (YYYY-MM-DD).")
     traveler_profile: Optional[str] = Field(None, description="Short description of traveler preferences.")

tools/google_maps_tool.py

@@ -1,9 +1,9 @@
 import os
 import httpx
 from typing import List, Dict, Optional
-from crewai_tools import RagTool
+from crewai.tools import BaseTool
 
-class GoogleMapsTool(RagTool):
+class GoogleMapsTool(BaseTool):
     """
     CrewAI compatible toool for querying Google Places Api
     """

tools/route_planner_tool.py

@@ -1,10 +1,10 @@
 import os
 import httpx
 from typing import List, Dict, Union, Optional
-from crewai_tools.tools import RagTool
+from crewai.tools import BaseTool
 
 
-class RoutePlannerTool(RagTool):
+class RoutePlannerTool(BaseTool):
     """
     CrewAI-compatible tool for computing optimal routes between locations
     using Google Directions API with multi-mode transport support.
@@ -47,49 +47,57 @@ class RoutePlannerTool(RagTool):
         base_url = "https://maps.googleapis.com/maps/api/directions/json"
         results = []
 
-        for dest in destinations[:max_results]:
-            best_route = None
-
-            # Try walking first
-            if "walking" in modes:
-                walk_params = {"origin": origin, "destination": dest, "mode": "walking", "key": api_key}
-                walk_data = self._fetch_route(base_url, walk_params)
-                if walk_data:
-                    best_route = {**walk_data, "mode": "walking"}
-
-            # Try public transport if walking route > 2km or not available
-            if ("public_transport" in modes or "transit" in modes) and (
-                not best_route or best_route["distance_km"] > 2
-            ):
-                transit_params = {
-                    "origin": origin,
-                    "destination": dest,
-                    "mode": "transit",
-                    "transit_mode": "bus|subway|train|tram",
-                    "key": api_key
-                }
-                transit_data = self._fetch_route(base_url, transit_params)
-                if transit_data:
-                    if not best_route or transit_data["duration_min"] < best_route["duration_min"]:
-                        best_route = {**transit_data, "mode": "public_transport"}
-
-            # Try driving if included and others unavailable
-            if "driving" in modes and not best_route:
-                drive_params = {"origin": origin, "destination": dest, "mode": "driving", "key": api_key}
-                drive_data = self._fetch_route(base_url, drive_params)
-                if drive_data:
-                    best_route = {**drive_data, "mode": "driving"}
-
-            if best_route:
-                best_route["destination"] = dest
-                results.append(best_route)
-
-        return results
-
-    def _fetch_route(self, base_url: str, params: Dict) -> Optional[Dict]:
+        with httpx.Client(timeout=20.0) as client:
+            for dest in destinations[:max_results]:
+                best_route = None
+
+                # Try walking first
+                if "walking" in modes:
+                    walk_params = {"origin": origin, "destination": dest, "mode": "walking", "key": api_key}
+                    walk_data = self._fetch_route(base_url, walk_params)
+                    if walk_data:
+                        best_route = {**walk_data, "mode": "walking"}
+
+                # Try public transport if walking route > 2km or not available
+                if ("public_transport" in modes or "transit" in modes) and (
+                    not best_route or best_route["distance_km"] > 2
+                ):
+                    transit_params = {
+                        "origin": origin,
+                        "destination": dest,
+                        "mode": "transit",
+                        "transit_mode": "bus|subway|train|tram",
+                        "key": api_key
+                    }
+                    transit_data = self._fetch_route(base_url, transit_params)
+                    if transit_data:
+                        if not best_route or transit_data["duration_min"] < best_route["duration_min"]:
+                            best_route = {**transit_data, "mode": "public_transport"}
+            
+                # Cycling if included
+                if "cycling" in modes and not best_route:
+                    bike_params = {"origin": origin, "destination": dest, "mode": "bicycling", "key": api_key}
+                    bike_data = self._fetch_route(client, base_url, bike_params)
+                    if bike_data:
+                        best_route = {**bike_data, "mode": "cycling"}
+
+                # Try driving if included and others unavailable
+                if "driving" in modes and not best_route:
+                    drive_params = {"origin": origin, "destination": dest, "mode": "driving", "key": api_key}
+                    drive_data = self._fetch_route(base_url, drive_params)
+                    if drive_data:
+                        best_route = {**drive_data, "mode": "driving"}
+
+                if best_route:
+                    best_route["destination"] = dest
+                    results.append(best_route)
+
+            return results
+
+    def _fetch_route(self, client: httpx.Client, base_url: str, params: Dict) -> Optional[Dict]:
         """Fetch and parse route data from Google Directions API."""
         try:
-            response = httpx.get(base_url, params=params, timeout=20.0)
+            response = client.get(base_url, params=params, timeout=20.0)
             data = response.json()
 
             if data["status"] != "OK" or not data.get("routes"):

tools/semantic_ranking_tool.py

@@ -2,13 +2,13 @@ import os
 import numpy as np
 from typing import List, Dict, Any, Optional
 from openai import OpenAI
-from crewai_tools import RagTool
+from crewai.tools import BaseTool
 from dotenv import load_dotenv
 
 load_dotenv()
 os.environ["CHROMA_OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
 
-class SemanticRankingTool(RagTool):
+class SemanticRankingTool(BaseTool):
     """
     CrewAI-compatible tool that semantically ranks and filters candidate places
     based on user preferences, ratings, popularity, and optional distance.

tools/weather_tool.py

@@ -1,5 +1,5 @@
 import httpx
-from crewai_tools import RagTool
+from crewai.tools import BaseTool
 from pydantic import BaseModel, Field
 from typing import Dict, Optional, Any, Type
 from datetime import date, timedelta
@@ -11,10 +11,11 @@ class WeatherToolInput(BaseModel):
     city: Optional[str] = Field(None, description="City name, e.g. 'Florence, Italy'.")
     latitude: Optional[float] = Field(None, description="Latitude in decimal degrees.")
     longitude: Optional[float] = Field(None, description="Longitude in decimal degrees.")
-
+    start_date: Optional[str] = Field(None, description="YYYY-MM-DD")
+    end_date: Optional[str] = Field(None, description="YYYY-MM-DD")
 
 # 🌤️ CrewAI Tool
-class WeatherTool(RagTool):
+class WeatherTool(BaseTool):
     """Fetches multi-day weather forecasts using the Open-Meteo API."""
 
     name: str = "Weather Forecast Tool"
@@ -65,6 +66,10 @@ class WeatherTool(RagTool):
             "timezone": "auto",
         }
 
+        if start_date and end_date:
+            params["start_date"] = start_date
+            params["end_date"] = end_date
+
         resp = httpx.get(base_url, params=params, timeout=10.0)
         data = resp.json()
         days = data.get("daily", {})