Upload 7 files

api.py

@@ -0,0 +1,154 @@
+from typing import Dict, Tuple, Optional
+import requests
+import json
+import time
+def geocode_address_nominatim(address: str) -> Optional[Tuple[float, float]]:
+    """
+    Geocoding using Nominatim (OpenStreetMap)
+    """
+    url = "https://nominatim.openstreetmap.org/search"
+    
+    params = {
+        "q": address,
+        "format": "json",
+        "limit": 1
+    }
+    
+    headers = {
+        "User-Agent": "DeliveryOptimizationSystem/1.0" 
+    }
+    
+    try:
+        time.sleep(1)  
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data:
+            return (float(data[0]["lat"]), float(data[0]["lon"]))
+        return None
+    except Exception as e:
+        print(f"Geocoding error: {e}")
+        return None
+
+
+def get_route_osrm(origin_coords: Tuple[float, float], 
+                   dest_coords: Tuple[float, float]) -> Optional[Dict]:
+    """
+    Routing using OSRM (OpenStreetMap Routing Machine
+    """
+    lat1, lon1 = origin_coords
+    lat2, lon2 = dest_coords
+    
+    url = f"http://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}"
+    
+    params = {
+        "overview": "full",
+        "geometries": "geojson",
+        "steps": "true",
+        "annotations": "true"
+    }
+    
+    try:
+        response = requests.get(url, params=params, timeout=15)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("code") == "Ok" and data.get("routes"):
+            route = data["routes"][0]
+            return {
+                "distance_km": route["distance"] / 1000,
+                "duration_min": route["duration"] / 60,
+                "geometry": route["geometry"],
+                "steps": route["legs"][0].get("steps", [])
+            }
+        return None
+    except Exception as e:
+        print(f"Routing error: {e}")
+        return None
+
+
+def get_alternative_routes_osrm(origin_coords: Tuple[float, float], 
+                                dest_coords: Tuple[float, float]) -> list:
+    """
+    Get multiple route options
+    """
+    lat1, lon1 = origin_coords
+    lat2, lon2 = dest_coords
+    
+    url = f"http://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}"
+    
+    params = {
+        "alternatives": "true", 
+        "steps": "true",
+        "overview": "full"
+    }
+    
+    try:
+        response = requests.get(url, params=params, timeout=15)
+        data = response.json()
+        
+        if data.get("code") == "Ok":
+            routes = []
+            for route in data.get("routes", []):
+                routes.append({
+                    "distance_km": route["distance"] / 1000,
+                    "duration_min": route["duration"] / 60
+                })
+            return routes
+        return []
+    except:
+        return []
+
+def get_detailed_route_with_instructions(origin_coords: Tuple[float, float], 
+                                         dest_coords: Tuple[float, float]) -> Optional[Dict]:
+    """
+    Get detailed route with turn-by-turn instructions and road names
+    """
+    lat1, lon1 = origin_coords
+    lat2, lon2 = dest_coords
+    
+    url = f"http://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}"
+    
+    params = {
+        "alternatives": "true",
+        "steps": "true",
+        "overview": "full",
+        "geometries": "geojson",
+        "annotations": "true"
+    }
+    
+    try:
+        response = requests.get(url, params=params, timeout=15)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("code") == "Ok" and data.get("routes"):
+            all_routes = []
+            
+            for route_idx, route in enumerate(data.get("routes", [])):
+                route_info = {
+                    "route_number": route_idx + 1,
+                    "distance_km": route["distance"] / 1000,
+                    "duration_min": route["duration"] / 60,
+                    "instructions": []
+                }
+                
+                for leg in route.get("legs", []):
+                    for step in leg.get("steps", []):
+                        instruction = {
+                            "distance_km": step["distance"] / 1000,
+                            "duration_min": step["duration"] / 60,
+                            "instruction": step.get("maneuver", {}).get("type", "continue"),
+                            "road_name": step.get("name", "Unnamed road"),
+                            "direction": step.get("maneuver", {}).get("modifier", "")
+                        }
+                        route_info["instructions"].append(instruction)
+                
+                all_routes.append(route_info)
+            
+            return all_routes
+        return None
+    except Exception as e:
+        print(f"Detailed routing error: {e}")
+        return None

app.py

@@ -0,0 +1,243 @@
+import gradio as gr
+from deep_agent import agent
+import os
+import re
+
+os.makedirs("static", exist_ok=True)
+
+def process_delivery_query(query):
+    """Process delivery queries and return text + map"""
+    if not query.strip():
+        return "<div style='color:#ff6b6b; padding:20px; background:#ffe0e0; border-radius:8px;'>Please enter a query</div>", None
+    
+    try:
+        result = agent.invoke({
+            "messages": [{"role": "user", "content": query}]
+        })
+        
+        response_text = ""
+        if isinstance(result, dict) and "messages" in result:
+            for message in reversed(result["messages"]):
+                if getattr(message, "type", None) == "ai" and getattr(message, "content", None):
+                    response_text = message.content
+                    break
+        else:
+            response_text = str(result)
+
+        map_file_path = None
+        map_url_pattern = r'/view-map/([^\s\)]+\.html)'
+        map_match = re.search(map_url_pattern, response_text)
+        
+        if map_match:
+            map_filename = map_match.group(1)
+            map_file_path = f"static/{map_filename}"
+        elif os.path.exists("static"):
+            map_files = [f for f in os.listdir("static") if f.startswith("route_") and f.endswith(".html")]
+            if map_files:
+                map_files.sort(key=lambda x: os.path.getmtime(os.path.join("static", x)), reverse=True)
+                map_file_path = f"static/{map_files[0]}"
+
+        response_text = re.sub(map_url_pattern, '', response_text)
+        response_text = re.sub(r'INTERACTIVE MAP:.*?\n', '', response_text)
+        
+        html_response = response_text
+        html_response = html_response.replace('PRIMARY ROUTE:', '<h3 style="color:#667eea; margin-top:25px; border-left:4px solid #667eea; padding-left:15px;">PRIMARY ROUTE</h3>')
+        html_response = html_response.replace('ROUTE COMPARISON:', '<h3 style="color:#667eea; margin-top:25px; border-left:4px solid #667eea; padding-left:15px;">ROUTE COMPARISON</h3>')
+        html_response = html_response.replace('Cost Estimate', '<h3 style="color:#764ba2; margin-top:25px; border-left:4px solid #764ba2; padding-left:15px;">Cost Estimate</h3>')
+        html_response = html_response.replace('Traffic Analysis', '<h3 style="color:#f093fb; margin-top:25px; border-left:4px solid #f093fb; padding-left:15px;">Traffic Analysis</h3>')
+        html_response = html_response.replace('Route Analysis', '<h3 style="color:#667eea; margin-top:25px; border-left:4px solid #667eea; padding-left:15px;">Route Analysis</h3>')
+        
+        html_response = html_response.replace('\n\n', '<br><br>')
+        html_response = html_response.replace('\n', '<br>')
+        html_response = f"<div style='font-family: system-ui; line-height:1.8; color:#333; padding:20px;'>{html_response}</div>"
+
+        return html_response, map_file_path
+
+    except Exception as e:
+        error_html = f"""
+        <div style='padding:25px; background:#ffe0e0; border-left:5px solid #ff6b6b; border-radius:10px;'>
+            <h3 style='color:#ff6b6b; margin:0 0 15px 0;'>Error Occurred</h3>
+            <p style='margin:0 0 10px 0; color:#666;'><strong>Error:</strong> {str(e)}</p>
+            <div style='margin-top:15px; padding:15px; background:#fff; border-radius:8px;'>
+                <p style='margin:0; font-size:14px; color:#999;'>
+                    <strong>Tips:</strong><br>
+                    - Use full city names: "Mumbai, Maharashtra, India"<br>
+                    - Include country for international routes<br>
+                    - Check spelling of location names
+                </p>
+            </div>
+        </div>
+        """
+        return error_html, None
+
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="purple",
+    ),
+    title="Delivery Optimization Agent",
+    css="""
+        body, html {
+            margin: 0;
+            padding: 0;
+            width: 100%;
+            overflow-x: hidden;
+        }
+        .gradio-container {
+            max-width: 100% !important;
+            width: 100% !important;
+            padding: 0 !important;
+            margin: 0 auto !important;
+        }
+        .block {
+            width: 100% !important;
+        }
+        #root > div {
+            width: 100% !important;
+        }
+    """
+) as demo:
+    
+    gr.HTML("""
+    <div style='
+        text-align: center;
+        padding: 30px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        color: white;
+        margin-bottom: 30px;
+        box-shadow: 0 10px 30px rgba(102, 126, 234, 0.3);
+    '>
+        <h1 style='margin:0; font-size:2.8em; font-weight:700;'>
+            Delivery Optimization Agent
+        </h1>
+        <p style='margin:15px 0 0 0; font-size:1.3em; opacity:0.95; font-weight:300;'>
+            Real-time Route Planning | Cost Analysis | Traffic Intelligence
+        </p>
+        <p style='margin:10px 0 0 0; font-size:1em; opacity:0.85;'>
+            Powered by SparkBrains
+        </p>
+    </div>
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("### Enter Your Delivery Query")
+            
+            query_input = gr.Textbox(
+                label="",
+                placeholder="Example: Plan a delivery route from Mumbai, Maharashtra to Pune, Maharashtra with 500kg cargo",
+                lines=6,
+                show_label=False
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button(
+                    "Optimize Delivery", 
+                    variant="primary", 
+                    size="lg",
+                    scale=4
+                )
+                clear_btn = gr.ClearButton(
+                    [query_input], 
+                    value="Clear",
+                    size="lg",
+                    scale=1
+                )
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            gr.Markdown("### Route Analysis")
+            output = gr.HTML(label="", show_label=False)
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### Interactive Map")
+            map_output = gr.HTML(
+                label="",
+                show_label=False,
+                value="<div style='padding:40px; text-align:center; color:#999; background:#f8f9fa; border-radius:10px; min-height:400px; display:flex; align-items:center; justify-content:center;'><div><p>Map will appear here after route planning</p></div></div>"
+            )
+    
+    def process_and_display(query):
+        """Process query and return both text and map"""
+        text_result, map_path = process_delivery_query(query)
+        
+        if map_path and os.path.exists(map_path):
+            with open(map_path, 'r', encoding='utf-8') as f:
+                map_html = f.read()
+            
+            map_display = f"""
+            <div style='width:100%; height:600px; border-radius:10px; overflow:hidden; box-shadow:0 4px 6px rgba(0,0,0,0.1);'>
+                <iframe srcdoc='{map_html.replace("'", "&apos;")}' 
+                        style='width:100%; height:100%; border:none;'>
+                </iframe>
+            </div>
+            """
+            return text_result, map_display
+        else:
+            no_map = """
+            <div style='padding:40px; text-align:center; color:#999; background:#f8f9fa; border-radius:10px; min-height:400px; display:flex; align-items:center; justify-content:center;'>
+                <div>
+                    <p>No map available for this query</p>
+                </div>
+            </div>
+            """
+            return text_result, no_map
+    
+    submit_btn.click(
+        fn=process_and_display,
+        inputs=query_input,
+        outputs=[output, map_output]
+    )
+    
+    gr.Markdown("### Try These Example Queries")
+    gr.Examples(
+        examples=[
+            "Plan route from Delhi, India to Jaipur, Rajasthan, India",
+            "Calculate delivery cost for 200kg package, distance 150km, duration 180 minutes",
+            "Check traffic conditions between Bangalore, Karnataka and Chennai, Tamil Nadu",
+            "Find optimal route from Mumbai, Maharashtra to Pune, Maharashtra with 500kg cargo",
+            "What's the best route from Kolkata to Bhubaneswar?",
+        ],
+        inputs=query_input,
+        label=""
+    )
+    
+    gr.HTML("""
+    <div style='margin-top:30px; padding:25px; background:#f8f9fa; border-radius:15px;'>
+        <h3 style='margin:0 0 20px 0; color:#333;'>Features</h3>
+        <div style='display:grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap:15px;'>
+            <div style='padding:15px; background:white; border-radius:10px; border-left:4px solid #667eea;'>
+                <strong>Interactive Maps</strong>
+                <p style='margin:5px 0 0 0; font-size:0.9em; color:#666;'>Visual turn-by-turn directions</p>
+            </div>
+            <div style='padding:15px; background:white; border-radius:10px; border-left:4px solid #764ba2;'>
+                <strong>Cost Optimization</strong>
+                <p style='margin:5px 0 0 0; font-size:0.9em; color:#666;'>Real-world pricing estimates</p>
+            </div>
+            <div style='padding:15px; background:white; border-radius:10px; border-left:4px solid #f093fb;'>
+                <strong>Traffic Analysis</strong>
+                <p style='margin:5px 0 0 0; font-size:0.9em; color:#666;'>Live traffic patterns</p>
+            </div>
+            <div style='padding:15px; background:white; border-radius:10px; border-left:4px solid #667eea;'>
+                <strong>Route Comparison</strong>
+                <p style='margin:5px 0 0 0; font-size:0.9em; color:#666;'>Multiple route options</p>
+            </div>
+        </div>
+    </div>
+    """)
+    
+    gr.Markdown("---")
+    gr.Markdown(
+        "<div style='text-align:center; color:#999; font-size:0.9em;'>"
+        "Built with DeepAgents | LangChain | Groq | OpenStreetMap<br>"
+        "Ready for Multi-Agent Hub Integration"
+        "</div>"
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

deep_agent.py

@@ -0,0 +1,39 @@
+from deepagents import create_deep_agent
+from langchain_groq import ChatGroq
+from sub_agents import route_agent, cost_agent, traffic_agent, coordinator
+from tools import route_tool, cost_tool, traffic_tool
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+llm = ChatGroq(
+    model="llama-3.3-70b-versatile",
+    api_key=GROQ_API_KEY,
+    temperature=0.1,
+)
+
+agent = create_deep_agent(
+    model=llm,
+    tools=[route_tool, cost_tool, traffic_tool],
+    subagents=[route_agent, cost_agent, traffic_agent, coordinator],
+    system_prompt="""
+    You are a real-world delivery optimization system:
+    - OpenStreetMap (OSRM) for routing
+    - Nominatim for geocoding
+    - Real traffic patterns
+
+    Process:
+    1. If a map URL is provided (INTERACTIVE MAP), keep it prominently visible
+      near the top of your response for easy user access.
+    2. Calculate real-world costs
+    3. Analyze current traffic
+    4. Provide actionable recommendation
+
+    CRITICAL: Always include the map URL.
+    
+    All numeric parameters must be numbers (not strings).
+    """,
+)

requirements.txt

@@ -0,0 +1,8 @@
+gradio
+langchain-groq
+langchain-core
+deepagents
+pydantic
+requests
+folium
+python-dotenv

schema.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+
+class RouteInput(BaseModel):
+    origin: str = Field(description="Starting location (address or city)")
+    destination: str = Field(description="Destination location (address or city)")
+
+
+class CostInput(BaseModel):
+    distance_km: float = Field(description="Distance in kilometers")
+    weight_kg: float = Field(description="Package weight in kilograms")
+    duration_min: float = Field(description="Estimated duration in minutes")
+
+
+class TrafficInput(BaseModel):
+    origin: str = Field(description="Origin location")
+    destination: str = Field(description="Destination location")

sub_agents.py

@@ -0,0 +1,64 @@
+from deepagents.middleware.subagents import SubAgent
+from tools import route_tool, cost_tool, traffic_tool
+
+route_agent = SubAgent(
+    name="RealRouteAgent",
+    description="Plans routes using real OpenStreetMap data",
+    system_prompt="""
+    You are a route planning expert using real-world OpenStreetMap data.
+    Use the 'real_route_planner' tool with city names or addresses and detailed routes with direction.
+    Examples: "Delhi, India", "Mumbai, Maharashtra", "123 Main St, Bangalore"
+    Provide clear routing information with distances and times.
+    """,
+    tools=[route_tool],
+)
+
+cost_agent = SubAgent(
+    name="RealCostAgent",
+    description="Calculates costs with real-world pricing",
+    system_prompt="""
+    You are a cost analysis expert. Use 'real_cost_optimizer' tool.
+    CRITICAL: Pass numbers without quotes:
+    - distance_km: 50.5 (NOT "50.5")
+    - weight_kg: 100.0 (NOT "100")
+    - duration_min: 120.0 (NOT "120")
+    Explain cost breakdown clearly.
+    """,
+    tools=[cost_tool],
+)
+
+traffic_agent = SubAgent(
+    name="RealTrafficAgent",
+    description="Analyzes traffic using real patterns",
+    system_prompt="""
+    You are a traffic analysis expert. Use 'real_traffic_analyzer' tool.
+    Provide insights on current traffic conditions and best departure times.
+    Consider weather impacts and time-of-day patterns.
+    """,
+    tools=[traffic_tool],
+)
+
+coordinator = SubAgent(
+    name="Coordinator",
+    description="Synthesizes all information",
+    system_prompt="""
+    You are the delivery coordinator. Combine route, cost, and traffic info.
+    
+    IMPORTANT MAP LINK FORMATTING:
+    - When you receive a map URL like "/view-map/route_X_Y.html", format it as:
+      "VIEW INTERACTIVE MAP: [CLICK HERE](/view-map/route_X_Y.html)"
+    - Place this map link at the TOP of your response in a prominent way
+    - Make it clear and obvious that users can click on it
+    
+    Your response structure should be:
+    1. nteractive Map Link (first and prominent)
+    2. Route Summary (distance, duration)
+    3. Dont give any detailed directions.
+    4. Cost Breakdown
+    5. Traffic Conditions
+    6. Final Recommendations
+    
+    Present information clearly and keep the map link easily accessible.
+    Never hide the map link in the middle of text - make it stand out!
+    """,
+)

tools.py

@@ -0,0 +1,403 @@
+from langchain_core.tools import StructuredTool
+from schema import RouteInput,CostInput,TrafficInput
+from typing import Tuple,Dict
+from datetime import datetime
+import time
+import folium
+import os
+
+from api  import geocode_address_nominatim,get_route_osrm,get_alternative_routes_osrm, get_detailed_route_with_instructions
+
+def estimate_traffic_from_time() -> float:
+    """
+    Estimate traffic based on time of day
+    Uses typical traffic patterns
+    """
+    current_hour = datetime.now().hour
+    
+    if 7 <= current_hour <= 10:  
+        return 1.5
+    elif 17 <= current_hour <= 19: 
+        return 1.6
+    elif 12 <= current_hour <= 14: 
+        return 1.2
+    elif 0 <= current_hour <= 5: 
+        return 0.8
+    else:
+        return 1.0
+
+REAL_VEHICLES = [
+    {
+        "id": "BIKE-001",
+        "type": "Motorcycle",
+        "capacity_kg": 30,
+        "fuel_cost_per_km": 2.5,
+        "speed_kmph": 40,
+        "available": True
+    },
+    {
+        "id": "VAN-001",
+        "type": "Small Van",
+        "capacity_kg": 500,
+        "fuel_cost_per_km": 8.0,
+        "speed_kmph": 50,
+        "available": True
+    },
+    {
+        "id": "TRUCK-001",
+        "type": "Light Truck",
+        "capacity_kg": 2000,
+        "fuel_cost_per_km": 15.0,
+        "speed_kmph": 45,
+        "available": True
+    },
+    {
+        "id": "TRUCK-002",
+        "type": "Heavy Truck",
+        "capacity_kg": 5000,
+        "fuel_cost_per_km": 25.0,
+        "speed_kmph": 40,
+        "available": True
+    },
+]
+
+def format_route_instructions(route_data: Dict) -> str:
+    """
+    Format route instructions in readable format
+    """
+    if not route_data:
+        return "No route instructions available"
+    
+    output = f"\nRoute {route_data['route_number']}:\n"
+    output += f"Total Distance: {route_data['distance_km']:.1f} km\n"
+    output += f"Total Duration: {route_data['duration_min']:.0f} minutes\n"
+    output += "\nTurn-by-Turn Directions:\n"
+    output += "-" * 50 + "\n"
+    
+    cumulative_distance = 0
+    for idx, step in enumerate(route_data['instructions'], 1):
+        cumulative_distance += step['distance_km']
+        
+        instruction_type = step['instruction']
+        direction = step['direction']
+        
+        if instruction_type == "depart":
+            action = "Start"
+        elif instruction_type == "arrive":
+            action = "Arrive at destination"
+        elif instruction_type == "turn":
+            action = f"Turn {direction}" if direction else "Turn"
+        elif instruction_type == "new name":
+            action = "Continue onto"
+        elif instruction_type == "roundabout":
+            action = "Take roundabout"
+        elif instruction_type == "merge":
+            action = f"Merge {direction}" if direction else "Merge"
+        else:
+            action = instruction_type.replace("_", " ").capitalize()
+        
+        road_name = step['road_name']
+        distance = step['distance_km']
+        
+        if distance > 0.1: 
+            output += f"{idx}. {action}"
+            if road_name and road_name != "Unnamed road":
+                output += f" on {road_name}"
+            output += f" for {distance:.1f} km"
+            output += f" (Total: {cumulative_distance:.1f} km)\n"
+    
+    return output
+
+
+def find_optimal_route(origin_coords: Tuple[float, float], 
+                       dest_coords: Tuple[float, float]) -> Dict:
+    """
+    Compare all available routes and find optimal with detailed instructions
+    """
+
+    detailed_routes = get_detailed_route_with_instructions(origin_coords, dest_coords)
+    
+    if not detailed_routes:
+        return None
+    
+    traffic_factor = estimate_traffic_from_time()
+    
+    scored_routes = []
+    for route_data in detailed_routes:
+        adjusted_time = route_data['duration_min'] * traffic_factor
+        
+        fuel_cost_per_km = 8.0
+        estimated_cost = route_data['distance_km'] * fuel_cost_per_km
+        
+        score = (adjusted_time * 0.6) + (estimated_cost * 0.4)
+        
+        scored_routes.append({
+            'route_num': route_data['route_number'],
+            'distance_km': route_data['distance_km'],
+            'duration_min': route_data['duration_min'],
+            'adjusted_duration': adjusted_time,
+            'estimated_cost': estimated_cost,
+            'score': score,
+            'instructions': route_data['instructions'] 
+        })
+    
+    scored_routes.sort(key=lambda x: x['score'])
+    
+    return {
+        'optimal': scored_routes[0],
+        'all_routes': scored_routes
+    }
+
+def create_route_map_html(origin_coords, dest_coords, route_data, filename="static/route_map.html"):
+    """Generate interactive map with YOUR exact turn-by-turn directions"""
+    
+    os.makedirs("static", exist_ok=True)
+    
+    m = folium.Map(
+        location=[(origin_coords[0]+dest_coords[0])/2, (origin_coords[1]+dest_coords[1])/2], 
+        zoom_start=8
+    )
+    
+    folium.Marker(
+        origin_coords, 
+        popup="<b>START</b>", 
+        icon=folium.Icon(color='green', icon='play')
+    ).add_to(m)
+    
+    folium.Marker(
+        dest_coords, 
+        popup="<b>DESTINATION</b>", 
+        icon=folium.Icon(color='red', icon='stop')
+    ).add_to(m)
+    
+    if 'geometry' in route_data and route_data['geometry']:
+        coords = [[c[1], c[0]] for c in route_data['geometry']['coordinates']]
+        folium.PolyLine(coords, color='blue', weight=5, opacity=0.7).add_to(m)
+    
+    directions_html = "<div style='position:fixed;top:10px;right:10px;width:300px;background:white;padding:10px;border:2px solid blue;max-height:80vh;overflow-y:auto;z-index:1000'>"
+    directions_html += f"<h3>Route Directions</h3>"
+    directions_html += f"<b>Distance:</b> {route_data.get('distance_km', 0):.1f} km<br>"
+    directions_html += f"<b>Duration:</b> {route_data.get('duration_min', 0):.0f} min<br><hr>"
+    
+    for idx, step in enumerate(route_data.get('instructions', []), 1):
+        if step['distance_km'] > 0.1:
+            directions_html += f"<b>{idx}.</b> {step['instruction'].title()}"
+            if step['road_name'] != "Unnamed road":
+                directions_html += f" on <b>{step['road_name']}</b>"
+            directions_html += f"<br><small>{step['distance_km']:.1f} km</small><hr>"
+    
+    directions_html += "</div>"
+    
+    m.get_root().html.add_child(folium.Element(directions_html))
+    
+    m.save(filename)
+    return filename
+
+def real_route_planner(origin: str, destination: str) -> str:
+    """
+    Plan route using FREE OSRM with real OpenStreetMap data
+    """
+    print(f"\n{'='*60}")
+    print(f"Planning route: {origin} → {destination}")
+    print(f"{'='*60}")
+    
+    origin_coords = geocode_address_nominatim(origin)
+    if not origin_coords:
+        return f"Could not find location: {origin}. Try being more specific (e.g., 'Mumbai, Maharashtra, India')"
+    print(f"✓ Origin found: {origin_coords}")
+    
+    dest_coords = geocode_address_nominatim(destination)
+    if not dest_coords:
+        return f"Could not find location: {destination}. Try being more specific."
+    print(f"✓ Destination found: {dest_coords}")
+    
+    route = get_route_osrm(origin_coords, dest_coords)
+    if not route:
+        return f"No route found between {origin} and {destination}"
+    print(f"✓ Route found: {route['distance_km']:.1f} km, {route['duration_min']:.0f} min")
+    
+    optimization = find_optimal_route(origin_coords, dest_coords)
+    if not optimization:
+        return f"Could not optimize route"
+    
+    safe_origin = origin.replace(' ', '_').replace(',', '')[:30]
+    safe_dest = destination.replace(' ', '_').replace(',', '')[:30]
+    map_filename = f"route_{safe_origin}_to_{safe_dest}.html"
+    map_path = f"static/{map_filename}"
+    
+    optimal_route_data = {
+        'distance_km': optimization['optimal']['distance_km'],
+        'duration_min': optimization['optimal']['duration_min'],
+        'instructions': optimization['optimal']['instructions'],
+        'geometry': route.get('geometry')
+    }
+    
+    try:
+        map_file = create_route_map_html(origin_coords, dest_coords, optimal_route_data, map_path)
+        print("Map saved to", map_file)
+        map_url = f"/view-map/{map_filename}"
+    except Exception as e:
+        print("Map creation failed:", e)
+        map_url = None
+
+
+    result = f"Route Analysis (OpenStreetMap Data):\n"
+    result += f"From: {origin}\n"
+    result += f"To: {destination}\n\n"
+    
+    if map_url:
+        result += f"INTERACTIVE MAP: {map_url}\n"
+        result += f"(Open this link in your browser to view the map)\n\n"
+    
+    result += f"PRIMARY ROUTE:\n"
+    result += f"Distance: {route['distance_km']:.1f} km\n"
+    result += f"Duration: {route['duration_min']:.0f} minutes\n"
+
+    if optimization and len(optimization['all_routes']) >= 1:
+        result += "\n\nROUTE COMPARISON:\n"
+        for i, r in enumerate(optimization['all_routes']):
+            marker = " [OPTIMAL]" if i == 0 else ""
+            result += (f"\nRoute {r['route_num']}:{marker}\n"
+                      f"  Distance: {r['distance_km']:.1f} km\n"
+                      f"  Base Time: {r['duration_min']:.0f} min\n"
+                      f"  With Traffic: {r['adjusted_duration']:.0f} min\n"
+                      f"  Est. Cost: Rs {r['estimated_cost']:.2f}\n"
+                      f"  Score: {r['score']:.1f}")
+        
+        if optimization['optimal']['route_num'] != 1:
+            result += f"\n\nRECOMMENDATION: Route {optimization['optimal']['route_num']} is optimal based on time and cost factors"
+        
+        optimal_route = optimization['optimal']
+        result += "\n\n" + "=" * 50
+        result += format_route_instructions({
+            'route_number': optimal_route['route_num'],
+            'distance_km': optimal_route['distance_km'],
+            'duration_min': optimal_route['duration_min'],
+            'instructions': optimal_route['instructions']
+        })
+
+    return result
+
+def real_cost_optimizer(distance_km: float, weight_kg: float, duration_min: float) -> str:
+    """
+    Calculate real-world delivery costs
+    """
+    print(f"\nCalculating costs: {distance_km:.1f}km, {weight_kg}kg, {duration_min/60:.0f}hr")
+    
+    suitable = [v for v in REAL_VEHICLES if v["capacity_kg"] >= weight_kg and v["available"]]
+    
+    if not suitable:
+        return f"No vehicle available for {weight_kg}kg (max capacity: {max(v['capacity_kg'] for v in REAL_VEHICLES)}kg)"
+    
+    options = []
+    for vehicle in suitable:
+    
+        fuel_cost = distance_km * vehicle["fuel_cost_per_km"]
+        
+        driver_cost = (duration_min / 60) * 200
+        
+        base_fee = 150
+        
+        traffic_multiplier = estimate_traffic_from_time()
+        
+        capacity_usage = weight_kg / vehicle["capacity_kg"]
+        capacity_multiplier = 1.15 if capacity_usage > 0.8 else 1.0
+        
+        total_cost = (base_fee + fuel_cost + driver_cost) * traffic_multiplier * capacity_multiplier
+        
+        options.append({
+            "vehicle": vehicle,
+            "total_cost": total_cost,
+            "fuel_cost": fuel_cost,
+            "driver_cost": driver_cost,
+            "traffic_factor": traffic_multiplier
+        })
+    
+    options.sort(key=lambda x: x["total_cost"])
+    best = options[0]
+    
+    result = (
+        f"Cost Estimate (Real-world pricing):\n"
+        f"Recommended: {best['vehicle']['type']} ({best['vehicle']['id']})\n"
+        f"Total Cost: ₹{best['total_cost']:.2f}\n"
+        f"• Base Fee: ₹150\n"
+        f"• Fuel: ₹{best['fuel_cost']:.2f}\n"
+        f"• Driver: ₹{best['driver_cost']:.2f}\n"
+        f"• Traffic Factor: {best['traffic_factor']:.2f}x\n"
+        f"Capacity: {best['vehicle']['capacity_kg']}kg (using {(weight_kg/best['vehicle']['capacity_kg'])*100:.1f}%)"
+    )
+    
+    if len(options) > 1:
+        alt = options[1]
+        result += f"\n Alternative: {alt['vehicle']['type']} at ₹{alt['total_cost']:.2f}"
+    
+    return result
+
+
+def real_traffic_analyzer(origin: str, destination: str) -> str:
+    """
+    Analyze traffic conditions using real data and patterns
+    """
+    print(f"\nAnalyzing traffic: {origin} → {destination}")
+    
+    origin_coords = geocode_address_nominatim(origin)
+    dest_coords = geocode_address_nominatim(destination)
+    
+    if not origin_coords or not dest_coords:
+        return "Could not analyze traffic - invalid locations"
+    
+    route = get_route_osrm(origin_coords, dest_coords)
+    if not route:
+        return "No route found for traffic analysis"
+    
+    current_hour = datetime.now().hour
+    traffic_factor = estimate_traffic_from_time()
+    
+    if traffic_factor >= 1.5:
+        traffic_level = "Heavy"
+        advice = "Consider delaying by 1-2 hours or use alternative route"
+    elif traffic_factor >= 1.2:
+        traffic_level = "Moderate"
+        advice = "Expect minor delays, monitor conditions"
+    else:
+        traffic_level = "Light"
+        advice = "Good time to depart!"
+    
+    
+    base_duration = route["duration_min"]
+    adjusted_duration = base_duration * traffic_factor
+    total_delay = adjusted_duration - base_duration
+    
+    result = (
+        f"Traffic Analysis (Real-time patterns):\n"
+        f"Current Traffic: {traffic_level}\n"
+        f"Time: {datetime.now().strftime('%H:%M')} (Factor: {traffic_factor:.2f}x)\n"
+        f"Base ETA: {base_duration:.0f} min\n"
+        f"Adjusted ETA: {adjusted_duration:.0f} min (+{total_delay:.0f} min delay)\n"
+    )
+    
+    result += f"\nAdvice: {advice}"
+    
+    return result
+
+
+route_tool = StructuredTool.from_function(
+    func=real_route_planner,
+    name="real_route_planner",
+    description="Find optimal route using FREE OpenStreetMap data. Provide city names or addresses and the detailed routes.",
+    args_schema=RouteInput
+)
+
+cost_tool = StructuredTool.from_function(
+    func=real_cost_optimizer,
+    name="real_cost_optimizer",
+    description="Calculate delivery costs with real-world pricing. Pass distance_km, weight_kg, duration_min as numbers.",
+    args_schema=CostInput
+)
+
+traffic_tool = StructuredTool.from_function(
+    func=real_traffic_analyzer,
+    name="real_traffic_analyzer",
+    description="Analyze traffic conditions using real patterns.",
+    args_schema=TrafficInput
+)