Add full deployment package for HF Spaces

- Dockerfile with Ollama + Python geospatial deps
- start.sh to run Ollama and Streamlit together
- App code, core modules, and data files

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Dockerfile

@@ -0,0 +1,46 @@
+# OUR-ERA: Hugging Face Spaces Deployment
+# Includes Ollama + Streamlit in a single container
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    libgdal-dev \
+    libgeos-dev \
+    libproj-dev \
+    gdal-bin \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Ollama
+RUN curl -fsSL https://ollama.com/install.sh | sh
+
+# Set GDAL environment variables
+ENV GDAL_CONFIG=/usr/bin/gdal-config
+
+# Copy and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app.py .
+COPY core/ ./core/
+COPY data/ ./data/
+
+# Copy startup script
+COPY start.sh .
+RUN chmod +x start.sh
+
+# Hugging Face Spaces expects port 7860
+EXPOSE 7860
+
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV OLLAMA_HOST=http://localhost:11434
+
+# Start both Ollama and Streamlit
+CMD ["./start.sh"]

README.md

@@ -1,10 +1,14 @@
 ---
-title: Our Era
-emoji: 👀
-colorFrom: yellow
-colorTo: red
+title: OUR-ERA
+emoji: 🌊
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OUR-ERA: Open Urban Resilience | Emergency Routing Assistant
+
+Climate-aware pedestrian routing for Brownsville, Brooklyn. Find optimal walking routes that avoid flooding, heat exposure, and steep hills.
+
+Powered by Ollama (qwen2.5:3b) for natural language queries.

app.py

@@ -0,0 +1,2231 @@
+"""
+Emergency Routing Assistant - Streamlit Frontend
+
+This is a presentation-only layer. All logic lives in core/engine.py.
+"""
+
+import os
+from datetime import datetime
+import streamlit as st
+import folium
+from streamlit_folium import st_folium
+import json
+import requests
+
+from core.engine import (
+    RoutingEngine,
+    execute_tool,
+    BROWNSVILLE_CENTER,
+    get_poi_marker_style,
+    POI_MARKER_STYLES,
+)
+
+# =============================================================================
+# Page Config
+# =============================================================================
+
+st.set_page_config(
+    page_title="Emergency Routing Assistant",
+    page_icon="🚨",
+    layout="wide"
+)
+
+# =============================================================================
+# Session State
+# =============================================================================
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "map_data" not in st.session_state:
+    st.session_state.map_data = None
+if "engine" not in st.session_state:
+    st.session_state.engine = RoutingEngine()
+
+# =============================================================================
+# LLM Config
+# =============================================================================
+
+OLLAMA_URL = "http://localhost:11434/api/chat"
+
+# Available models for selection
+AVAILABLE_MODELS = {
+    "Qwen 2.5 3B (Fast)": "qwen2.5:3b",
+    "Llama xLAM 8B (Accurate)": "hf.co/Salesforce/Llama-xLAM-2-8b-fc-r-gguf",
+}
+DEFAULT_MODEL = "Qwen 2.5 3B (Fast)"
+
+# Initialize model selection in session state
+if "selected_model" not in st.session_state:
+    st.session_state.selected_model = DEFAULT_MODEL
+
+def get_current_model() -> str:
+    """Get the currently selected model ID."""
+    return AVAILABLE_MODELS.get(st.session_state.selected_model, AVAILABLE_MODELS[DEFAULT_MODEL])
+
+
+def warmup_llm(model: str):
+    """Warmup LLM on startup to avoid cold start latency on first query.
+
+    This sends a simple request to load the model into memory.
+    Returns True if successful, False otherwise.
+    """
+    import requests
+    try:
+        response = requests.post(
+            OLLAMA_URL,
+            json={
+                "model": model,
+                "messages": [{"role": "user", "content": "Hi"}],
+                "stream": False,
+            },
+            timeout=120,  # Model loading can take time
+        )
+        response.raise_for_status()
+        return True
+    except requests.exceptions.ConnectionError:
+        return False
+    except Exception:
+        return False
+
+# =============================================================================
+# "Less is More" - Embedding-Based Tool Selection
+# Paper insight: Pre-filter tools using embeddings, only send relevant ones to LLM
+# =============================================================================
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+# Pre-computed tool embeddings (computed once at startup)
+# Climate weight parameters are set by the LLM based on user context:
+#   flood_penalty_deep: 5.0 default, 10.0 for active flooding
+#   flood_penalty_shallow: 2.0 default, 4.0 for flooding
+#   heat_factor: 0.3 default, 0.5 for hot days / shade seeking
+#   shade_factor: 0.3 default, 0.5 for tree shade preference
+#   aqi_factor: 0.1 default, 0.5 for respiratory concerns
+#   grade_factor: 0.2 default, 0.5 for elderly/mobility-impaired users
+#   routing_mode: 'safe' (default) or 'fast'
+TOOL_DEFINITIONS = {
+    "find_nearest": {
+        "description": "Find the single nearest closest resource like hospital clinic pharmacy shelter school fire station police with climate-safe walking route directions flooding heat asthma shade cooling center elderly wheelchair accessible flat",
+        "keywords": ["nearest", "closest", "find", "where is", "locate", "emergency", "help", "nearby", "flooding", "hot", "shade", "asthma", "cooling", "elderly", "wheelchair", "accessible", "flat"],
+        "params": "resource_type, lat, lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor"
+    },
+    "list_resources": {
+        "description": "List count inventory enumerate all resources of a type how many are there total number available",
+        "keywords": ["list", "how many", "count", "all", "show", "available", "total", "number", "inventory", "enumerate"],
+        "params": "resource_type"
+    },
+    "calculate_route": {
+        "description": "Calculate walking route directions path between two locations climate-safe safest low flood risk heat exposure shade trees avoidance evacuation storm weather resilient asthma air quality get to go to elderly wheelchair accessible flat hills avoid steep",
+        "keywords": ["route", "walk", "from", "to", "directions", "path", "evacuate", "go", "between", "travel", "safest", "climate", "flood", "heat", "safe", "exposure", "risk", "storm", "resilient", "shade", "trees", "asthma", "air", "breathing", "get to", "elderly", "wheelchair", "accessible", "flat", "hills", "steep"],
+        "params": "start_lat, start_lon, end_lat, end_lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor, routing_mode"
+    },
+    "generate_isochrone": {
+        "description": "Show what resources can residents reach within X minutes walking time reachable area coverage zone radius from a location assess emergency access accessibility response window service area",
+        "keywords": ["reach", "minutes", "reachable", "within", "coverage", "area", "time", "radius", "zone", "access", "assess", "accessibility", "residents", "response", "window", "service area", "can reach"],
+        "params": "lat, lon, time_limits"
+    },
+    "find_along_route": {
+        "description": "Find resources along a route corridor on the way between two points what is near the path during travel what resources are along",
+        "keywords": ["along", "route", "corridor", "between", "on the way", "during", "path", "near route", "along the way", "resources along"],
+        "params": "start_lat, start_lon, end_lat, end_lon, resource_types"
+    }
+}
+
+RESOURCE_TYPES = ["pharmacy", "clinic", "hospital", "fire_station", "police", "school", "library", "community_centre", "place_of_worship", "shelter"]
+
+# =============================================================================
+# GBNF Grammars for Type-Safe LLM Output
+# These constrain the LLM to output properly typed JSON for each tool
+# =============================================================================
+
+# Common grammar components
+_GBNF_COMMON = r'''
+ws ::= [ \t\n]*
+number ::= "-"? ([0-9] | [1-9] [0-9]*) ("." [0-9]+)?
+integer ::= "-"? ([0-9] | [1-9] [0-9]*)
+string ::= "\"" ([^"\\] | "\\" .)* "\""
+'''
+
+# Grammar for tool selection - enforces proper types for all tools
+# NOTE: This is the FULL grammar. Use build_dynamic_grammar() to generate
+# a grammar constrained to only the embedding-selected tools.
+TOOL_SELECTION_GRAMMAR = r'''
+root ::= "{" ws "\"name\"" ws ":" ws tool-name ws "," ws "\"arguments\"" ws ":" ws arguments ws "}"
+
+tool-name ::= "\"find_nearest\"" | "\"list_resources\"" | "\"calculate_route\"" | "\"generate_isochrone\"" | "\"find_along_route\""
+
+arguments ::= find-nearest-args | list-resources-args | calculate-route-args | generate-isochrone-args | find-along-route-args
+
+resource-type ::= "\"pharmacy\"" | "\"clinic\"" | "\"hospital\"" | "\"fire_station\"" | "\"police\"" | "\"school\"" | "\"library\"" | "\"community_centre\"" | "\"place_of_worship\"" | "\"shelter\"" | "\"aed\"" | "\"senior_center\"" | "\"cooling_center\""
+
+find-nearest-args ::= "{" ws "\"resource_type\"" ws ":" ws resource-type ws ( "," ws lat-lon-args )? ( "," ws climate-args )* ws "}"
+
+list-resources-args ::= "{" ws "\"resource_type\"" ws ":" ws resource-type ws "}"
+
+calculate-route-args ::= "{" ws start-lat-arg ws "," ws start-lon-arg ws "," ws end-lat-arg ws "," ws end-lon-arg ws ( "," ws climate-args )* ( "," ws routing-mode-arg )? ws "}"
+
+generate-isochrone-args ::= "{" ws lat-arg ws "," ws lon-arg ws ( "," ws time-limits-arg )? ws "}"
+
+find-along-route-args ::= "{" ws start-lat-arg ws "," ws start-lon-arg ws "," ws end-lat-arg ws "," ws end-lon-arg ws ( "," ws resource-types-arg )? ws "}"
+
+lat-lon-args ::= lat-arg ws "," ws lon-arg
+lat-arg ::= "\"lat\"" ws ":" ws number
+lon-arg ::= "\"lon\"" ws ":" ws number
+start-lat-arg ::= "\"start_lat\"" ws ":" ws number
+start-lon-arg ::= "\"start_lon\"" ws ":" ws number
+end-lat-arg ::= "\"end_lat\"" ws ":" ws number
+end-lon-arg ::= "\"end_lon\"" ws ":" ws number
+
+time-limits-arg ::= "\"time_limits\"" ws ":" ws "[" ws integer ( ws "," ws integer )* ws "]"
+
+resource-types-arg ::= "\"resource_types\"" ws ":" ws "[" ws resource-type ( ws "," ws resource-type )* ws "]"
+
+climate-args ::= flood-penalty-arg | heat-factor-arg | shade-factor-arg | aqi-factor-arg | grade-factor-arg
+flood-penalty-arg ::= "\"flood_penalty_deep\"" ws ":" ws number
+heat-factor-arg ::= "\"heat_factor\"" ws ":" ws number
+shade-factor-arg ::= "\"shade_factor\"" ws ":" ws number
+aqi-factor-arg ::= "\"aqi_factor\"" ws ":" ws number
+grade-factor-arg ::= "\"grade_factor\"" ws ":" ws number
+
+routing-mode-arg ::= "\"routing_mode\"" ws ":" ws ("\"safe\"" | "\"fast\"")
+
+ws ::= [ \t\n]*
+number ::= "-"? ([0-9] | [1-9] [0-9]*) ("." [0-9]+)?
+integer ::= [0-9] | [1-9] [0-9]*
+'''
+
+
+def build_dynamic_grammar(selected_tools: list[str]) -> str:
+    """Build a GBNF grammar constrained to only the selected tools.
+
+    This is critical for the "Less is More" approach - embedding pre-selection
+    narrows to top-k tools, and the grammar ENFORCES that the LLM can only
+    output one of those tools. This prevents the LLM from hallucinating
+    a tool that wasn't in the pre-selected set.
+
+    Args:
+        selected_tools: List of tool names from embedding pre-selection
+
+    Returns:
+        GBNF grammar string that only allows the selected tools
+    """
+    # Build the tool-name rule with only selected tools
+    tool_name_parts = [f'"\"{t}\""' for t in selected_tools]
+    tool_name_rule = "tool-name ::= " + " | ".join(tool_name_parts)
+
+    # Build the arguments rule with only selected tools' argument types
+    arg_parts = []
+    for t in selected_tools:
+        arg_parts.append(f"{t.replace('_', '-')}-args")
+    arguments_rule = "arguments ::= " + " | ".join(arg_parts)
+
+    # Assemble the grammar
+    grammar = f'''
+root ::= "{{" ws "\\"name\\"" ws ":" ws tool-name ws "," ws "\\"arguments\\"" ws ":" ws arguments ws "}}"
+
+{tool_name_rule}
+
+{arguments_rule}
+
+resource-type ::= "\\"pharmacy\\"" | "\\"clinic\\"" | "\\"hospital\\"" | "\\"fire_station\\"" | "\\"police\\"" | "\\"school\\"" | "\\"library\\"" | "\\"community_centre\\"" | "\\"place_of_worship\\"" | "\\"shelter\\"" | "\\"aed\\"" | "\\"senior_center\\"" | "\\"cooling_center\\""
+
+find-nearest-args ::= "{{" ws "\\"resource_type\\"" ws ":" ws resource-type ws ( "," ws lat-lon-args )? ( "," ws climate-args )* ws "}}"
+
+list-resources-args ::= "{{" ws "\\"resource_type\\"" ws ":" ws resource-type ws "}}"
+
+calculate-route-args ::= "{{" ws start-lat-arg ws "," ws start-lon-arg ws "," ws end-lat-arg ws "," ws end-lon-arg ws ( "," ws climate-args )* ( "," ws routing-mode-arg )? ws "}}"
+
+generate-isochrone-args ::= "{{" ws lat-arg ws "," ws lon-arg ws ( "," ws time-limits-arg )? ws "}}"
+
+find-along-route-args ::= "{{" ws start-lat-arg ws "," ws start-lon-arg ws "," ws end-lat-arg ws "," ws end-lon-arg ws ( "," ws resource-types-arg )? ws "}}"
+
+lat-lon-args ::= lat-arg ws "," ws lon-arg
+lat-arg ::= "\\"lat\\"" ws ":" ws number
+lon-arg ::= "\\"lon\\"" ws ":" ws number
+start-lat-arg ::= "\\"start_lat\\"" ws ":" ws number
+start-lon-arg ::= "\\"start_lon\\"" ws ":" ws number
+end-lat-arg ::= "\\"end_lat\\"" ws ":" ws number
+end-lon-arg ::= "\\"end_lon\\"" ws ":" ws number
+
+time-limits-arg ::= "\\"time_limits\\"" ws ":" ws "[" ws integer ( ws "," ws integer )* ws "]"
+
+resource-types-arg ::= "\\"resource_types\\"" ws ":" ws "[" ws resource-type ( ws "," ws resource-type )* ws "]"
+
+climate-args ::= flood-penalty-arg | heat-factor-arg | shade-factor-arg | aqi-factor-arg | grade-factor-arg
+flood-penalty-arg ::= "\\"flood_penalty_deep\\"" ws ":" ws number
+heat-factor-arg ::= "\\"heat_factor\\"" ws ":" ws number
+shade-factor-arg ::= "\\"shade_factor\\"" ws ":" ws number
+aqi-factor-arg ::= "\\"aqi_factor\\"" ws ":" ws number
+grade-factor-arg ::= "\\"grade_factor\\"" ws ":" ws number
+
+routing-mode-arg ::= "\\"routing_mode\\"" ws ":" ws ("\\"safe\\"" | "\\"fast\\"")
+
+ws ::= [ \\t\\n]*
+number ::= "-"? ([0-9] | [1-9] [0-9]*) ("." [0-9]+)?
+integer ::= [0-9] | [1-9] [0-9]*
+'''
+    return grammar
+
+# =============================================================================
+# Pre-computed Embeddings Loading (run build_tool_embeddings.py first!)
+# =============================================================================
+
+EMBEDDINGS_PATH = os.path.join(os.path.dirname(__file__), "data", "tool_embeddings.npz")
+
+@st.cache_resource
+def load_tool_embeddings():
+    """Load pre-computed tool embeddings from file (instant startup!)."""
+    if not os.path.exists(EMBEDDINGS_PATH):
+        st.warning("Tool embeddings not found. Run: python build_tool_embeddings.py")
+        return None, None, None
+
+    data = np.load(EMBEDDINGS_PATH, allow_pickle=True)
+    tool_names = data['tool_names'].tolist()
+    embeddings = data['embeddings']
+    model_name = str(data['model_name'])
+    return tool_names, embeddings, model_name
+
+@st.cache_resource
+def load_embedding_model():
+    """Load sentence transformer model for query encoding (cached)."""
+    _, _, model_name = load_tool_embeddings()
+    if model_name:
+        return SentenceTransformer(model_name)
+    return SentenceTransformer('all-MiniLM-L6-v2')
+
+def select_tool_by_embedding(query: str, top_k: int = 2) -> list[str]:
+    """Select most relevant tools using embedding similarity (no LLM call!)."""
+    tool_names, embeddings, _ = load_tool_embeddings()
+
+    if tool_names is None:
+        # Fallback: return all tools if embeddings not available
+        return list(TOOL_DEFINITIONS.keys())[:top_k]
+
+    model = load_embedding_model()
+
+    # Encode the query
+    query_embedding = model.encode(query, normalize_embeddings=True)
+
+    # Compute similarities using matrix multiplication (fast!)
+    similarities = np.dot(embeddings, query_embedding)
+
+    # Get top-k indices
+    top_indices = np.argsort(similarities)[::-1][:top_k]
+
+    return [tool_names[i] for i in top_indices]
+
+
+def build_minimal_tool_prompt(selected_tools: list[str]) -> str:
+    """Build a minimal prompt with only the selected tools."""
+    lines = ["Select ONE tool. Output JSON: {\"name\": \"tool\", \"arguments\": {...}}\n\nTools:"]
+
+    # Tool descriptions to help LLM understand what each tool does
+    tool_descriptions = {
+        "find_nearest": "find single nearest resource (hospital, pharmacy, shelter, etc.)",
+        "list_resources": "list/count all resources of a type",
+        "calculate_route": "get walking directions between two locations",
+        "generate_isochrone": "show what resources can be reached within X minutes from a location",
+        "find_along_route": "find resources along a route between two points",
+    }
+
+    for tool in selected_tools:
+        info = TOOL_DEFINITIONS[tool]
+        desc = tool_descriptions.get(tool, "")
+        lines.append(f"- {tool}({info['params']}) - {desc}")
+    lines.append(f"\nresource_type options: {'|'.join(RESOURCE_TYPES)}")
+
+    # Critical: Tell LLM when to OMIT resource_types filter for find_along_route
+    if "find_along_route" in selected_tools:
+        lines.append("""
+IMPORTANT for find_along_route: OMIT resource_types to find ALL resources along the route.
+Only include resource_types if user asks for specific types (e.g., "pharmacies along route").""")
+
+    # Add tool-specific guidance
+    if "generate_isochrone" in selected_tools:
+        lines.append("""
+For "reach in X minutes" or "what can residents access" queries, use generate_isochrone with time_limits=[5,10,15]""")
+
+    # Add climate parameter guidance for tools that support it
+    climate_tools = {"find_nearest", "calculate_route", "compare_routes"}
+    if any(t in climate_tools for t in selected_tools):
+        lines.append("""
+CLIMATE PARAMETERS - Set based on user context:
+- If user mentions FLOODING/storm/rain: flood_penalty_deep=10.0
+- If user mentions HEAT/hot/cooling/shade/trees: heat_factor=0.5, shade_factor=0.5
+- If user mentions ASTHMA/breathing/air quality: aqi_factor=0.5
+- If user mentions ELDERLY/wheelchair/walker/mobility/accessible/flat/hills/steep: grade_factor=0.5
+- For FAST routes (user wants speed over safety): routing_mode="fast"
+- Default: omit climate params for standard safe routing""")
+    return "\n".join(lines)
+
+
+# Fallback prompt with all tools (used if embedding selection fails)
+TOOL_SELECTION_PROMPT = """Select ONE tool. Output JSON: {"name": "tool", "arguments": {...}}
+
+Tools:
+- find_nearest(resource_type, lat, lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor)
+- list_resources(resource_type)
+- calculate_route(start_lat, start_lon, end_lat, end_lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor, routing_mode)
+- generate_isochrone(lat, lon, time_limits)
+- find_along_route(start_lat, start_lon, end_lat, end_lon, resource_types)
+
+resource_type options: pharmacy|clinic|hospital|fire_station|police|school|library|community_centre|place_of_worship|shelter
+
+CLIMATE PARAMETERS - Set based on user context:
+- If user mentions FLOODING/storm/rain: flood_penalty_deep=10.0
+- If user mentions HEAT/hot/cooling/shade/trees: heat_factor=0.5, shade_factor=0.5
+- If user mentions ASTHMA/breathing/air quality: aqi_factor=0.5
+- If user mentions ELDERLY/wheelchair/walker/mobility/accessible/flat/hills/steep: grade_factor=0.5
+- For FAST routes (user wants speed over safety): routing_mode="fast"
+- Default: omit climate params for standard safe routing"""
+
+# =============================================================================
+# Multi-Step Query Planner
+# Key insight: Use variable references ($step1.lat) instead of LLM reproducing outputs
+# =============================================================================
+
+MULTI_STEP_PLANNER_PROMPT = """You are a query planner. Analyze if this query requires multiple steps.
+
+If SINGLE step: Output {"multi_step": false, "steps": []}
+
+If MULTIPLE steps needed (e.g., "find X then go to Y", "reach A then find nearest B"):
+Output a plan with variable references. Results from step N are available as $stepN.field
+
+Example for "Find nearest SNAP center avoiding floods, then route to nearest cooling center":
+{
+  "multi_step": true,
+  "steps": [
+    {"step": 1, "tool": "find_nearest", "args": {"resource_type": "community_centre", "lat": 40.6594, "lon": -73.9126, "flood_penalty_deep": 10.0}, "description": "Find SNAP center avoiding floods"},
+    {"step": 2, "tool": "find_nearest", "args": {"resource_type": "shelter", "lat": "$step1.lat", "lon": "$step1.lon"}, "description": "Find cooling center from SNAP location"}
+  ]
+}
+
+Available tools:
+- find_nearest(resource_type, lat, lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor) -> returns {lat, lon, name, distance_meters, walking_time_minutes}
+- calculate_route(start_lat, start_lon, end_lat, end_lon, flood_penalty_deep, heat_factor, shade_factor, aqi_factor, grade_factor, routing_mode) -> returns route with distance, time
+- generate_isochrone(lat, lon, time_limits) -> returns reachable areas
+- find_along_route(start_lat, start_lon, end_lat, end_lon, resource_types) -> returns POIs along route
+
+resource_type: pharmacy|clinic|hospital|fire_station|police|school|library|community_centre|place_of_worship|shelter
+
+CLIMATE PARAMETERS - Set based on user context:
+- FLOODING/storm/rain: flood_penalty_deep=10.0
+- HEAT/hot/cooling/shade/trees: heat_factor=0.5, shade_factor=0.5
+- ASTHMA/breathing/air quality: aqi_factor=0.5
+- ELDERLY/wheelchair/walker/mobility/accessible/flat/hills/steep: grade_factor=0.5
+- FAST routes: routing_mode="fast"
+
+Output JSON only."""
+
+
+def is_multi_step_query(query: str) -> bool:
+    """Quick heuristic check if query might need multiple steps."""
+    multi_step_indicators = [
+        " then ", " after ", " next ", " finally ",
+        " and then ", " before going ", " from there ",
+        ", then ", "after that", "once I", "when I reach"
+    ]
+    query_lower = query.lower()
+    return any(indicator in query_lower for indicator in multi_step_indicators)
+
+
+def call_llm_planner(query: str) -> dict:
+    """Call LLM to generate a multi-step plan."""
+    try:
+        response = requests.post(
+            OLLAMA_URL,
+            json={
+                "model": get_current_model(),
+                "messages": [
+                    {"role": "system", "content": MULTI_STEP_PLANNER_PROMPT},
+                    {"role": "user", "content": query},
+                ],
+                "stream": False,
+                "format": "json",
+            },
+            timeout=60,
+        )
+        response.raise_for_status()
+        content = response.json().get("message", {}).get("content", "{}")
+        return json.loads(content)
+    except Exception as e:
+        return {"multi_step": False, "error": str(e)}
+
+
+def resolve_variable_references(args: dict, step_results: dict) -> dict:
+    """Replace $stepN.field references with actual values from previous results."""
+    resolved = {}
+    for key, value in args.items():
+        if isinstance(value, str) and value.startswith("$step"):
+            # Parse reference like "$step1.lat"
+            try:
+                parts = value[1:].split(".")  # Remove $ and split
+                step_ref = parts[0]  # "step1"
+                field = parts[1] if len(parts) > 1 else None  # "lat"
+
+                step_num = int(step_ref.replace("step", ""))
+                step_result = step_results.get(step_num, {})
+
+                if field:
+                    resolved[key] = step_result.get(field, value)
+                else:
+                    resolved[key] = step_result
+            except (ValueError, IndexError):
+                resolved[key] = value  # Keep original if parsing fails
+        else:
+            resolved[key] = value
+    return resolved
+
+
+def execute_multi_step_plan(plan: dict, engine) -> tuple[list[dict], list[dict]]:
+    """Execute a multi-step plan, passing results between steps.
+
+    Returns:
+        tuple: (list of results, list of map_data for each step)
+    """
+    steps = plan.get("steps", [])
+    step_results = {}  # Store results keyed by step number
+    all_results = []
+    all_map_data = []
+
+    for step in steps:
+        step_num = step.get("step", len(step_results) + 1)
+        tool_name = step.get("tool", "")
+        args = step.get("args", {})
+        description = step.get("description", f"Step {step_num}")
+
+        # Resolve any variable references from previous steps
+        resolved_args = resolve_variable_references(args, step_results)
+
+        # Execute the tool
+        result, map_data = execute_tool(tool_name, resolved_args, engine)
+
+        # Store result for future reference
+        # Flatten key fields for easy reference
+        step_results[step_num] = {
+            "lat": result.get("lat", result.get("destination", {}).get("lat") if isinstance(result.get("destination"), dict) else None),
+            "lon": result.get("lon", result.get("destination", {}).get("lon") if isinstance(result.get("destination"), dict) else None),
+            "name": result.get("name", result.get("destination", {}).get("name") if isinstance(result.get("destination"), dict) else None),
+            "distance_meters": result.get("distance_meters", 0),
+            "walking_time_minutes": result.get("walking_time_minutes", 0),
+            "full_result": result
+        }
+
+        all_results.append({
+            "step": step_num,
+            "description": description,
+            "tool": tool_name,
+            "args": resolved_args,
+            "result": result
+        })
+        all_map_data.append(map_data)
+
+    return all_results, all_map_data
+
+
+def format_multi_step_results(results: list[dict]) -> str:
+    """Format multi-step results for display."""
+    lines = ["**Multi-Step Query Results**\n"]
+
+    for step_result in results:
+        step_num = step_result.get("step", "?")
+        description = step_result.get("description", "")
+        result = step_result.get("result", {})
+
+        lines.append(f"### Step {step_num}: {description}")
+
+        if "error" in result:
+            lines.append(f"❌ Error: {result['error']}\n")
+        elif "name" in result:
+            # find_nearest result
+            lines.append(f"✅ **{result.get('name')}**")
+            lines.append(f"   📍 {result.get('distance_meters', 0):.0f}m away · 🚶 {result.get('walking_time_minutes', 0):.1f} min walk")
+            # Add climate metrics if available
+            if "climate_metrics" in result:
+                climate = result["climate_metrics"]
+                climate_parts = []
+                if climate.get("avg_flood_risk", 0) > 0.1:
+                    climate_parts.append(f"🌊 Flood: {climate['avg_flood_risk']:.0%}")
+                if climate.get("avg_heat_risk", 0) > 0.1:
+                    climate_parts.append(f"🌡️ Heat: {climate['avg_heat_risk']:.0%}")
+                if climate.get("avg_air_quality_risk", 0) > 0.1:
+                    climate_parts.append(f"💨 Air: {climate['avg_air_quality_risk']:.0%}")
+                if climate_parts:
+                    lines.append(f"   Climate: {' · '.join(climate_parts)}")
+            lines.append("")
+        elif "success" in result:
+            # calculate_route result
+            lines.append(f"✅ Route calculated: {result.get('distance_meters', 0):.0f}m · {result.get('walking_time_minutes', 0):.1f} min")
+            # Add climate metrics for route
+            if "climate_metrics" in result:
+                climate = result["climate_metrics"]
+                combined = climate.get("avg_climate_risk", 0)
+                lines.append(f"   Climate risk: {combined:.0%} (🌊 {climate.get('avg_flood_risk', 0):.0%} · 🌡️ {climate.get('avg_heat_risk', 0):.0%} · 💨 {climate.get('avg_air_quality_risk', 0):.0%})")
+            lines.append("")
+        else:
+            lines.append(f"✅ Completed\n")
+
+    return "\n".join(lines)
+
+
+def merge_multi_step_map_data(all_map_data: list[dict]) -> dict:
+    """Merge map data from multiple steps into a single map display.
+
+    Handles both old format (route_coords) and new format (routes array).
+    Draws routes between consecutive step destinations for multi-step queries.
+    """
+    merged = {
+        "routes": [],
+        "markers": [],
+        "waypoints": [],  # Intermediate stops between steps
+    }
+
+    colors = ["#3b82f6", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6"]  # Blue, green, amber, red, purple
+
+    for i, map_data in enumerate(all_map_data):
+        if not map_data:
+            continue
+
+        color = colors[i % len(colors)]
+
+        # Merge routes - handle both formats
+        # New format: "routes" array with multiple route alternatives
+        if "routes" in map_data and map_data["routes"]:
+            # Use recommended route, or first route as fallback
+            recommended_name = map_data.get("recommended", "")
+            route_to_use = None
+            for route in map_data["routes"]:
+                if route.get("name") == recommended_name:
+                    route_to_use = route
+                    break
+            if not route_to_use:
+                route_to_use = map_data["routes"][0]
+
+            if route_to_use and route_to_use.get("coords"):
+                merged["routes"].append({
+                    "coords": route_to_use["coords"],
+                    "color": color,
+                    "label": f"Step {i + 1}: {route_to_use.get('label', 'Route')}"
+                })
+        # Old format: single "route_coords"
+        elif "route_coords" in map_data:
+            merged["routes"].append({
+                "coords": map_data["route_coords"],
+                "color": color,
+                "label": f"Step {i + 1}"
+            })
+
+        # Merge origin/destination markers
+        if "origin" in map_data:
+            if i == 0:  # Only use origin from first step
+                merged["origin"] = map_data["origin"]
+            else:
+                # Intermediate origins become waypoints
+                merged["waypoints"].append({
+                    "coords": map_data["origin"],
+                    "label": f"Waypoint {i}",
+                    "step": i + 1
+                })
+
+        if "destination" in map_data:
+            # Track all destinations as potential waypoints
+            dest_info = {
+                "coords": map_data["destination"],
+                "name": map_data.get("dest_name", f"Step {i + 1}"),
+                "step": i + 1,
+                "is_final": True  # Will be updated if more steps follow
+            }
+            # Mark previous destinations as not final
+            for wp in merged["waypoints"]:
+                if wp.get("is_final"):
+                    wp["is_final"] = False
+            merged["waypoints"].append(dest_info)
+            # Always keep last destination
+            merged["destination"] = map_data["destination"]
+            merged["dest_name"] = map_data.get("dest_name", f"Step {i + 1} destination")
+
+        # Merge isochrones
+        if "isochrones" in map_data:
+            merged["isochrones"] = map_data["isochrones"]
+
+        # Merge resources_within
+        if "resources_within" in map_data:
+            merged["resources_within"] = map_data.get("resources_within", [])
+
+        # Merge POIs along route
+        if "pois_along_route" in map_data:
+            if "pois_along_route" not in merged:
+                merged["pois_along_route"] = []
+            merged["pois_along_route"].extend(map_data["pois_along_route"])
+
+    return merged
+
+# =============================================================================
+# NYC-Specific Emergency Guidance Templates
+# =============================================================================
+
+NYC_EMERGENCY_CONTACTS = """
+## EMERGENCY CONTACTS
+| Service | Contact |
+|---------|---------|
+| Life-threatening emergencies | **911** |
+| City services, cooling centers | **311** |
+| Con Edison (power outages) | **1-800-752-6633** |
+| NYC Emergency Alerts | **NYC.gov/notifynyc** |
+| CB16 CERT (Brownsville) | **(718) 385-0323** |
+"""
+
+BROWNSVILLE_RESOURCES = """
+## NEARBY RESOURCES IN BROWNSVILLE
+- **Brownsville Recreation Center**: 1555 Linden Blvd (cooling center)
+- **Stone Avenue Library**: 581 Mother Gaston Blvd
+- **Brownsville Multi-Service Family Health Center**: 592 Rockaway Ave
+- **CB16 Office**: 444 Thomas S. Boyland St - (718) 385-0323
+"""
+
+def get_heat_guidance(flood_risk: float = 0) -> str:
+    """NYC official heat emergency guidance."""
+    guidance = """
+## HEAT EMERGENCY CHECKLIST
+
+### BEFORE DEPARTURE
+- [ ] Bring water—drink even if not thirsty
+- [ ] Wear light, loose-fitting clothing
+- [ ] Check air quality: **dec.ny.gov** (high ozone accompanies heat waves)
+- [ ] Confirm destination has AC (most heat deaths occur in homes without AC)
+
+### DURING TRANSIT
+- [ ] Avoid strenuous activity, especially 12pm-6pm
+- [ ] Take breaks in shade or AC—even a few hours helps
+- [ ] Watch for heat illness signs: heavy sweating, muscle cramps, dizziness, headache
+
+### IF CONDITIONS WORSEN
+- [ ] Find cooling center: Call **311** or **finder.nyc.gov/coolingcenters**
+- [ ] Confusion + hot/dry skin + rapid pulse = **Call 911** (heat stroke)
+- [ ] Code Red: Any shelter accepts people in heat distress
+"""
+    if flood_risk > 0.2:
+        guidance += """
+### ⚠️ COMBINED HEAT + FLOOD RISK
+- [ ] Avoid flooded underpasses—heat + standing water = dangerous conditions
+- [ ] Flash flooding can occur during summer storms
+"""
+    return guidance
+
+
+def get_flood_guidance(heat_risk: float = 0) -> str:
+    """NYC official flood emergency guidance."""
+    guidance = """
+## FLOOD EMERGENCY CHECKLIST
+
+### BEFORE DEPARTURE
+- [ ] This route avoids low-elevation flood-prone areas where possible
+- [ ] Charge phone; have backup battery
+- [ ] Know your evacuation zone: **NYC.gov/knowyourzone**
+
+### DURING TRANSIT
+- [ ] **"Turn Around, Don't Drown"**—never walk through moving water
+- [ ] 6 inches of moving water can knock you down
+- [ ] Avoid underpasses and subway entrances where water collects
+- [ ] Stay away from downed power lines
+
+### IF CONDITIONS WORSEN
+- [ ] Move to higher ground immediately
+- [ ] If trapped, **call 911**
+- [ ] Do NOT enter basements or below-grade spaces
+"""
+    if heat_risk > 0.2:
+        guidance += """
+### ⚠️ COMBINED FLOOD + HEAT RISK
+- [ ] Post-flood conditions can be humid and hot—stay hydrated
+- [ ] Mold grows quickly after flooding—avoid prolonged exposure
+"""
+    return guidance
+
+
+def get_blackout_guidance() -> str:
+    """NYC official blackout emergency guidance."""
+    return """
+## BLACKOUT EMERGENCY CHECKLIST
+
+### BEFORE DEPARTURE
+- [ ] Route prioritizes ground-floor accessible resources
+- [ ] Elevators will fail in high-rises—plan for stairs
+- [ ] Charge all devices; bring flashlight
+
+### DURING TRANSIT
+- [ ] Traffic signals may be out—cross carefully
+- [ ] Subway service likely suspended
+- [ ] Electronic door locks may not work
+
+### IF CONDITIONS WORSEN
+- [ ] Report outages: **Con Edison 1-800-752-6633**
+- [ ] Help seniors/disabled descend from upper floors
+- [ ] Never use generators indoors (CO poisoning kills)
+"""
+
+
+def get_general_guidance() -> str:
+    """General emergency preparedness guidance."""
+    return """
+## GENERAL EMERGENCY CHECKLIST
+
+### BEFORE DEPARTURE
+- [ ] Check weather conditions: **weather.gov**
+- [ ] Tell someone your route and expected arrival time
+- [ ] Charge phone; bring water and ID
+
+### DURING TRANSIT
+- [ ] Follow the recommended climate-safe route
+- [ ] Stay aware of surroundings
+- [ ] If conditions change, seek shelter immediately
+
+### IF CONDITIONS WORSEN
+- [ ] Find nearest sturdy building or shelter
+- [ ] **Call 911** for life-threatening emergencies
+- [ ] **Call 311** for city services and information
+"""
+
+
+def detect_scenario_type(climate: dict, user_query: str) -> str:
+    """Detect emergency scenario type from climate data and query."""
+    query_lower = user_query.lower()
+    flood_risk = climate.get("avg_flood_risk", 0)
+    heat_risk = climate.get("avg_heat_risk", 0)
+
+    # Check query for explicit mentions
+    if any(word in query_lower for word in ["blackout", "power outage", "no power", "electricity"]):
+        return "blackout"
+    if any(word in query_lower for word in ["heat", "hot", "cooling", "temperature", "heat wave"]):
+        return "heat"
+    if any(word in query_lower for word in ["flood", "rain", "storm", "water", "hurricane"]):
+        return "flood"
+
+    # Detect from risk metrics
+    if flood_risk > 0.4:
+        return "flood"
+    if heat_risk > 0.4:
+        return "heat"
+    if flood_risk > 0.2 and heat_risk > 0.2:
+        return "combined"
+    if flood_risk > 0.2:
+        return "flood"
+    if heat_risk > 0.2:
+        return "heat"
+
+    return "general"
+
+
+# =============================================================================
+# Code-Based Report Generation (No LLM needed - much faster!)
+# =============================================================================
+
+def generate_route_action_plan(result: dict, user_query: str) -> str:
+    """Generate Emergency Action Plan from route data with NYC-specific guidance."""
+    dest = result.get("destination", {})
+    dest_name = dest.get("name", "Destination") if isinstance(dest, dict) else "Destination"
+    distance = result.get("distance_meters", 0)
+    time_min = result.get("walking_time_minutes", 0)
+    metrics = result.get("route_metrics", {})
+    climate = result.get("climate_metrics", {})
+
+    terrain = metrics.get("difficulty", "unknown")
+    elev_gain = metrics.get("elevation_gain_m", 0)
+
+    # Climate risk assessment
+    flood_risk = climate.get("avg_flood_risk", 0)
+    heat_risk = climate.get("avg_heat_risk", 0)
+    air_quality_risk = climate.get("avg_air_quality_risk", 0)
+    flood_exposure = climate.get("flood_exposure_m", 0)
+    climate_avoided = climate.get("climate_avoided_m", 0)
+    combined_risk = climate.get("avg_climate_risk", 0)
+
+    # Determine scenario and risk level
+    scenario = detect_scenario_type(climate, user_query)
+    scenario_labels = {
+        "heat": "🌡️ EXTREME HEAT",
+        "flood": "🌊 FLOOD WARNING",
+        "blackout": "⚡ POWER OUTAGE",
+        "combined": "⚠️ COMBINED HEAT + FLOOD",
+        "general": "📋 GENERAL EMERGENCY"
+    }
+    scenario_label = scenario_labels.get(scenario, "📋 GENERAL EMERGENCY")
+
+    risk_level = "🟢 LOW"
+    if combined_risk > 0.6 or flood_risk > 0.4 or heat_risk > 0.4:
+        risk_level = "🔴 HIGH"
+    elif combined_risk > 0.4 or flood_risk > 0.2 or heat_risk > 0.2:
+        risk_level = "🟡 MODERATE"
+    elif combined_risk > 0.2:
+        risk_level = "🟠 ELEVATED"
+
+    # Build the report
+    report = f"""
+---
+# 📋 ACTION PLAN REPORT
+
+## MISSION
+| Field | Value |
+|-------|-------|
+| **Destination** | {dest_name} |
+| **Distance** | {distance:.0f}m |
+| **Walking Time** | {time_min:.1f} min |
+| **Elevation** | +{elev_gain:.0f}m climb |
+| **Scenario** | {scenario_label} |
+| **Risk Level** | {risk_level} |
+
+## ROUTE INTELLIGENCE
+| Climate Metric | Value |
+|----------------|-------|
+| **Combined Climate Risk** | {combined_risk:.0%} |
+| Flood Risk | {flood_risk:.0%} ({flood_exposure:.0f}m exposed) |
+| Heat Risk | {heat_risk:.0%} |
+| Air Quality Risk | {air_quality_risk:.0%} |
+| Terrain | {terrain.title()} |
+"""
+
+    # Add climate-safe route note if applicable
+    if climate_avoided > 0:
+        report += f"""
+### ✓ CLIMATE-SAFE ROUTE SELECTED
+This route avoids **{climate_avoided:.0f}m** of high-risk streets.
+"""
+
+    # Add scenario-specific guidance
+    if scenario == "heat":
+        report += get_heat_guidance(flood_risk)
+    elif scenario == "flood":
+        report += get_flood_guidance(heat_risk)
+    elif scenario == "blackout":
+        report += get_blackout_guidance()
+    elif scenario == "combined":
+        report += get_heat_guidance(flood_risk)
+        report += get_flood_guidance(heat_risk)
+    else:
+        report += get_general_guidance()
+
+    # Add emergency contacts and local resources
+    report += NYC_EMERGENCY_CONTACTS
+    report += BROWNSVILLE_RESOURCES
+    report += "\n---"
+
+    return report
+
+
+def generate_isochrone_report(result: dict, user_query: str) -> str:
+    """Generate Coverage Assessment from isochrone data with NYC-specific guidance."""
+    isochrones = result.get("isochrones", [])
+    resources = result.get("resources_within", [])
+
+    # Categorize resources by time
+    immediate = [r for r in resources if r.get("walking_time_minutes", 99) <= 5]
+    short_term = [r for r in resources if 5 < r.get("walking_time_minutes", 99) <= 10]
+    extended = [r for r in resources if 10 < r.get("walking_time_minutes", 99) <= 15]
+
+    # Find critical resource types
+    types_found = set(r.get("type", "") for r in resources)
+    critical_types = {"hospital", "clinic", "fire_station", "police", "shelter"}
+    missing = critical_types - types_found
+
+    # Find cooling centers specifically
+    cooling_centers = [r for r in resources if "cooling" in r.get("name", "").lower() or r.get("type") == "community_centre"]
+
+    report = f"""
+---
+# 📋 EMERGENCY COVERAGE ASSESSMENT
+
+## REACHABILITY ZONES
+"""
+    for iso in isochrones:
+        emoji = {"5": "🟢", "10": "🟡", "15": "🟠"}.get(str(iso.get("time_min")), "⚪")
+        report += f"- {emoji} **{iso.get('time_min')} min**: {iso.get('node_count', 0)} intersections reachable\n"
+
+    report += f"""
+## RESOURCES BY PRIORITY
+
+### 🟢 IMMEDIATE (0-5 min) - {len(immediate)} resources
+"""
+    for r in immediate[:5]:
+        report += f"- {r.get('name')} ({r.get('type')}) - {r.get('walking_time_minutes', 0):.1f} min\n"
+
+    report += f"""
+### 🟡 SHORT-TERM (5-10 min) - {len(short_term)} resources
+"""
+    for r in short_term[:5]:
+        report += f"- {r.get('name')} ({r.get('type')}) - {r.get('walking_time_minutes', 0):.1f} min\n"
+
+    report += f"""
+### 🟠 EXTENDED (10-15 min) - {len(extended)} resources
+"""
+    for r in extended[:5]:
+        report += f"- {r.get('name')} ({r.get('type')}) - {r.get('walking_time_minutes', 0):.1f} min\n"
+
+    report += f"""
+## COVERAGE ASSESSMENT
+
+| Assessment | Status |
+|------------|--------|
+| **Total Resources** | {len(resources)} within 15 min |
+| **Critical Services** | {len(critical_types - missing)}/5 covered |
+| **Gaps** | {', '.join(missing) if missing else '✓ All covered'} |
+| **Cooling Centers** | {len(cooling_centers)} nearby |
+
+## NYC HOUSEHOLD EMERGENCY CHECKLIST
+- [ ] Save nearest clinic/hospital address
+- [ ] Know your evacuation zone: **NYC.gov/knowyourzone**
+- [ ] Know 2 evacuation routes from your location
+- [ ] Keep emergency kit ready (water, flashlight, phone charger, medications)
+- [ ] Sign up for alerts: **NYC.gov/notifynyc**
+- [ ] Share this plan with family members
+
+## HEAT EMERGENCY RESOURCES
+- [ ] Nearest cooling center: Call **311** or **finder.nyc.gov/coolingcenters**
+- [ ] Libraries and community centers often serve as cooling centers
+- [ ] Code Red: Any shelter accepts people in heat distress
+"""
+    report += NYC_EMERGENCY_CONTACTS
+    report += BROWNSVILLE_RESOURCES
+    report += "\n---"
+    return report
+
+
+def generate_corridor_report(result: dict, user_query: str) -> str:
+    """Generate Evacuation Corridor Report from along-route data with NYC-specific guidance."""
+    pois = result.get("pois_found", [])
+    buffer = result.get("buffer_meters", 100)
+    poi_count = result.get("poi_count", len(pois))
+    climate = result.get("climate_metrics", {})
+
+    # Extract climate metrics
+    flood_risk = climate.get("avg_flood_risk", 0)
+    heat_risk = climate.get("avg_heat_risk", 0)
+    air_quality_risk = climate.get("avg_air_quality_risk", 0)
+    combined_risk = climate.get("avg_climate_risk", 0)
+
+    if not pois:
+        report = f"""
+---
+# 📋 EVACUATION CORRIDOR ANALYSIS
+
+## ASSESSMENT
+| Field | Value |
+|-------|-------|
+| **Resources Found** | 0 within {buffer}m of route |
+| **Recommendation** | Expand search or try alternate route |
+
+## NYC EMERGENCY GUIDANCE
+If no resources found along your route:
+- [ ] Try a wider search buffer (200-300m)
+- [ ] Check isochrone analysis for area coverage
+- [ ] Consider alternate evacuation routes
+- [ ] Call **311** for nearest cooling center or shelter
+- [ ] Know your evacuation zone: **NYC.gov/knowyourzone**
+"""
+        report += NYC_EMERGENCY_CONTACTS
+        report += BROWNSVILLE_RESOURCES
+        report += "\n---"
+        return report
+
+    # Group by type
+    by_type = {}
+    for poi in pois:
+        t = poi.get("type", "other")
+        if t not in by_type:
+            by_type[t] = []
+        by_type[t].append(poi)
+
+    # Identify critical waypoints
+    shelters = [p for p in pois if p.get("type") in ["shelter", "community_centre"]]
+    medical = [p for p in pois if p.get("type") in ["hospital", "clinic", "pharmacy"]]
+    emergency = [p for p in pois if p.get("type") in ["fire_station", "police"]]
+
+    # Build climate section if available
+    climate_section = ""
+    if climate:
+        climate_section = f"""
+## ROUTE CLIMATE ASSESSMENT
+| Climate Metric | Value |
+|----------------|-------|
+| **Combined Climate Risk** | {combined_risk:.0%} |
+| Flood Risk | {flood_risk:.0%} |
+| Heat Risk | {heat_risk:.0%} |
+| Air Quality Risk | {air_quality_risk:.0%} |
+"""
+
+    report = f"""
+---
+# 📋 EVACUATION CORRIDOR ANALYSIS
+
+## CORRIDOR SUMMARY
+| Field | Value |
+|-------|-------|
+| **Buffer Width** | {buffer}m each side |
+| **Total Resources** | {poi_count} facilities |
+| **Shelters/Centers** | {len(shelters)} |
+| **Medical Facilities** | {len(medical)} |
+| **Emergency Services** | {len(emergency)} |
+{climate_section}
+## WAYPOINTS ALONG ROUTE
+| # | Resource | Type | Distance |
+|---|----------|------|----------|
+"""
+    for i, poi in enumerate(pois[:10], 1):
+        report += f"| {i} | {poi.get('name', 'Unknown')[:30]} | {poi.get('type')} | {poi.get('distance_from_route_m', 0):.0f}m |\n"
+
+    if len(pois) > 10:
+        report += f"| ... | *{len(pois) - 10} more resources* | | |\n"
+
+    report += f"""
+## RESOURCES BY TYPE
+"""
+    for rtype, items in by_type.items():
+        emoji = {"hospital": "🏥", "clinic": "🏥", "pharmacy": "💊", "shelter": "🏠",
+                 "fire_station": "🚒", "police": "🚔", "community_centre": "🏛️",
+                 "library": "📚", "school": "🏫"}.get(rtype, "📍")
+        report += f"- {emoji} **{rtype}**: {len(items)} available\n"
+
+    report += f"""
+## NYC EVACUATION CORRIDOR CHECKLIST
+- [ ] Note waypoint locations before departing
+- [ ] Identify which facilities can serve as shelter points
+- [ ] Know your evacuation zone: **NYC.gov/knowyourzone**
+- [ ] Share corridor plan with family/group members
+- [ ] Have backup route in mind if primary is blocked
+
+## IF CONDITIONS WORSEN EN ROUTE
+- [ ] Seek nearest waypoint shelter immediately
+- [ ] **"Turn Around, Don't Drown"**—never walk through moving water
+- [ ] Call **911** for life-threatening emergencies
+- [ ] Call **311** for city services and shelter locations
+"""
+    report += NYC_EMERGENCY_CONTACTS
+    report += BROWNSVILLE_RESOURCES
+    report += "\n---"
+    return report
+
+
+def generate_multi_step_action_plan(all_results: list[dict], user_query: str) -> str:
+    """Generate Action Plan for multi-step queries (e.g., find shelter then hospital)."""
+
+    # Calculate totals
+    total_distance = 0
+    total_time = 0
+    step_summaries = []
+
+    for step_result in all_results:
+        step_num = step_result.get("step", "?")
+        description = step_result.get("description", "")
+        result = step_result.get("result", {})
+        tool = step_result.get("tool", "")
+
+        step_info = {
+            "step": step_num,
+            "description": description,
+            "tool": tool,
+        }
+
+        if "error" in result:
+            step_info["status"] = "❌ Error"
+            step_info["detail"] = result.get("error", "Unknown error")
+        elif "name" in result:
+            # find_nearest result
+            name = result.get("name", "Unknown")
+            dist = result.get("distance_meters", 0)
+            time_m = result.get("walking_time_minutes", 0)
+            total_distance += dist
+            total_time += time_m
+            step_info["status"] = "✅ Found"
+            step_info["name"] = name
+            step_info["distance"] = dist
+            step_info["time"] = time_m
+            step_info["climate"] = result.get("climate_metrics", {})
+        elif "success" in result:
+            # calculate_route result
+            dist = result.get("distance_meters", 0)
+            time_m = result.get("walking_time_minutes", 0)
+            total_distance += dist
+            total_time += time_m
+            step_info["status"] = "✅ Route"
+            step_info["distance"] = dist
+            step_info["time"] = time_m
+            step_info["climate"] = result.get("climate_metrics", {})
+        else:
+            step_info["status"] = "✅ Completed"
+
+        step_summaries.append(step_info)
+
+    # Build the report
+    report = f"""
+---
+# 📋 MULTI-STEP ACTION PLAN
+
+## MISSION OVERVIEW
+**Query:** {user_query}
+
+| Metric | Value |
+|--------|-------|
+| **Total Steps** | {len(step_summaries)} |
+| **Total Distance** | {total_distance:.0f}m |
+| **Total Walking Time** | {total_time:.1f} min |
+
+## STEP-BY-STEP EXECUTION
+"""
+
+    for step_info in step_summaries:
+        step_num = step_info["step"]
+        desc = step_info["description"]
+        status = step_info["status"]
+
+        report += f"\n### Step {step_num}: {desc}\n"
+        report += f"**Status:** {status}\n"
+
+        if "name" in step_info:
+            report += f"- **Found:** {step_info['name']}\n"
+        if "distance" in step_info:
+            report += f"- **Distance:** {step_info['distance']:.0f}m\n"
+        if "time" in step_info:
+            report += f"- **Walking Time:** {step_info['time']:.1f} min\n"
+
+        climate = step_info.get("climate", {})
+        if climate:
+            heat = climate.get("avg_heat_risk", 0)
+            flood = climate.get("avg_flood_risk", 0)
+            aqi = climate.get("avg_air_quality_risk", 0)
+            if heat > 0 or flood > 0 or aqi > 0:
+                report += f"- **Climate:** 🌡️ Heat: {heat:.0%} · 🌊 Flood: {flood:.0%} · 💨 Air: {aqi:.0%}\n"
+
+        if "detail" in step_info:
+            report += f"- **Detail:** {step_info['detail']}\n"
+
+    # Risk summary
+    all_climate = [s.get("climate", {}) for s in step_summaries if s.get("climate")]
+    if all_climate:
+        avg_heat = sum(c.get("avg_heat_risk", 0) for c in all_climate) / len(all_climate)
+        avg_flood = sum(c.get("avg_flood_risk", 0) for c in all_climate) / len(all_climate)
+        avg_aqi = sum(c.get("avg_air_quality_risk", 0) for c in all_climate) / len(all_climate)
+
+        risk_level = "🟢 LOW"
+        if avg_heat > 0.6 or avg_flood > 0.4:
+            risk_level = "🔴 HIGH"
+        elif avg_heat > 0.4 or avg_flood > 0.2:
+            risk_level = "🟡 MODERATE"
+
+        report += f"""
+## JOURNEY RISK ASSESSMENT
+| Risk Type | Average |
+|-----------|---------|
+| 🌡️ Heat Risk | {avg_heat:.0%} |
+| 🌊 Flood Risk | {avg_flood:.0%} |
+| 💨 Air Quality Risk | {avg_aqi:.0%} |
+| **Overall Risk Level** | {risk_level} |
+"""
+
+    # Add safety recommendations based on query content
+    report += """
+## SAFETY RECOMMENDATIONS
+"""
+    query_lower = user_query.lower()
+    if "flood" in query_lower or "storm" in query_lower:
+        report += "- 🌊 **Flooding:** Avoid flood zones. Turn Around, Don't Drown!\n"
+    if "heat" in query_lower or "hot" in query_lower:
+        report += "- 💧 **Hydration:** Bring water, take rest breaks in shade\n"
+    if "elderly" in query_lower or "grandmother" in query_lower or "grandfather" in query_lower:
+        report += "- 👴 **Mobility:** Take frequent breaks, avoid rushing\n"
+    report += "- 📍 **Navigation:** Confirm each waypoint before proceeding to next\n"
+    report += "- 📱 **Communication:** Share your plan with someone\n"
+
+    report += """
+## NYC EMERGENCY CHECKLIST
+- [ ] 📱 Phone charged for emergencies
+- [ ] 💧 Water bottle (especially in heat)
+- [ ] 💊 Medications if needed
+- [ ] 🗺️ Know evacuation zone: **NYC.gov/knowyourzone**
+- [ ] 📢 Sign up for alerts: **NYC.gov/notifynyc**
+"""
+
+    report += NYC_EMERGENCY_CONTACTS
+    report += BROWNSVILLE_RESOURCES
+    report += "\n---"
+
+    return report
+
+
+# =============================================================================
+# LLM Prompts for Action Plan Generation (NYC-Specific)
+# =============================================================================
+
+ROUTE_EXPLANATION_PROMPT = """You are an NYC Emergency Preparedness Analyst for Brownsville, Brooklyn. Generate a detailed ACTION PLAN REPORT from the route data.
+
+REQUIRED OUTPUT STRUCTURE (you MUST include ALL these sections):
+
+## 🚶 1. ROUTE SUMMARY TABLE (REQUIRED)
+| Metric | Value |
+|--------|-------|
+| 📏 Distance | [X] meters |
+| ⏱️ Walking Time | [X] minutes |
+| 🛣️ Recommended Route | [name] |
+
+## 🌡️ 2. CLIMATE RISK ASSESSMENT TABLE (REQUIRED - MUST include ALL 4 metrics)
+| Risk Type | Value | Level |
+|-----------|-------|-------|
+| 🌳 Shade Coverage | [avg_tree_coverage as %] | [emoji] [level] |
+| 🌊 Flood Risk | [avg_flood_risk as %] | [emoji] [level] |
+| ☀️ Heat Vulnerability | [avg_heat_risk as %] | [emoji] [level] |
+| 💨 Air Quality Risk | [avg_air_quality_risk as %] | [emoji] [level] |
+| 🌊 Flood Exposure | [flood_exposure_m] meters in flood zones | |
+
+CRITICAL - CLIMATE DATA INTERPRETATION:
+- avg_tree_coverage: 0-1 scale where HIGHER IS BETTER (more shade = safer in heat)
+  * < 0.3 (under 30%) = 🔴 POOR SHADE - dangerous in heat, seek shade
+  * 0.3-0.6 (30-60%) = 🟡 MODERATE SHADE - some protection
+  * > 0.6 (over 60%) = 🟢 GOOD SHADE - comfortable walk
+  * ALWAYS display this as "Shade Coverage: X%" with emoji rating
+- avg_heat_risk: 0-1 where HIGHER IS WORSE (Heat Vulnerability Index)
+- avg_air_quality_risk: 0-1 where HIGHER IS WORSE
+- avg_flood_risk: 0-1 where HIGHER IS WORSE
+- flood_exposure_m: meters of route through flood zones (0 is best)
+
+## ⚠️ 3. SAFETY RECOMMENDATIONS (REQUIRED)
+Use emoji bullets for ALL recommendations based on climate data:
+- 💧 Hydration: "Bring water, stay hydrated" (if heat risk > 0.5)
+- 🌳 Shade: "Seek shaded rest stops" (if shade coverage < 40%)
+- 🌊 Flooding: "Avoid flooded areas, X meters in flood zones" (if flood_exposure > 0)
+- 😷 Air Quality: "Wear mask if sensitive" (if air quality risk > 0.5)
+- 👴 Elderly/Mobility: "Take frequent breaks" (always for vulnerable populations)
+- 🏥 Medical: "Nearest hospital/clinic is X" (always include)
+
+## ✅ 4. NYC EMERGENCY CHECKLIST
+Use checkbox format with emojis:
+- [ ] 📱 Phone charged for emergencies
+- [ ] 💧 Water bottle (especially in heat)
+- [ ] 🧢 Sun protection (hat, sunscreen)
+- [ ] 💊 Medications if needed
+- [ ] 🗺️ Know alternate routes
+
+## 📞 5. EMERGENCY CONTACTS
+| Service | Contact |
+|---------|---------|
+| 🚨 Emergency | 911 |
+| 🏙️ NYC Services | 311 |
+| 🆘 CB16 CERT | (718) 385-0323 |
+| ❄️ Cooling Centers | Call 311 |
+
+FORMATTING RULES:
+- Use markdown tables with clear headers
+- Use LARGE VISUAL EMOJI throughout for quick scanning:
+  * 🟢 = Low Risk / Good / Safe
+  * 🟡 = Moderate / Caution
+  * 🟠 = Elevated / Warning
+  * 🔴 = High Risk / Danger / Poor
+- Today's date is {date}
+- NEVER use placeholders - use actual data from the JSON
+- Make report SCANNABLE - emergencies require quick info
+
+BROWNSVILLE RESOURCES:
+- 🏢 Brownsville Recreation Center: 1555 Linden Blvd (cooling center)
+- 📚 Stone Avenue Library: 581 Mother Gaston Blvd
+- 🚒 CB16 CERT: (718) 385-0323"""
+
+ISOCHRONE_EXPLANATION_PROMPT = """You are an NYC Emergency Preparedness Analyst. Generate an EMERGENCY COVERAGE ASSESSMENT from the reachability data.
+
+## 🗺️ 1. REACHABILITY ZONES
+Use emoji time indicators:
+- 🟢 **0-5 min**: [list resources] - IMMEDIATE access
+- 🟡 **5-10 min**: [list resources] - SHORT-TERM access
+- 🟠 **10-15 min**: [list resources] - EXTENDED access
+
+## 📍 2. RESOURCES BY CATEGORY
+| Type | Count | Nearest | Walk Time |
+|------|-------|---------|-----------|
+| 🏥 Healthcare | X | [name] | X min |
+| 🏠 Shelters | X | [name] | X min |
+| 🚒 Fire/Police | X | [name] | X min |
+| 💊 Pharmacy | X | [name] | X min |
+
+## ⚠️ 3. COVERAGE GAPS
+Flag missing critical services with 🔴
+
+## ✅ 4. NYC HOUSEHOLD CHECKLIST
+- [ ] 🗺️ Know your evacuation zone: NYC.gov/knowyourzone
+- [ ] 📱 Sign up for alerts: NYC.gov/notifynyc
+- [ ] ❄️ Nearest cooling center: Call 311
+- [ ] 📞 CB16 CERT: (718) 385-0323
+
+Use actual resource names and walking times from the data."""
+
+ALONG_ROUTE_EXPLANATION_PROMPT = """You are an NYC Emergency Preparedness Analyst. Generate an EVACUATION CORRIDOR REPORT from the route corridor data.
+
+## 🛣️ 1. CORRIDOR SUMMARY
+| Metric | Value |
+|--------|-------|
+| 📏 Buffer Width | X meters |
+| 📍 Resources Found | X total |
+| 🏥 Healthcare | X |
+| 🏠 Shelters | X |
+
+## 📍 2. WAYPOINTS TABLE
+| Resource | Type | Distance from Route |
+|----------|------|---------------------|
+| [name] | 🏥/🏠/💊 | X meters |
+
+## ⚠️ 3. NYC EVACUATION GUIDANCE
+- [ ] 🗺️ Know your zone: NYC.gov/knowyourzone
+- [ ] 🌊 "Turn Around, Don't Drown"—never walk through moving water
+- [ ] 🚨 If trapped, call 911
+- [ ] ⚡ Power issues: Con Edison 1-800-752-6633
+
+## 📞 4. EMERGENCY CONTACTS
+| Service | Contact |
+|---------|---------|
+| 🚨 Emergency | 911 |
+| 🏙️ NYC Services | 311 |
+| 🆘 CB16 CERT | (718) 385-0323 |
+
+If NO resources found:
+- 🔍 Recommend wider search buffer
+- 📞 Call 311 for nearest resources
+- 🗺️ Check NYC.gov/knowyourzone
+
+Use actual data provided. Be specific with names and distances."""
+
+MULTI_STEP_EXPLANATION_PROMPT = """You are an NYC Emergency Preparedness Analyst. Generate a MULTI-STEP EMERGENCY ACTION PLAN from the sequential query results.
+
+Include:
+1. MISSION OVERVIEW: What needs to be accomplished across all steps
+2. STEP-BY-STEP EXECUTION: For each step, summarize key finding and action
+3. TOTAL JOURNEY: Combined distance, time, climate risk assessment
+4. NYC COORDINATION CHECKLIST:
+   - [ ] Know your evacuation zone: NYC.gov/knowyourzone
+   - [ ] Sign up for alerts: NYC.gov/notifynyc
+   - [ ] Waypoint confirmations
+   - [ ] Contingency if conditions worsen
+
+5. EMERGENCY CONTACTS:
+   - 911: Life-threatening emergencies
+   - 311: City services, cooling centers
+   - CB16 CERT: (718) 385-0323
+
+Use actual data from each step. Be specific about locations, distances, and times."""
+
+# =============================================================================
+# Example Queries by Persona - Climate-Aware Emergency Routing
+# =============================================================================
+# These queries have been tested and validated with 80%+ success rate in E2E tests.
+# Mix of NYCHA housing names and street addresses from places.csv for realistic scenarios.
+
+# CERT / Emergency Response Team - Evacuation & Corridor Analysis
+CERT_EXAMPLES = [
+    # find_along_route - 24 POIs found in test
+    "What resources are along the evacuation route from Van Dyke Houses to Betsy Head Park?",
+    # generate_isochrone - 20 resources found
+    "Show CERT response coverage from Betsy Head Park - 10 minute window",
+    # calculate_route with flood params
+    "Emergency response route from FDNY Rescue Company 2 to Betsy Head Park during flood conditions",
+    # calculate_route - 565m, 7.5min
+    "CERT deployment - fastest route from FDNY Engine 283 Division 15 to 753 Thomas S. Boyland Street",
+]
+
+# Urban Planner / Community Board - Coverage & Access Analysis
+PLANNING_EXAMPLES = [
+    # generate_isochrone - 20 resources
+    "What resources can residents of 457 Blake Avenue reach in 10 minutes?",
+    # generate_isochrone - multi-time analysis
+    "Assess emergency access coverage from Marcus Garvey Houses in 5, 10, 15 minutes",
+    # generate_isochrone - 20 resources
+    "What emergency resources are within 15 minutes walking from 663 Mother Gaston Blvd?",
+]
+
+# Healthcare / Social Worker - Patient Transport & Access
+HEALTHCARE_EXAMPLES = [
+    # calculate_route - 431m, 5.7min with heat/shade params
+    "It's 98 degrees and my elderly father needs to walk to Brookdale Hospital Medical Center from 899 Saratoga Avenue",
+    # calculate_route - 2258m, 30.1min with AQI params
+    "My patient has asthma - what's the best air quality route from 424 Mother Gaston Blvd to Brookdale Hospital Medical Center?",
+    # find_nearest - 250m
+    "Find the closest clinic to 35 Newport Street",
+    # find_nearest - 589m
+    "Where is the nearest hospital from 867 Saratoga Avenue?",
+]
+
+# Resident / Family - Emergency & Vulnerable Population Support
+RESIDENT_EXAMPLES = [
+    # calculate_route - 1746m, 23.3min with heat params
+    "I need to get my elderly mother to Brookdale Hospital Medical Center from 177 Chester Street during this heat wave",
+    # find_nearest - 723m
+    "Where is the nearest shelter from 550 Saratoga Avenue?",
+    # find_nearest - 174m
+    "Find the nearest cooling center from 456 Sutter Avenue during this heat wave",
+    # calculate_route - 93m, 1.2min
+    "Heat wave alert - need a shaded route from 45 Newport Street to Lincoln Terrace Park for my grandmother",
+]
+
+# Multi-step planning with climate awareness
+MULTI_STEP_EXAMPLES = [
+    "Find the nearest shelter from Howard Houses, then find the closest hospital from there",
+]
+
+# Climate-safe routing (showcase climate features)
+CLIMATE_EXAMPLES = [
+    # calculate_route with flood params - 687m, 9.2min
+    "Storm surge warning - route from 360 Legion Street to Brookdale Hospital Medical Center avoiding flood zones",
+    # calculate_route with AQI params - 595m, 7.9min
+    "I have COPD and need to walk to BROWNSVILLE CHILD HEALTH CLINIC from 255 Legion Street - find a route with good air quality",
+    # calculate_route - 372m, 5.0min
+    "My grandmother has difficulty breathing. What's the safest route from 1413 Pitkin Avenue to RALPH AVENUE HEALTH CENTER?",
+    # calculate_route - 1049m, 14.0min
+    "Route from 1728 Pitkin Avenue to Betsy Head Park",
+]
+
+# Multilingual queries (Spanish, Haitian Creole - common languages in Brownsville)
+# These demonstrate the app's ability to understand queries in multiple languages
+MULTILINGUAL_EXAMPLES = [
+    # Spanish find_nearest - 967m
+    "¿Dónde está el hospital más cercano de 122 Dumont Avenue?",
+    # Spanish find_nearest - 555m
+    "¿Dónde está el refugio más cercano de Howard Houses? Hay una tormenta fuerte.",
+    # Spanish calculate_route - 689m, 9.2min
+    "Ruta segura desde 540 Chester Street hasta Brookdale Hospital Medical Center durante la inundación",
+    # Haitian Creole find_nearest - 207m
+    "Pitit mwen malad - ki klinik ki pi pre 189 Dumont Avenue?",
+    # Haitian Creole find_nearest - 2096m
+    "Ki lopital ki pi pre 333 Dumont Avenue?",
+    # Spanish generate_isochrone - 20 resources
+    "¿Qué recursos están a 10 minutos caminando de 651 Mother Gaston Boulevard?",
+]
+
+# Combined sample list for random display
+SAMPLE_QUERIES = CERT_EXAMPLES + PLANNING_EXAMPLES + HEALTHCARE_EXAMPLES + RESIDENT_EXAMPLES + CLIMATE_EXAMPLES + MULTILINGUAL_EXAMPLES
+
+# =============================================================================
+# LLM Helpers
+# =============================================================================
+
+def call_llm_tool_selection(query: str, model: str, use_embeddings: bool = True, use_grammar: bool = True, original_query: str = None) -> dict:
+    """Call LLM to select appropriate tool.
+
+    "Less is More" approach: Use embeddings to pre-filter to top-k tools,
+    then send only those to the LLM. This reduces context size and improves
+    accuracy + speed.
+
+    IMPORTANT: When use_embeddings=True and use_grammar=True, we generate a
+    DYNAMIC grammar that only allows the embedding-selected tools. This prevents
+    the LLM from hallucinating tools that weren't in the pre-selected set.
+
+    Args:
+        query: User query to process (may be geocoded with lat/lon)
+        model: Model name to use
+        use_embeddings: Whether to use embedding-based tool pre-filtering
+        use_grammar: Whether to use GBNF grammar for type-safe output
+        original_query: Original user query before geocoding (used for embedding selection)
+                       If None, uses query parameter for embeddings too
+    """
+    try:
+        # Step 1: Use embeddings to select top-k most relevant tools
+        # Use original_query for embedding selection if provided (preserves semantic meaning
+        # before geocoding replaces location names with lat/lon coordinates)
+        selected_tools = None
+        if use_embeddings:
+            embedding_query = original_query if original_query else query
+            selected_tools = select_tool_by_embedding(embedding_query, top_k=2)
+            system_prompt = build_minimal_tool_prompt(selected_tools)
+        else:
+            system_prompt = TOOL_SELECTION_PROMPT
+
+        # Step 2: Build request with optional GBNF grammar constraint
+        request_json = {
+            "model": get_current_model(),
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": query},
+            ],
+            "stream": False,
+            "format": "json",
+        }
+
+        # Add GBNF grammar for type-safe output
+        # CRITICAL: When using embeddings, use dynamic grammar to ENFORCE that the
+        # LLM can only output tools from the embedding-selected set.
+        if use_grammar:
+            if use_embeddings and selected_tools:
+                # Dynamic grammar constrained to selected tools only
+                grammar = build_dynamic_grammar(selected_tools)
+            else:
+                # Full grammar with all tools
+                grammar = TOOL_SELECTION_GRAMMAR
+            request_json["options"] = {
+                "grammar": grammar
+            }
+
+        # Step 3: Call LLM with reduced tool set
+        response = requests.post(
+            OLLAMA_URL,
+            json=request_json,
+            timeout=60,
+        )
+        response.raise_for_status()
+        content = response.json().get("message", {}).get("content", "{}")
+        return json.loads(content)
+    except requests.exceptions.ConnectionError:
+        return {"error": "Cannot connect to Ollama. Is it running?"}
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON from LLM: {e}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def call_llm_explain_result(user_query: str, result: dict, model: str, tool_name: str) -> str:
+    """Call LLM to generate detailed action plan based on tool type.
+
+    Uses local Ollama model for action plan generation.
+    """
+    # Select appropriate prompt based on tool type
+    if tool_name == "generate_isochrone":
+        system_prompt = ISOCHRONE_EXPLANATION_PROMPT
+    elif tool_name == "find_along_route":
+        system_prompt = ALONG_ROUTE_EXPLANATION_PROMPT
+    elif tool_name == "multi_step":
+        system_prompt = MULTI_STEP_EXPLANATION_PROMPT
+    else:
+        system_prompt = ROUTE_EXPLANATION_PROMPT
+
+    # Inject today's date into prompt
+    today = datetime.now().strftime("%B %d, %Y")
+    system_prompt = system_prompt.replace("{date}", today)
+
+    prompt = f'User asked: "{user_query}"\n\nAnalysis result:\n{json.dumps(result, indent=2)}\n\nGenerate the comprehensive report as specified.'
+
+    try:
+        response = requests.post(
+            OLLAMA_URL,
+            json={
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt},
+                ],
+                "stream": False,
+            },
+            timeout=120,  # Longer timeout for detailed reports
+        )
+        response.raise_for_status()
+        content = response.json().get("message", {}).get("content", "")
+
+        # Validate response - reject if it looks like a tool call or JSON instead of a report
+        if not content or content.strip().startswith("[{") or content.strip().startswith('{"'):
+            return ""  # Return empty to trigger fallback
+
+        # Basic sanity check - report should have some readable content
+        if len(content) < 100:
+            return ""
+
+        return content
+    except Exception:
+        return ""
+
+
+# =============================================================================
+# Display Helpers
+# =============================================================================
+
+def render_map(map_data: dict | None, resources_df) -> folium.Map:
+    """Render Folium map with routes, isochrones, and markers."""
+    m = folium.Map(
+        location=[BROWNSVILLE_CENTER["lat"], BROWNSVILLE_CENTER["lon"]],
+        zoom_start=14,
+        tiles="OpenStreetMap"
+    )
+
+    # Resource markers - using POI type-specific styling
+    if resources_df is not None:
+        for _, row in resources_df.iterrows():
+            poi_type = row.get("type", "facility")
+            style = get_poi_marker_style(poi_type)
+            folium.CircleMarker(
+                location=[row["lat"], row["lon"]],
+                radius=style["radius"],
+                color=style["color"],
+                fill=True,
+                fillColor=style["fill_color"],
+                fillOpacity=0.7,
+                popup=f"<b>{row['name']}</b><br>{row['type']}"
+            ).add_to(m)
+
+    if not map_data:
+        return m
+
+    # Isochrones (render first so routes appear on top)
+    if "isochrones" in map_data:
+        # Render in reverse order so smaller isochrones appear on top
+        for iso in reversed(map_data["isochrones"]):
+            if iso.get("polygon_coords"):
+                folium.Polygon(
+                    locations=iso["polygon_coords"],
+                    color=iso.get("color", "#6366f1"),
+                    fill=True,
+                    fillColor=iso.get("color", "#6366f1"),
+                    fillOpacity=0.2,
+                    weight=2,
+                    tooltip=f"{iso['time_min']} min walking"
+                ).add_to(m)
+
+    # Resources within isochrone - using POI type-specific styling
+    if "resources_within" in map_data:
+        for res in map_data["resources_within"]:
+            poi_type = res.get("type", "facility")
+            style = get_poi_marker_style(poi_type)
+            folium.CircleMarker(
+                location=[res["lat"], res["lon"]],
+                radius=style["radius"] + 1,  # Slightly larger to stand out
+                color=style["color"],
+                fill=True,
+                fillColor=style["fill_color"],
+                fillOpacity=0.9,
+                popup=f"<b>{res['name']}</b><br>{res['type']}<br>{res['walking_time_minutes']:.1f} min"
+            ).add_to(m)
+
+    # Multiple routes
+    if "routes" in map_data:
+        for route in map_data["routes"]:
+            folium.PolyLine(
+                route["coords"],
+                weight=5,
+                color=route.get("color", "#3b82f6"),
+                opacity=0.8,
+                tooltip=route.get("label", "Route")
+            ).add_to(m)
+    # Single route fallback
+    elif "route_coords" in map_data:
+        folium.PolyLine(
+            map_data["route_coords"],
+            weight=5,
+            color="#3b82f6",
+            opacity=0.8
+        ).add_to(m)
+
+    # Origin marker
+    if "origin" in map_data:
+        folium.Marker(
+            map_data["origin"],
+            popup="Start",
+            icon=folium.Icon(color="green", icon="play")
+        ).add_to(m)
+
+    # Destination marker
+    if "destination" in map_data:
+        folium.Marker(
+            map_data["destination"],
+            popup=f"{map_data.get('dest_name', 'Destination')}<br>{map_data.get('distance', 0):.0f}m",
+            icon=folium.Icon(color="red", icon="flag")
+        ).add_to(m)
+
+    # Waypoints for multi-step queries (intermediate stops)
+    if "waypoints" in map_data:
+        waypoint_colors = ["blue", "purple", "orange", "darkred", "cadetblue"]
+        for i, wp in enumerate(map_data["waypoints"]):
+            if wp.get("is_final"):
+                continue  # Skip final destination, it's already rendered above
+            coords = wp.get("coords")
+            if coords:
+                color = waypoint_colors[i % len(waypoint_colors)]
+                folium.Marker(
+                    coords,
+                    popup=f"<b>Step {wp.get('step', i+1)}</b><br>{wp.get('name', 'Waypoint')}",
+                    icon=folium.Icon(color=color, icon="info-sign")
+                ).add_to(m)
+
+    # Geocoded location
+    if "geocoded_location" in map_data:
+        geo = map_data["geocoded_location"]
+        folium.CircleMarker(
+            [geo["lat"], geo["lon"]],
+            radius=8,
+            color="#fbbf24",
+            fill=True,
+            fillColor="#fbbf24",
+            fillOpacity=0.9,
+            popup=f"📍 {geo['name']}"
+        ).add_to(m)
+
+    # POIs along route (rendered last so they appear on top of routes and other markers)
+    # Uses POI type-specific styling for visual differentiation
+    if "pois_along_route" in map_data:
+        for poi in map_data["pois_along_route"]:
+            poi_type = poi.get("type", "facility")
+            style = get_poi_marker_style(poi_type)
+            folium.CircleMarker(
+                location=[poi["lat"], poi["lon"]],
+                radius=style["radius"] + 2,  # Larger to stand out along route
+                color=style["color"],
+                fill=True,
+                fillColor=style["fill_color"],
+                fillOpacity=0.9,
+                weight=2,
+                popup=f"<b>{poi['name']}</b><br>{poi['type']}<br>{poi['distance_from_route_m']:.0f}m from route"
+            ).add_to(m)
+
+    return m
+
+
+def format_route_metrics(metrics: dict) -> str:
+    """Format route metrics as a string."""
+    if not metrics:
+        return ""
+    emoji = {"flat": "🟢", "moderate": "🟡", "hilly": "🔴"}.get(metrics.get("difficulty", ""), "⚪")
+    parts = [
+        f"{emoji} **{metrics.get('difficulty', 'unknown').title()}** terrain",
+        f"↗️ +{metrics.get('elevation_gain_m', 0)}m / ↘️ -{metrics.get('elevation_loss_m', 0)}m"
+    ]
+    if metrics.get("max_grade_pct", 0) > 0:
+        parts.append(f"⛰️ Max grade: {metrics['max_grade_pct']:.1f}%")
+    return " · ".join(parts)
+
+
+def format_climate_metrics(climate: dict) -> str:
+    """Format climate risk metrics as a string.
+
+    Note: Risk values are normalized indices (0.0-1.0 scale), NOT percentages.
+    - flood_risk: FEMA flood zone risk (0=none, 1=high risk zone)
+    - heat_risk: Heat Vulnerability Index (0=low, 1=high vulnerability)
+    - air_quality_risk: Air quality risk index (0=good, 1=poor)
+    """
+    if not climate:
+        return ""
+
+    # Determine overall risk level
+    avg_risk = climate.get("avg_climate_risk", 0)
+    if avg_risk < 0.2:
+        risk_level = "Low"
+        emoji = "🟢"
+    elif avg_risk < 0.4:
+        risk_level = "Moderate"
+        emoji = "🟡"
+    elif avg_risk < 0.6:
+        risk_level = "Elevated"
+        emoji = "🟠"
+    else:
+        risk_level = "High"
+        emoji = "🔴"
+
+    parts = [f"{emoji} **{risk_level} climate risk**"]
+
+    # Add flood info if significant
+    flood_risk = climate.get("avg_flood_risk", 0)
+    if flood_risk > 0.1:
+        flood_exposure = climate.get("flood_exposure_m", 0)
+        if flood_exposure > 0:
+            parts.append(f"🌊 {flood_exposure:.0f}m flood-prone")
+        else:
+            # Show as index value, not percentage
+            flood_label = "Low" if flood_risk < 0.3 else "Moderate" if flood_risk < 0.6 else "High"
+            parts.append(f"🌊 Flood: {flood_label}")
+
+    # Add heat info if significant (HVI index, not percentage)
+    heat_risk = climate.get("avg_heat_risk", 0)
+    if heat_risk > 0.2:
+        # Convert to HVI-style label (1-5 scale commonly used)
+        hvi_approx = 1 + heat_risk * 4  # Maps 0-1 to 1-5
+        parts.append(f"🌡️ HVI: {hvi_approx:.1f}/5")
+
+    # Add air quality info if significant
+    air_quality_risk = climate.get("avg_air_quality_risk", 0)
+    if air_quality_risk > 0.2:
+        # Show as qualitative label
+        aqi_label = "Good" if air_quality_risk < 0.3 else "Moderate" if air_quality_risk < 0.6 else "Poor"
+        parts.append(f"💨 Air: {aqi_label}")
+
+    # Add tree coverage if available
+    tree_coverage = climate.get("avg_tree_coverage", 0)
+    if tree_coverage > 0:
+        shade_label = "Low" if tree_coverage < 0.3 else "Moderate" if tree_coverage < 0.6 else "Good"
+        parts.append(f"🌳 Shade: {shade_label}")
+
+    return " · ".join(parts)
+
+
+def format_result(tool_name: str, result: dict) -> str:
+    """Format tool result for chat display."""
+    if "error" in result:
+        return f"❌ {result['error']}"
+
+    if tool_name == "find_nearest":
+        if result.get("found"):
+            lines = [
+                f"✅ **{result['name']}** ({result['type']})",
+                f"📍 {result['distance_meters']:.0f}m away · 🚶 {result['walking_time_minutes']:.1f} min walk"
+            ]
+            if "route_metrics" in result:
+                lines.append(format_route_metrics(result["route_metrics"]))
+            if "climate_metrics" in result:
+                lines.append(format_climate_metrics(result["climate_metrics"]))
+            return "\n".join(lines)
+        return f"No {result.get('resource_type', 'resources')} found nearby"
+
+    if tool_name == "list_resources":
+        count = result.get("total_count", 0)
+        lines = [f"Found **{count}** resources:"]
+        for r in result.get("resources", [])[:5]:
+            lines.append(f"• {r['name']} ({r['type']})")
+        if count > 5:
+            lines.append(f"_...and {count - 5} more_")
+        return "\n".join(lines)
+
+    if tool_name == "calculate_route":
+        alternatives = result.get("alternatives", [])
+        climate_aware = result.get("climate_aware", False)
+
+        if len(alternatives) > 1:
+            colors = {"shortest": "🔵", "flattest": "🟢", "balanced": "🟠", "safest": "🌿"}
+            lines = ["**Route Options:**\n"]
+            for alt in alternatives:
+                indicator = colors.get(alt["name"], "⚪")
+                check = " ✓" if alt["name"] == result.get("recommended") else ""
+                metrics = alt.get("route_metrics", {})
+
+                # Build the line with basic info
+                line = (
+                    f"{indicator} **{alt['label']}**{check}: "
+                    f"{alt['distance_meters']:.0f}m · {alt['walking_time_minutes']:.1f} min"
+                )
+
+                # Add elevation info
+                if metrics.get('elevation_gain_m', 0) > 0:
+                    line += f" · +{metrics['elevation_gain_m']}m climb"
+
+                # Add climate risk info for each alternative if available
+                if "climate_metrics" in alt:
+                    climate = alt["climate_metrics"]
+                    risk = climate.get("avg_climate_risk", 0)
+                    if risk < 0.2:
+                        line += " · 🟢 Low risk"
+                    elif risk < 0.4:
+                        line += " · 🟡 Mod risk"
+                    elif risk < 0.6:
+                        line += " · 🟠 Elevated"
+                    else:
+                        line += " · 🔴 High risk"
+
+                lines.append(line)
+
+            if climate_aware:
+                lines.append("\n_Climate-aware routing enabled. Recommended route (✓) minimizes flood & heat exposure._")
+            else:
+                lines.append("\n_Recommended route shown with ✓_")
+            return "\n".join(lines)
+        else:
+            lines = [f"📏 {result['distance_meters']:.0f}m · 🚶 {result['walking_time_minutes']:.1f} min walk"]
+            if "route_metrics" in result:
+                lines.append(format_route_metrics(result["route_metrics"]))
+            if "climate_metrics" in result:
+                lines.append(format_climate_metrics(result["climate_metrics"]))
+            return "\n".join(lines)
+
+    if tool_name == "generate_isochrone":
+        isochrones = result.get("isochrones", [])
+        resources = result.get("resources_within", [])
+        lines = ["**🗺️ Reachable Area Analysis**\n"]
+
+        for iso in isochrones:
+            emoji = {"5": "🟢", "10": "🟡", "15": "🟠", "20": "🔴"}.get(str(iso["time_min"]), "⚪")
+            lines.append(f"{emoji} **{iso['time_min']} min**: {iso['node_count']} intersections reachable")
+
+        if resources:
+            lines.append(f"\n**📍 {len(resources)} resources within reach:**")
+            for r in resources[:8]:
+                lines.append(f"• {r['name']} ({r['type']}) - {r['walking_time_minutes']:.1f} min")
+            if len(resources) > 8:
+                lines.append(f"_...and {len(resources) - 8} more_")
+
+        return "\n".join(lines)
+
+    if tool_name == "find_along_route":
+        pois = result.get("pois_found", [])
+        buffer = result.get("buffer_meters", 100)
+
+        if not pois:
+            return f"No resources found within {buffer}m of the route"
+
+        lines = [f"**🛤️ Found {len(pois)} resources along the route** (within {buffer}m)\n"]
+
+        # Group by type
+        by_type = {}
+        for poi in pois:
+            t = poi["type"]
+            if t not in by_type:
+                by_type[t] = []
+            by_type[t].append(poi)
+
+        for resource_type, items in by_type.items():
+            lines.append(f"**{resource_type}** ({len(items)}):")
+            for item in items[:3]:
+                lines.append(f"  • {item['name']} ({item['distance_from_route_m']}m from route)")
+            if len(items) > 3:
+                lines.append(f"  _...and {len(items) - 3} more_")
+
+        return "\n".join(lines)
+
+    return json.dumps(result, indent=2)
+
+
+# =============================================================================
+# Main App - Two Column Layout
+# =============================================================================
+
+# Additional session state for action plan output
+if "action_plan" not in st.session_state:
+    st.session_state.action_plan = None
+
+
+def main():
+    engine = st.session_state.engine
+
+    # Load engine and warmup LLM on first run
+    if not engine.is_loaded:
+        with st.spinner("Loading network data..."):
+            engine.load()
+
+    # Warmup LLM in background
+    # Note: Embedding model loads lazily on first query to speed up startup
+    with st.spinner("Warming up LLM..."):
+        llm_ready = warmup_llm(get_current_model())
+
+    # --- Header ---
+    st.title("🚨 Emergency Routing Assistant")
+    st.caption("Climate-aware emergency services for Brownsville, Brooklyn")
+
+    # --- Sidebar with example queries ---
+    with st.sidebar:
+        st.header("📊 Status")
+
+        if engine.is_loaded:
+            st.success("✓ Network loaded")
+            st.caption(f"{engine.resource_count} resources · {engine.node_count:,} nodes")
+        else:
+            st.error("Failed to load network")
+
+        if llm_ready:
+            st.success("✓ LLM ready")
+        else:
+            st.warning("⚠ LLM not available (check Ollama)")
+
+        # Model selection dropdown
+        st.divider()
+        st.markdown("### Model Selection")
+        selected = st.selectbox(
+            "LLM Model",
+            options=list(AVAILABLE_MODELS.keys()),
+            index=list(AVAILABLE_MODELS.keys()).index(st.session_state.selected_model),
+            help="Qwen 2.5 3B is faster, xLAM 8B is more accurate for function calling"
+        )
+        if selected != st.session_state.selected_model:
+            st.session_state.selected_model = selected
+            st.rerun()
+
+        st.divider()
+        if st.button("🗑️ Clear All", use_container_width=True):
+            st.session_state.messages = []
+            st.session_state.map_data = None
+            st.session_state.action_plan = None
+            st.rerun()
+
+        st.divider()
+        st.markdown("### Example Queries")
+
+        st.markdown("**🚒 CERT / Emergency:**")
+        for ex in CERT_EXAMPLES:
+            if st.button(ex, key=f"cert_{ex[:20]}", use_container_width=True):
+                st.session_state.pending_query = ex
+                st.rerun()
+
+        st.markdown("**🏥 Healthcare:**")
+        for ex in HEALTHCARE_EXAMPLES:
+            if st.button(ex, key=f"health_{ex[:20]}", use_container_width=True):
+                st.session_state.pending_query = ex
+                st.rerun()
+
+        st.markdown("**🏠 Resident:**")
+        for ex in RESIDENT_EXAMPLES:
+            if st.button(ex, key=f"resident_{ex[:20]}", use_container_width=True):
+                st.session_state.pending_query = ex
+                st.rerun()
+
+        st.markdown("**📋 Multi-step:**")
+        for ex in MULTI_STEP_EXAMPLES:
+            if st.button(ex, key=f"multi_{ex[:20]}", use_container_width=True):
+                st.session_state.pending_query = ex
+                st.rerun()
+
+        st.markdown("**🌡️ Climate-Safe:**")
+        for ex in CLIMATE_EXAMPLES:
+            if st.button(ex, key=f"climate_{ex[:20]}", use_container_width=True):
+                st.session_state.pending_query = ex
+                st.rerun()
+
+    # ==========================================================================
+    # TWO-COLUMN LAYOUT: Chat (left) | Map (right)
+    # ==========================================================================
+    col_chat, col_map = st.columns([1, 1], gap="medium")
+
+    # --- LEFT COLUMN: Chat Input & History ---
+    with col_chat:
+        st.subheader("💬 Query")
+
+        # Chat input at the top
+        pending = st.session_state.pop("pending_query", None)
+        prompt = st.chat_input("Ask about emergency services...") or pending
+
+        # Processing indicator placeholder (appears in chat column)
+        processing_placeholder = st.empty()
+
+        # Chat history
+        chat_container = st.container(height=350)
+        with chat_container:
+            if not st.session_state.messages:
+                st.info("Enter a query above or select an example from the sidebar.")
+            for msg in st.session_state.messages:
+                with st.chat_message(msg["role"]):
+                    st.markdown(msg["content"])
+
+    # --- RIGHT COLUMN: Map ---
+    with col_map:
+        st.subheader("🗺️ Map")
+        m = render_map(st.session_state.map_data, engine.resources_df)
+        st_folium(m, width=None, height=400, returned_objects=[])
+
+    # ==========================================================================
+    # ACTION PLAN OUTPUT - Below the two columns
+    # ==========================================================================
+    st.divider()
+    st.subheader("📋 Action Plan Report")
+
+    action_plan_container = st.container()
+    with action_plan_container:
+        if st.session_state.action_plan:
+            st.markdown(st.session_state.action_plan)
+        else:
+            st.info("Action plan will appear here after you submit a query.")
+
+    # ==========================================================================
+    # QUERY PROCESSING (uses placeholder in chat column for spinner)
+    # ==========================================================================
+    if prompt:
+        if not engine.is_loaded:
+            st.error("Network not loaded")
+            st.stop()
+
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        # Helper to show thinking status
+        def show_status(message: str):
+            processing_placeholder.info(f"🤔 {message}")
+
+        # Geocode locations
+        show_status("Recognizing locations...")
+        modified_query, geocoded = engine.geocode_query(prompt)
+
+        # Check if this is a multi-step query
+        if is_multi_step_query(prompt):
+            show_status("Planning multi-step query...")
+            plan = call_llm_planner(modified_query)
+
+            if plan.get("multi_step") and plan.get("steps"):
+                steps = plan.get("steps", [])
+                for i, step in enumerate(steps, 1):
+                    show_status(f"Executing step {i}/{len(steps)}: {step.get('description', 'Processing')}...")
+
+                all_results, all_map_data = execute_multi_step_plan(plan, engine)
+
+                # Merge map data from all steps
+                merged_map_data = merge_multi_step_map_data(all_map_data)
+                if geocoded:
+                    merged_map_data["geocoded_location"] = list(geocoded.values())[0]
+                st.session_state.map_data = merged_map_data
+
+                # Format chat response (brief summary)
+                chat_parts = []
+                if geocoded:
+                    geo_text = ", ".join([f"📍 {k} ({v['lat']:.4f}, {v['lon']:.4f})" for k, v in geocoded.items()])
+                    chat_parts.append(f"_Geocoded: {geo_text}_")
+                chat_parts.append(format_multi_step_results(all_results))
+
+                chat_response = "\n\n".join(chat_parts)
+                st.session_state.messages.append({"role": "assistant", "content": chat_response})
+
+                # Generate action plan for separate display (code-based, no LLM needed)
+                show_status("Generating action plan report...")
+                st.session_state.action_plan = generate_multi_step_action_plan(all_results, prompt)
+
+                processing_placeholder.empty()
+                st.rerun()
+
+        # Single-step query (default flow)
+        show_status("Selecting appropriate tool...")
+        # Pass original prompt for embedding selection (before geocoding replaces location names)
+        tool_call = call_llm_tool_selection(modified_query, get_current_model(), original_query=prompt)
+
+        if "error" in tool_call:
+            chat_response = f"❌ {tool_call['error']}"
+            st.session_state.action_plan = None
+            st.session_state.messages.append({"role": "assistant", "content": chat_response})
+            processing_placeholder.empty()
+            st.rerun()
+
+        tool_name = tool_call.get("name", "")
+        tool_args = tool_call.get("arguments", {})
+
+        # Show what we're doing
+        tool_labels = {
+            "find_nearest": "Finding nearest resource...",
+            "list_resources": "Listing resources...",
+            "calculate_route": "Computing climate-safe route...",
+            "generate_isochrone": "Calculating reachable area...",
+            "find_along_route": "Finding resources along route...",
+        }
+        show_status(tool_labels.get(tool_name, "Executing query..."))
+
+        # Execute
+        result, map_data = execute_tool(tool_name, tool_args, engine)
+
+        # Update map
+        if map_data:
+            if geocoded:
+                map_data["geocoded_location"] = list(geocoded.values())[0]
+            st.session_state.map_data = map_data
+
+        # Format chat response (brief summary)
+        chat_parts = []
+        if geocoded:
+            geo_text = ", ".join([f"📍 {k} ({v['lat']:.4f}, {v['lon']:.4f})" for k, v in geocoded.items()])
+            chat_parts.append(f"_Geocoded: {geo_text}_")
+        chat_parts.append(format_result(tool_name, result))
+        chat_response = "\n\n".join(chat_parts)
+
+        # Store result and display immediately
+        st.session_state.messages.append({"role": "assistant", "content": chat_response})
+
+        # Generate action plan for separate display (show status while generating)
+        if tool_name in ("find_nearest", "calculate_route", "generate_isochrone", "find_along_route") and "error" not in result:
+            # Show placeholder while generating
+            show_status("📋 Generating action plan report...")
+
+            # Try LLM explanation first (uses local Ollama model)
+            explanation = call_llm_explain_result(prompt, result, get_current_model(), tool_name)
+            if explanation:
+                st.session_state.action_plan = explanation
+            else:
+                # Fallback: use code-based report generation
+                if tool_name in ("find_nearest", "calculate_route"):
+                    st.session_state.action_plan = generate_route_action_plan(result, prompt)
+                elif tool_name == "generate_isochrone":
+                    st.session_state.action_plan = generate_isochrone_report(result, prompt)
+                elif tool_name == "find_along_route":
+                    st.session_state.action_plan = generate_corridor_report(result, prompt)
+        else:
+            st.session_state.action_plan = None
+
+        processing_placeholder.empty()
+        st.rerun()
+
+
+if __name__ == "__main__":
+    main()

core/__init__.py

@@ -0,0 +1,12 @@
+"""Core routing and engine logic."""
+
+from .engine import RoutingEngine, execute_tool, BROWNSVILLE_CENTER, POI_MARKER_STYLES
+from .config import *
+from .tools import *
+
+__all__ = [
+    "RoutingEngine",
+    "execute_tool",
+    "BROWNSVILLE_CENTER",
+    "POI_MARKER_STYLES",
+]

core/config.py

@@ -0,0 +1,301 @@
+"""
+Configuration File for Emergency Routing Assistant UI
+Customize colors, icons, languages, and behavior here
+"""
+
+# =============================================================================
+# Application Settings
+# =============================================================================
+
+APP_CONFIG = {
+    "title": "Emergency Routing Assistant",
+    "page_icon": "🚨",
+    "layout": "wide",
+    "initial_sidebar_state": "expanded",
+    "theme": {
+        "primaryColor": "#ef4444",
+        "backgroundColor": "#0f172a",
+        "secondaryBackgroundColor": "#1e293b",
+        "textColor": "#f1f5f9",
+        "font": "Outfit"
+    }
+}
+
+# =============================================================================
+# Map Configuration
+# =============================================================================
+
+MAP_CONFIG = {
+    "default_zoom": 14,
+    "min_zoom": 10,
+    "max_zoom": 18,
+    "default_style": "light",  # Options: light, dark, street, satellite
+    "show_scale": True,
+    "show_fullscreen_button": True,
+    "cluster_resources": False,  # Set to True to cluster nearby markers
+    "cluster_distance": 50,  # pixels
+}
+
+# Center point for Brownsville, Brooklyn
+BROWNSVILLE_CENTER = {
+    "lat": 40.6694,
+    "lon": -73.9125,
+    "name": "Brownsville, Brooklyn"
+}
+
+# =============================================================================
+# Feature Flags
+# =============================================================================
+
+FEATURES = {
+    "voice_recording": True,
+    "media_upload": True,
+    "multi_language": True,
+    "emergency_banner": True,
+    "route_alternatives": True,
+    "isochrone_analysis": True,
+    "resources_along_route": True,
+    "real_time_updates": False,  # Future feature
+    "offline_mode": False,  # Future feature
+    "push_notifications": False,  # Future feature
+}
+
+# =============================================================================
+# UI Behavior Settings
+# =============================================================================
+
+UI_SETTINGS = {
+    "auto_dismiss_banner": False,  # Auto-dismiss emergency banner after X seconds
+    "banner_dismiss_timeout": 10,  # seconds
+    "animation_speed": "normal",  # Options: slow, normal, fast, none
+    "show_coordinates": True,  # Show lat/lon in geocoding results
+    "max_chat_messages": 100,  # Maximum chat history to keep
+    "default_language": "en",
+    "map_height": 500,  # pixels
+    "enable_dark_mode": True,
+}
+
+# =============================================================================
+# Resource Display Settings
+# =============================================================================
+
+RESOURCE_DISPLAY = {
+    "show_all_on_load": True,  # Show all resources when page loads
+    "max_results_display": 10,  # Maximum results to show in list
+    "highlight_nearest": True,  # Highlight nearest resource
+    "show_walking_time": True,
+    "show_distance": True,
+    "group_by_category": True,
+}
+
+# =============================================================================
+# Route Calculation Settings
+# =============================================================================
+
+ROUTE_SETTINGS = {
+    "default_profile": "foot-walking",  # walking profile
+    "calculate_alternatives": True,
+    "max_alternatives": 3,
+    "prefer_flat_routes": True,  # For accessibility
+    "avoid_stairs": False,  # Future feature
+    "max_route_distance": 10000,  # meters (10km max)
+}
+
+# =============================================================================
+# Isochrone Settings
+# =============================================================================
+
+ISOCHRONE_SETTINGS = {
+    "default_time_limits": [5, 10, 15],  # minutes
+    "max_time_limit": 30,  # minutes
+    "show_resources_within": True,
+    "resource_limit": 50,  # max resources to show
+}
+
+# =============================================================================
+# Media Upload Settings
+# =============================================================================
+
+MEDIA_SETTINGS = {
+    "max_file_size": 10 * 1024 * 1024,  # 10MB
+    "allowed_image_types": ["jpg", "jpeg", "png", "gif"],
+    "allowed_video_types": ["mp4", "mov", "avi", "webm"],
+    "save_to_disk": False,  # Save uploaded files to disk
+    "upload_directory": "./uploads",
+}
+
+# =============================================================================
+# Voice Recording Settings
+# =============================================================================
+
+VOICE_SETTINGS = {
+    "max_recording_duration": 300,  # seconds (5 minutes)
+    "audio_format": "wav",
+    "sample_rate": 44100,
+    "save_recordings": False,
+    "recording_directory": "./recordings",
+}
+
+# =============================================================================
+# Notification Settings
+# =============================================================================
+
+NOTIFICATION_SETTINGS = {
+    "enable_success_messages": True,
+    "enable_error_messages": True,
+    "enable_info_messages": True,
+    "auto_clear_messages": True,
+    "message_duration": 3,  # seconds
+}
+
+# =============================================================================
+# Emergency Response Settings
+# =============================================================================
+
+EMERGENCY_SETTINGS = {
+    "priority_resources": ["hospital", "fire_station", "police"],
+    "emergency_phone": "911",
+    "show_emergency_contacts": True,
+    "emergency_contacts": {
+        "Police": "911",
+        "Fire": "911",
+        "Medical": "911",
+        "NYC Emergency Management": "311",
+        "Poison Control": "1-800-222-1222",
+    }
+}
+
+# =============================================================================
+# Cooling Center Specific Settings
+# =============================================================================
+
+COOLING_CENTER_SETTINGS = {
+    "show_capacity": False,  # Future feature
+    "show_hours": False,  # Future feature
+    "highlight_24h_centers": True,
+    "show_amenities": False,  # AC, water, restrooms, etc.
+    "temperature_threshold": 90,  # °F - show special alerts above this
+}
+
+# =============================================================================
+# Accessibility Settings
+# =============================================================================
+
+ACCESSIBILITY_SETTINGS = {
+    "high_contrast_mode": False,
+    "large_text_mode": False,
+    "screen_reader_support": True,
+    "keyboard_navigation": True,
+    "color_blind_friendly": True,
+}
+
+# =============================================================================
+# Advanced Settings
+# =============================================================================
+
+ADVANCED_SETTINGS = {
+    "debug_mode": False,
+    "log_user_queries": False,
+    "cache_geocoding_results": True,
+    "cache_duration": 3600,  # seconds (1 hour)
+    "enable_analytics": False,
+    "api_timeout": 30,  # seconds
+}
+
+# =============================================================================
+# Customization Examples
+# =============================================================================
+
+"""
+EXAMPLE CUSTOMIZATIONS:
+
+1. Change to dark theme:
+   APP_CONFIG["theme"]["primaryColor"] = "#3b82f6"
+   APP_CONFIG["theme"]["backgroundColor"] = "#000000"
+   UI_SETTINGS["enable_dark_mode"] = True
+
+2. Enable clustering for dense areas:
+   MAP_CONFIG["cluster_resources"] = True
+   MAP_CONFIG["cluster_distance"] = 100
+
+3. Focus on cooling centers:
+   COOLING_CENTER_SETTINGS["show_capacity"] = True
+   COOLING_CENTER_SETTINGS["show_hours"] = True
+   EMERGENCY_SETTINGS["priority_resources"] = ["cooling_center", "hospital"]
+
+4. Mobile-optimized settings:
+   UI_SETTINGS["map_height"] = 400
+   MAP_CONFIG["default_zoom"] = 13
+   RESOURCE_DISPLAY["max_results_display"] = 5
+
+5. Accessibility mode:
+   ACCESSIBILITY_SETTINGS["high_contrast_mode"] = True
+   ACCESSIBILITY_SETTINGS["large_text_mode"] = True
+   ROUTE_SETTINGS["prefer_flat_routes"] = True
+   ROUTE_SETTINGS["avoid_stairs"] = True
+
+6. Emergency mode (fast response):
+   UI_SETTINGS["animation_speed"] = "none"
+   RESOURCE_DISPLAY["show_all_on_load"] = False
+   MAP_CONFIG["default_zoom"] = 15
+   NOTIFICATION_SETTINGS["auto_clear_messages"] = True
+"""
+
+# =============================================================================
+# Validation
+# =============================================================================
+
+def validate_config():
+    """Validate configuration settings and return any errors."""
+    errors = []
+    
+    # Validate map zoom levels
+    if MAP_CONFIG["default_zoom"] < MAP_CONFIG["min_zoom"]:
+        errors.append("default_zoom must be >= min_zoom")
+    if MAP_CONFIG["default_zoom"] > MAP_CONFIG["max_zoom"]:
+        errors.append("default_zoom must be <= max_zoom")
+    
+    # Validate time limits
+    if ISOCHRONE_SETTINGS["max_time_limit"] > 60:
+        errors.append("max_time_limit should not exceed 60 minutes")
+    
+    # Validate file sizes
+    if MEDIA_SETTINGS["max_file_size"] > 50 * 1024 * 1024:
+        errors.append("max_file_size should not exceed 50MB")
+    
+    # Validate recording duration
+    if VOICE_SETTINGS["max_recording_duration"] > 600:
+        errors.append("max_recording_duration should not exceed 10 minutes")
+    
+    return errors
+
+
+def get_active_features():
+    """Return list of enabled features."""
+    return [feature for feature, enabled in FEATURES.items() if enabled]
+
+
+def print_config_summary():
+    """Print a summary of current configuration."""
+    print("=" * 60)
+    print("EMERGENCY ROUTING ASSISTANT - CONFIGURATION SUMMARY")
+    print("=" * 60)
+    print(f"\nApp Title: {APP_CONFIG['title']}")
+    print(f"Default Language: {UI_SETTINGS['default_language']}")
+    print(f"Map Style: {MAP_CONFIG['default_style']}")
+    print(f"\nActive Features ({len(get_active_features())} enabled):")
+    for feature in get_active_features():
+        print(f"  ✓ {feature}")
+    
+    errors = validate_config()
+    if errors:
+        print(f"\n⚠️  Configuration Errors ({len(errors)}):")
+        for error in errors:
+            print(f"  ❌ {error}")
+    else:
+        print("\n✅ Configuration is valid")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    print_config_summary()

core/engine.py

@@ -0,0 +1,2239 @@
+"""
+Routing engine for the Emergency Routing Assistant.
+
+This module contains all routing logic, data loading, and processing.
+The frontend (app.py) should only handle presentation.
+
+Features inspired by dream-meridian:
+- igraph backend for high-performance routing (optional)
+- Isochrone generation (reachable area within X minutes)
+- Find along route (discover POIs along a computed route)
+"""
+
+import os
+import re
+import json
+import networkx as nx
+import pandas as pd
+import geopandas as gpd
+import osmnx as ox
+import requests
+from typing import Any
+from dataclasses import dataclass, field
+from scipy.spatial import cKDTree
+import numpy as np
+
+# Optional igraph support for high-performance routing
+try:
+    import igraph as ig
+    HAS_IGRAPH = True
+except ImportError:
+    HAS_IGRAPH = False
+
+# =============================================================================
+# Constants
+# =============================================================================
+
+WALK_SPEED_M_PER_MIN = 75  # ~4.5 km/h
+ELEVATION_PENALTY_FACTOR = 3.0
+
+BROWNSVILLE_CENTER = {"lat": 40.6594, "lon": -73.9126}
+BROWNSVILLE_BOUNDS = {
+    "min_lat": 40.64,
+    "max_lat": 40.68,
+    "min_lon": -73.93,
+    "max_lon": -73.89
+}
+
+VALID_RESOURCE_TYPES = [
+    "pharmacy", "clinic", "hospital", "fire_station", "police",
+    "school", "library", "community_centre", "place_of_worship"
+]
+
+# Route colors for display
+ROUTE_COLORS = {
+    "shortest": "#3b82f6",   # Blue
+    "flattest": "#22c55e",   # Green
+    "balanced": "#f59e0b",   # Amber
+    "safest": "#10b981",     # Emerald (climate-safe route)
+}
+
+# Isochrone colors by time
+ISOCHRONE_COLORS = {
+    5: "#22c55e",    # Green - 5 min
+    10: "#84cc16",   # Lime - 10 min
+    15: "#f59e0b",   # Amber - 15 min
+    20: "#ef4444",   # Red - 20 min
+}
+
+# =============================================================================
+# POI Marker Styles
+# =============================================================================
+# This configuration allows UI developers to customize markers by POI type.
+# Each entry defines: color, icon, and optional display properties.
+#
+# Icon options for Folium:
+#   - Font Awesome icons (prefix "fa"): "fa-hospital", "fa-fire", etc.
+#   - Glyphicons (prefix "glyphicon"): "glyphicon-home", etc.
+#   - Bootstrap icons: "heart", "star", "flag", etc.
+#
+# For custom SVG/image markers, UI devs can extend render_map() to use
+# folium.CustomIcon or folium.DivIcon with the 'custom_icon_url' field.
+
+POI_MARKER_STYLES = {
+    # Emergency Services
+    "hospital": {
+        "color": "#dc2626",       # Red-600
+        "fill_color": "#fecaca",  # Red-200
+        "icon": "fa-hospital",
+        "icon_prefix": "fa",
+        "radius": 8,
+        "category": "Emergency Service",
+    },
+    "clinic": {
+        "color": "#ef4444",       # Red-500
+        "fill_color": "#fee2e2",  # Red-100
+        "icon": "fa-stethoscope",
+        "icon_prefix": "fa",
+        "radius": 7,
+        "category": "Emergency Service",
+    },
+    "fire_station": {
+        "color": "#ea580c",       # Orange-600
+        "fill_color": "#ffedd5",  # Orange-100
+        "icon": "fa-fire-extinguisher",
+        "icon_prefix": "fa",
+        "radius": 8,
+        "category": "Emergency Service",
+    },
+    "police": {
+        "color": "#1d4ed8",       # Blue-700
+        "fill_color": "#dbeafe",  # Blue-100
+        "icon": "fa-shield",
+        "icon_prefix": "fa",
+        "radius": 8,
+        "category": "Emergency Service",
+    },
+
+    # Healthcare
+    "pharmacy": {
+        "color": "#16a34a",       # Green-600
+        "fill_color": "#dcfce7",  # Green-100
+        "icon": "fa-medkit",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Healthcare",
+    },
+    "doctors": {
+        "color": "#22c55e",       # Green-500
+        "fill_color": "#bbf7d0",  # Green-200
+        "icon": "fa-user-md",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Healthcare",
+    },
+
+    # Community Resources
+    "school": {
+        "color": "#7c3aed",       # Violet-600
+        "fill_color": "#ede9fe",  # Violet-100
+        "icon": "fa-graduation-cap",
+        "icon_prefix": "fa",
+        "radius": 7,
+        "category": "Community Resource",
+    },
+    "library": {
+        "color": "#8b5cf6",       # Violet-500
+        "fill_color": "#f3e8ff",  # Purple-100
+        "icon": "fa-book",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Community Resource",
+    },
+    "community_centre": {
+        "color": "#6366f1",       # Indigo-500
+        "fill_color": "#e0e7ff",  # Indigo-100
+        "icon": "fa-users",
+        "icon_prefix": "fa",
+        "radius": 7,
+        "category": "Community Resource",
+    },
+    "place_of_worship": {
+        "color": "#a855f7",       # Purple-500
+        "fill_color": "#f3e8ff",  # Purple-100
+        "icon": "fa-church",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Community Resource",
+    },
+    "youth_center": {
+        "color": "#ec4899",       # Pink-500
+        "fill_color": "#fce7f3",  # Pink-100
+        "icon": "fa-child",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Community Resource",
+    },
+    "senior_center": {
+        "color": "#f97316",       # Orange-500
+        "fill_color": "#ffedd5",  # Orange-100
+        "icon": "fa-heart",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Community Resource",
+    },
+    "childcare": {
+        "color": "#f472b6",       # Pink-400
+        "fill_color": "#fbcfe8",  # Pink-200
+        "icon": "fa-child",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Community Resource",
+    },
+    "nycha_community_center": {
+        "color": "#0ea5e9",       # Sky-500
+        "fill_color": "#e0f2fe",  # Sky-100
+        "icon": "fa-building",
+        "icon_prefix": "fa",
+        "radius": 7,
+        "category": "Community Resource",
+    },
+
+    # Climate Infrastructure
+    "park": {
+        "color": "#16a34a",       # Green-600
+        "fill_color": "#bbf7d0",  # Green-200
+        "icon": "fa-tree",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Climate Infrastructure",
+    },
+    "shelter": {
+        "color": "#0284c7",       # Sky-600
+        "fill_color": "#bae6fd",  # Sky-200
+        "icon": "fa-home",
+        "icon_prefix": "fa",
+        "radius": 8,
+        "category": "Climate Infrastructure",
+    },
+    "drinking_water": {
+        "color": "#0891b2",       # Cyan-600
+        "fill_color": "#cffafe",  # Cyan-100
+        "icon": "fa-tint",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Climate Infrastructure",
+    },
+
+    # Local Business
+    "bodega": {
+        "color": "#f59e0b",       # Amber-500
+        "fill_color": "#fef3c7",  # Amber-100
+        "icon": "fa-shopping-basket",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Local Business",
+    },
+    "supermarket": {
+        "color": "#d97706",       # Amber-600
+        "fill_color": "#fef3c7",  # Amber-100
+        "icon": "fa-shopping-cart",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Local Business",
+    },
+    "fast_food": {
+        "color": "#fbbf24",       # Amber-400
+        "fill_color": "#fef9c3",  # Yellow-100
+        "icon": "fa-cutlery",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Local Business",
+    },
+    "cafe": {
+        "color": "#92400e",       # Amber-800
+        "fill_color": "#fef3c7",  # Amber-100
+        "icon": "fa-coffee",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Local Business",
+    },
+    "bank": {
+        "color": "#475569",       # Slate-600
+        "fill_color": "#e2e8f0",  # Slate-200
+        "icon": "fa-university",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Local Business",
+    },
+
+    # Social Services
+    "social_facility": {
+        "color": "#0d9488",       # Teal-600
+        "fill_color": "#ccfbf1",  # Teal-100
+        "icon": "fa-handshake-o",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Social Services",
+    },
+    "snap_center": {
+        "color": "#14b8a6",       # Teal-500
+        "fill_color": "#ccfbf1",  # Teal-100
+        "icon": "fa-id-card",
+        "icon_prefix": "fa",
+        "radius": 6,
+        "category": "Social Services",
+    },
+
+    # Default / Fallback for unknown types
+    "facility": {
+        "color": "#6b7280",       # Gray-500
+        "fill_color": "#e5e7eb",  # Gray-200
+        "icon": "fa-building-o",
+        "icon_prefix": "fa",
+        "radius": 5,
+        "category": "Other",
+    },
+}
+
+# Default style for POI types not explicitly defined
+POI_DEFAULT_STYLE = {
+    "color": "#6b7280",       # Gray-500
+    "fill_color": "#e5e7eb",  # Gray-200
+    "icon": "fa-map-marker",
+    "icon_prefix": "fa",
+    "radius": 5,
+    "category": "Other",
+}
+
+
+def get_poi_marker_style(poi_type: str) -> dict:
+    """
+    Get marker style configuration for a given POI type.
+
+    Args:
+        poi_type: The type of POI (e.g., "hospital", "pharmacy", "school")
+
+    Returns:
+        Dictionary with marker style properties:
+        - color: Border/stroke color (hex)
+        - fill_color: Fill color (hex)
+        - icon: Font Awesome or Glyphicon name
+        - icon_prefix: Icon library prefix ("fa" or "glyphicon")
+        - radius: Circle marker radius in pixels
+        - category: POI category for grouping
+
+    Example:
+        >>> style = get_poi_marker_style("hospital")
+        >>> style["color"]
+        '#dc2626'
+        >>> style["icon"]
+        'fa-hospital'
+    """
+    return POI_MARKER_STYLES.get(poi_type, POI_DEFAULT_STYLE).copy()
+
+
+def get_all_poi_styles() -> dict:
+    """
+    Get all POI marker style configurations.
+
+    Returns:
+        Dictionary mapping POI type names to their style configurations.
+        Useful for UI developers to enumerate all available styles.
+
+    Example:
+        >>> styles = get_all_poi_styles()
+        >>> list(styles.keys())
+        ['hospital', 'clinic', 'fire_station', ...]
+    """
+    return POI_MARKER_STYLES.copy()
+
+
+def get_poi_styles_by_category() -> dict[str, list[str]]:
+    """
+    Get POI types grouped by category.
+
+    Returns:
+        Dictionary mapping category names to lists of POI types.
+
+    Example:
+        >>> by_cat = get_poi_styles_by_category()
+        >>> by_cat["Emergency Service"]
+        ['hospital', 'clinic', 'fire_station', 'police']
+    """
+    categories: dict[str, list[str]] = {}
+    for poi_type, style in POI_MARKER_STYLES.items():
+        cat = style.get("category", "Other")
+        if cat not in categories:
+            categories[cat] = []
+        categories[cat].append(poi_type)
+    return categories
+
+
+# =============================================================================
+# Data Classes
+# =============================================================================
+
+@dataclass
+class RouteMetrics:
+    elevation_gain_m: float = 0
+    elevation_loss_m: float = 0
+    max_elevation_m: float = 0
+    min_elevation_m: float = 0
+    avg_grade_pct: float = 0
+    max_grade_pct: float = 0
+    difficulty: str = "flat"
+
+    def to_dict(self) -> dict:
+        return {
+            "elevation_gain_m": self.elevation_gain_m,
+            "elevation_loss_m": self.elevation_loss_m,
+            "max_elevation_m": self.max_elevation_m,
+            "min_elevation_m": self.min_elevation_m,
+            "avg_grade_pct": self.avg_grade_pct,
+            "max_grade_pct": self.max_grade_pct,
+            "difficulty": self.difficulty,
+        }
+
+
+@dataclass
+class ClimateMetrics:
+    """Climate risk metrics for a route.
+
+    Climate weights are now computed at RUNTIME using configurable parameters,
+    allowing the LLM to adjust weights based on user context (e.g., flooding,
+    heat wave, air quality concerns).
+    """
+    avg_climate_risk: float = 0
+    max_climate_risk: float = 0
+    avg_flood_risk: float = 0
+    max_flood_risk: float = 0
+    avg_heat_risk: float = 0
+    max_heat_risk: float = 0
+    avg_air_quality_risk: float = 0
+    max_air_quality_risk: float = 0
+    avg_tree_coverage: float = 0
+    flood_exposure_m: float = 0  # meters of route where flood_risk > 0.3
+
+    def to_dict(self) -> dict:
+        return {
+            "avg_climate_risk": self.avg_climate_risk,
+            "max_climate_risk": self.max_climate_risk,
+            "avg_flood_risk": self.avg_flood_risk,
+            "max_flood_risk": self.max_flood_risk,
+            "avg_heat_risk": self.avg_heat_risk,
+            "max_heat_risk": self.max_heat_risk,
+            "avg_air_quality_risk": self.avg_air_quality_risk,
+            "max_air_quality_risk": self.max_air_quality_risk,
+            "avg_tree_coverage": self.avg_tree_coverage,
+            "flood_exposure_m": self.flood_exposure_m,
+        }
+
+
+@dataclass
+class ClimateWeightParams:
+    """Parameters for runtime climate weight calculation.
+
+    These parameters are inferred by the LLM based on user context:
+    - Flooding mentioned: increase flood penalties
+    - Hot day / shade requested: increase heat_factor and shade_factor
+    - Respiratory concerns: increase aqi_factor
+    - Mobility concerns / elderly: increase grade_factor
+    """
+    flood_penalty_deep: float = 5.0      # Multiplier for deep flood zones (flood_risk >= 1.0)
+    flood_penalty_shallow: float = 2.0   # Multiplier for shallow flood zones (flood_risk >= 0.6)
+    heat_factor: float = 0.3             # Penalty for high heat vulnerability (0.0-1.0)
+    shade_factor: float = 0.3            # Benefit from tree coverage (0.0-1.0)
+    aqi_factor: float = 0.1              # Penalty for poor air quality (0.0-1.0)
+    grade_factor: float = 0.2            # Penalty for steep grades (0.0-1.0)
+
+    def to_dict(self) -> dict:
+        return {
+            "flood_penalty_deep": self.flood_penalty_deep,
+            "flood_penalty_shallow": self.flood_penalty_shallow,
+            "heat_factor": self.heat_factor,
+            "shade_factor": self.shade_factor,
+            "aqi_factor": self.aqi_factor,
+            "grade_factor": self.grade_factor,
+        }
+
+
+@dataclass
+class RouteOption:
+    name: str
+    label: str
+    color: str
+    coords: list[tuple[float, float]]
+    distance_m: float
+    time_min: float
+    metrics: RouteMetrics
+    route_nodes: list[int] = field(default_factory=list)
+    climate_metrics: ClimateMetrics = field(default_factory=ClimateMetrics)
+
+    def to_dict(self) -> dict:
+        result = {
+            "name": self.name,
+            "label": self.label,
+            "color": self.color,
+            "coords": self.coords,
+            "distance_meters": self.distance_m,
+            "walking_time_minutes": self.time_min,
+            "route_metrics": self.metrics.to_dict(),
+        }
+        # Include climate metrics if they have data
+        if self.climate_metrics.avg_climate_risk > 0:
+            result["climate_metrics"] = self.climate_metrics.to_dict()
+        return result
+
+
+@dataclass
+class RoutingResult:
+    success: bool
+    recommended: str = ""
+    alternatives: list[RouteOption] = field(default_factory=list)
+    origin: tuple[float, float] = (0, 0)
+    destination: tuple[float, float] = (0, 0)
+    dest_name: str = ""
+    error: str = ""
+
+    def to_dict(self) -> dict:
+        if not self.success:
+            return {"error": self.error}
+
+        recommended_route = next(
+            (r for r in self.alternatives if r.name == self.recommended),
+            self.alternatives[0] if self.alternatives else None
+        )
+
+        return {
+            "success": True,
+            "recommended": self.recommended,
+            "alternatives": [r.to_dict() for r in self.alternatives],
+            "distance_meters": recommended_route.distance_m if recommended_route else 0,
+            "walking_time_minutes": recommended_route.time_min if recommended_route else 0,
+            "origin": {"lat": self.origin[0], "lon": self.origin[1]},
+            "destination": {"lat": self.destination[0], "lon": self.destination[1], "name": self.dest_name},
+            "route_metrics": recommended_route.metrics.to_dict() if recommended_route else {},
+        }
+
+    def to_map_data(self) -> dict | None:
+        if not self.success or not self.alternatives:
+            return None
+
+        recommended_route = next(
+            (r for r in self.alternatives if r.name == self.recommended),
+            self.alternatives[0]
+        )
+
+        return {
+            "routes": [
+                {"coords": r.coords, "color": r.color, "label": r.label, "name": r.name}
+                for r in self.alternatives
+            ],
+            "origin": list(self.origin),
+            "destination": list(self.destination),
+            "dest_name": self.dest_name,
+            "distance": recommended_route.distance_m,
+            "route_coords": recommended_route.coords,  # backwards compat
+        }
+
+
+@dataclass
+class IsochroneResult:
+    """Result of isochrone generation - areas reachable within time limits."""
+    success: bool
+    origin: tuple[float, float] = (0, 0)
+    isochrones: list[dict] = field(default_factory=list)  # [{time_min, polygon_coords, color}]
+    resources_within: list[dict] = field(default_factory=list)  # Resources within max isochrone
+    error: str = ""
+
+    def to_dict(self) -> dict:
+        if not self.success:
+            return {"error": self.error}
+        return {
+            "success": True,
+            "origin": {"lat": self.origin[0], "lon": self.origin[1]},
+            "isochrones": self.isochrones,
+            "resources_within": self.resources_within,
+        }
+
+    def to_map_data(self) -> dict | None:
+        if not self.success:
+            return None
+        return {
+            "origin": list(self.origin),
+            "isochrones": self.isochrones,
+            "resources_within": self.resources_within,
+        }
+
+
+@dataclass
+class AlongRouteResult:
+    """Result of find_along_route - POIs discovered along a route."""
+    success: bool
+    route_coords: list[tuple[float, float]] = field(default_factory=list)
+    pois_found: list[dict] = field(default_factory=list)
+    origin: tuple[float, float] = (0, 0)
+    destination: tuple[float, float] = (0, 0)
+    buffer_meters: float = 100
+    climate_metrics: ClimateMetrics | None = None
+    error: str = ""
+
+    def to_dict(self) -> dict:
+        if not self.success:
+            return {"error": self.error}
+        result = {
+            "success": True,
+            "origin": {"lat": self.origin[0], "lon": self.origin[1]},
+            "destination": {"lat": self.destination[0], "lon": self.destination[1]},
+            "buffer_meters": self.buffer_meters,
+            "pois_found": self.pois_found,
+            "poi_count": len(self.pois_found),
+        }
+        if self.climate_metrics:
+            result["climate_metrics"] = self.climate_metrics.to_dict()
+        return result
+
+    def to_map_data(self) -> dict | None:
+        if not self.success:
+            return None
+        return {
+            "route_coords": self.route_coords,
+            "origin": list(self.origin),
+            "destination": list(self.destination),
+            "pois_along_route": self.pois_found,
+        }
+
+
+@dataclass
+class RouteComparisonResult:
+    """Result of comparing shortest vs safest routes."""
+    success: bool
+    shortest: RouteOption | None = None
+    safest: RouteOption | None = None
+    origin: tuple[float, float] = (0, 0)
+    destination: tuple[float, float] = (0, 0)
+    dest_name: str = ""
+    extra_distance_m: float = 0
+    extra_distance_pct: float = 0
+    risk_reduction: float = 0
+    error: str = ""
+
+    def to_dict(self) -> dict:
+        if not self.success:
+            return {"error": self.error}
+        return {
+            "success": True,
+            "shortest": self.shortest.to_dict() if self.shortest else None,
+            "safest": self.safest.to_dict() if self.safest else None,
+            "origin": {"lat": self.origin[0], "lon": self.origin[1]},
+            "destination": {"lat": self.destination[0], "lon": self.destination[1], "name": self.dest_name},
+            "comparison": {
+                "extra_distance_m": round(self.extra_distance_m, 1),
+                "extra_distance_pct": round(self.extra_distance_pct, 1),
+                "risk_reduction": round(self.risk_reduction, 3),
+            },
+        }
+
+    def to_map_data(self) -> dict | None:
+        if not self.success:
+            return None
+        routes = []
+        if self.shortest:
+            routes.append({
+                "coords": self.shortest.coords,
+                "color": self.shortest.color,
+                "label": self.shortest.label,
+                "name": self.shortest.name,
+            })
+        if self.safest and self.safest.coords != (self.shortest.coords if self.shortest else []):
+            routes.append({
+                "coords": self.safest.coords,
+                "color": self.safest.color,
+                "label": self.safest.label,
+                "name": self.safest.name,
+            })
+        return {
+            "routes": routes,
+            "origin": list(self.origin),
+            "destination": list(self.destination),
+            "dest_name": self.dest_name,
+        }
+
+
+# =============================================================================
+# Routing Engine
+# =============================================================================
+
+class RoutingEngine:
+    """
+    Core routing engine - handles all graph operations and route computation.
+
+    Supports optional igraph backend for high-performance routing.
+    Features:
+    - Multi-route computation (shortest, flattest, balanced)
+    - Isochrone generation (reachable area within X minutes)
+    - Find along route (POIs near a route corridor)
+    """
+
+    def __init__(self, use_igraph: bool = True):
+        self.G: nx.MultiDiGraph | None = None
+        self.resources_df: pd.DataFrame | None = None
+        self.known_places: dict[str, dict] = {}
+        self._loaded = False
+
+        # igraph backend (if available and requested)
+        self.use_igraph = use_igraph and HAS_IGRAPH
+        self.ig_graph: "ig.Graph | None" = None
+        self.ig_node_map: dict[int, int] = {}  # NetworkX node -> igraph node
+        self.ig_reverse_map: dict[int, int] = {}  # igraph node -> NetworkX node
+
+        # Edge attribute indices for igraph (for climate routing)
+        self.ig_length_idx: int = -1
+        self.ig_climate_weight_idx: int = -1
+
+        # Track if climate data is available
+        self.has_climate_data: bool = False
+
+        # Spatial index for fast nearest-neighbor queries
+        self._node_coords: np.ndarray | None = None
+        self._node_ids: list[int] = []
+        self._kdtree: cKDTree | None = None
+        self._resource_kdtree: cKDTree | None = None
+
+    def load(self) -> bool:
+        """Load network and resources from disk.
+
+        Tries to load from pre-built cache first (fast), falls back to GraphML (slow).
+        Run `python build_graph_cache.py` to generate the cache for faster startup.
+        """
+        if self._loaded:
+            return True
+
+        # Data is in project root's data/ directory, not core/data/
+        data_dir = os.path.join(os.path.dirname(__file__), "..", "data", "brownsville")
+
+        try:
+            # Try loading from cache first (much faster!)
+            cache_path = os.path.join(data_dir, "graph_cache.pkl")
+            if os.path.exists(cache_path):
+                loaded_from_cache = self._load_from_cache(cache_path)
+                if loaded_from_cache:
+                    # Cache loaded successfully, skip GraphML parsing
+                    pass
+                else:
+                    # Cache failed, fall back to GraphML
+                    self._load_from_graphml(data_dir)
+            else:
+                # No cache, load from GraphML
+                self._load_from_graphml(data_dir)
+
+            # Load resources
+            resources_path = os.path.join(data_dir, "all_resources.csv")
+            if os.path.exists(resources_path):
+                self.resources_df = pd.read_csv(resources_path)
+            else:
+                geojson_path = os.path.join(data_dir, "all_resources.geojson")
+                if os.path.exists(geojson_path):
+                    gdf = gpd.read_file(geojson_path)
+                    self.resources_df = pd.DataFrame({
+                        "name": gdf["name"],
+                        "type": gdf["type"],
+                        "category": gdf["category"],
+                        "lat": gdf.geometry.y,
+                        "lon": gdf.geometry.x
+                    })
+
+            # Build resource spatial index
+            if self.resources_df is not None:
+                self._build_resource_index()
+
+            # Load places for geocoding
+            self._load_known_places(data_dir)
+
+            self._loaded = True
+            return True
+
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            return False
+
+    def _load_from_cache(self, cache_path: str) -> bool:
+        """Load pre-built graph data from pickle cache (fast startup)."""
+        import pickle
+        try:
+            with open(cache_path, 'rb') as f:
+                cache = pickle.load(f)
+
+            # Check cache version (v3 added air_quality_risk)
+            if cache.get("version", 1) < 3:
+                print("Cache version outdated, rebuilding from GraphML...")
+                return False
+
+            # Restore all cached data
+            self.G = cache["nx_graph"]
+            self.has_climate_data = cache["has_climate_data"]
+            self._node_ids = cache["node_ids"]
+            self._node_coords = cache["coords"]
+            self._kdtree = cache["kdtree"]
+
+            # Restore igraph if available
+            if self.use_igraph and cache.get("ig_graph") is not None:
+                self.ig_graph = cache["ig_graph"]
+                self.ig_node_map = cache["ig_node_map"]
+                self.ig_reverse_map = cache["ig_reverse_map"]
+
+            return True
+        except Exception as e:
+            print(f"Failed to load cache: {e}")
+            return False
+
+    def _load_from_graphml(self, data_dir: str):
+        """Load graph from GraphML file (slow fallback)."""
+        # Load climate-enhanced network in priority order:
+        # 1. Real climate data (walking_network_final.graphml)
+        # 2. Mock climate data (walking_network_climate.graphml)
+        # 3. Raw network (walking_network.graphml)
+        final_path = os.path.join(data_dir, "walking_network_final.graphml")
+        climate_path = os.path.join(data_dir, "walking_network_climate.graphml")
+        graphml_path = os.path.join(data_dir, "walking_network.graphml")
+
+        if os.path.exists(final_path):
+            self.G = ox.load_graphml(final_path)
+            self.has_climate_data = True
+        elif os.path.exists(climate_path):
+            self.G = ox.load_graphml(climate_path)
+            self.has_climate_data = True
+        elif os.path.exists(graphml_path):
+            self.G = ox.load_graphml(graphml_path)
+            self.has_climate_data = False
+        else:
+            from shapely.geometry import box
+            brownsville_bbox = box(-73.93, 40.64, -73.89, 40.68)
+            self.G = ox.graph_from_polygon(brownsville_bbox, network_type='walk', simplify=True)
+            self.has_climate_data = False
+
+        # Convert climate attributes from strings to floats (GraphML stores all as strings)
+        if self.has_climate_data:
+            climate_attrs = ['flood_risk', 'heat_risk', 'air_quality_risk', 'climate_risk', 'climate_weight']
+            for u, v, data in self.G.edges(data=True):
+                for attr in climate_attrs:
+                    if attr in data and isinstance(data[attr], str):
+                        try:
+                            data[attr] = float(data[attr])
+                        except (ValueError, TypeError):
+                            data[attr] = 0.0
+
+        # Verify climate data by checking first edge
+        if self.has_climate_data:
+            sample_edge = next(iter(self.G.edges(data=True)), None)
+            if sample_edge and "climate_weight" not in sample_edge[2]:
+                self.has_climate_data = False
+
+        self.G = ox.project_graph(self.G)
+
+        # Build spatial index for fast nearest-node queries
+        self._build_spatial_index()
+
+        # Build igraph graph if available
+        if self.use_igraph:
+            self._build_igraph_graph()
+
+    def _build_spatial_index(self):
+        """Build KD-tree for fast nearest-node lookups."""
+        if self.G is None:
+            return
+
+        nodes = list(self.G.nodes())
+        coords = []
+        for node in nodes:
+            x = self.G.nodes[node].get("x", 0)
+            y = self.G.nodes[node].get("y", 0)
+            coords.append([x, y])
+
+        self._node_ids = nodes
+        self._node_coords = np.array(coords)
+        self._kdtree = cKDTree(self._node_coords)
+
+    def _build_resource_index(self):
+        """Build KD-tree for fast resource lookups."""
+        if self.resources_df is None or len(self.resources_df) == 0:
+            return
+
+        # Convert lat/lon to projected coordinates for consistency
+        coords = []
+        if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+            import pyproj
+            transformer = pyproj.Transformer.from_crs("EPSG:4326", self.G.graph["crs"], always_xy=True)
+            for _, row in self.resources_df.iterrows():
+                x, y = transformer.transform(row["lon"], row["lat"])
+                coords.append([x, y])
+        else:
+            for _, row in self.resources_df.iterrows():
+                coords.append([row["lon"], row["lat"]])
+
+        self._resource_kdtree = cKDTree(np.array(coords))
+
+    def _build_igraph_graph(self):
+        """Build igraph graph from NetworkX graph for high-performance routing.
+
+        Preserves all edge attributes including climate data.
+        Uses ig.Graph.from_networkx() for automatic attribute transfer.
+        """
+        if not HAS_IGRAPH or self.G is None:
+            return
+
+        # Create node mapping (NetworkX uses arbitrary IDs, igraph uses 0..n-1)
+        nx_nodes = list(self.G.nodes())
+        self.ig_node_map = {nx_node: i for i, nx_node in enumerate(nx_nodes)}
+        self.ig_reverse_map = {i: nx_node for nx_node, i in self.ig_node_map.items()}
+
+        # Create igraph graph (directed)
+        self.ig_graph = ig.Graph(n=len(nx_nodes), directed=True)
+
+        # Store vertex osmids for reverse lookup
+        self.ig_graph.vs["_nx_name"] = nx_nodes
+
+        # Add edges with all attributes
+        edges = []
+        lengths = []
+        climate_weights = []
+        flood_risks = []
+        heat_risks = []
+        climate_risks = []
+
+        for u, v, data in self.G.edges(data=True):
+            ig_u = self.ig_node_map[u]
+            ig_v = self.ig_node_map[v]
+            edges.append((ig_u, ig_v))
+
+            length = data.get("length", 1.0)
+            if length is None:
+                length = 1.0
+            lengths.append(float(length))
+
+            # Climate attributes (default to safe values if missing)
+            flood_risks.append(float(data.get("flood_risk", 0) or 0))
+            heat_risks.append(float(data.get("heat_risk", 0) or 0))
+            climate_risks.append(float(data.get("climate_risk", 0) or 0))
+
+            # Climate weight for routing (default to length if missing)
+            cw = data.get("climate_weight")
+            if cw is None:
+                cw = length
+            climate_weights.append(float(cw))
+
+        self.ig_graph.add_edges(edges)
+        self.ig_graph.es["length"] = lengths
+        self.ig_graph.es["weight"] = lengths  # Default weight is length
+        self.ig_graph.es["climate_weight"] = climate_weights
+        self.ig_graph.es["flood_risk"] = flood_risks
+        self.ig_graph.es["heat_risk"] = heat_risks
+        self.ig_graph.es["climate_risk"] = climate_risks
+
+    def _load_known_places(self, data_dir: str):
+        """Load known places for geocoding."""
+        places_path = os.path.join(data_dir, "places.csv")
+        if os.path.exists(places_path):
+            try:
+                df = pd.read_csv(places_path)
+                for _, row in df.iterrows():
+                    self.known_places[row['name_lower']] = {
+                        "lat": row['lat'],
+                        "lon": row['lon'],
+                        "name": row['name']
+                    }
+            except Exception:
+                pass
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._loaded
+
+    @property
+    def node_count(self) -> int:
+        return len(self.G.nodes) if self.G else 0
+
+    @property
+    def resource_count(self) -> int:
+        return len(self.resources_df) if self.resources_df is not None else 0
+
+    # -------------------------------------------------------------------------
+    # Graph utilities
+    # -------------------------------------------------------------------------
+
+    def _get_nearest_node(self, lat: float, lon: float) -> int:
+        """Find nearest network node to a point using KD-tree (fast)."""
+        # Convert to projected coordinates if needed
+        if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+            import pyproj
+            transformer = pyproj.Transformer.from_crs("EPSG:4326", self.G.graph["crs"], always_xy=True)
+            x, y = transformer.transform(lon, lat)
+        else:
+            x, y = lon, lat
+
+        # Use KD-tree for O(log n) lookup
+        if self._kdtree is not None:
+            _, idx = self._kdtree.query([x, y])
+            return self._node_ids[idx]
+
+        # Fallback to OSMnx
+        return ox.nearest_nodes(self.G, x, y)
+
+    def _get_nearest_node_ig(self, lat: float, lon: float) -> int:
+        """Get igraph node ID for a location."""
+        nx_node = self._get_nearest_node(lat, lon)
+        return self.ig_node_map.get(nx_node, 0)
+
+    def _get_route_coords(self, route: list[int]) -> list[tuple[float, float]]:
+        """Extract lat/lon coordinates from route nodes."""
+        if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+            import pyproj
+            transformer = pyproj.Transformer.from_crs(self.G.graph["crs"], "EPSG:4326", always_xy=True)
+            coords = []
+            for node in route:
+                x, y = self.G.nodes[node]["x"], self.G.nodes[node]["y"]
+                lon, lat = transformer.transform(x, y)
+                coords.append((lat, lon))
+            return coords
+        return [(self.G.nodes[node]["y"], self.G.nodes[node]["x"]) for node in route]
+
+    def _apply_elevation_weights(self, penalty_factor: float = ELEVATION_PENALTY_FACTOR) -> nx.MultiDiGraph:
+        """Create graph copy with elevation-weighted edges."""
+        G_weighted = self.G.copy()
+        for u, v, key, data in G_weighted.edges(keys=True, data=True):
+            base_length = data.get("length", 1)
+            elev_u = G_weighted.nodes[u].get("elevation", 0) or 0
+            elev_v = G_weighted.nodes[v].get("elevation", 0) or 0
+            elev_diff = elev_v - elev_u
+
+            if elev_diff > 0:
+                data["weighted_length"] = base_length + (elev_diff * penalty_factor)
+            else:
+                data["weighted_length"] = base_length
+        return G_weighted
+
+    def _compute_edge_weight(
+        self,
+        data: dict,
+        params: ClimateWeightParams = None
+    ) -> float:
+        """
+        Compute routing weight for an edge using raw risk values and configurable penalties.
+
+        This is computed at RUNTIME, allowing the LLM to adjust weights based on
+        what the user tells us about their situation (flooding, heat, air quality, mobility).
+
+        Design:
+        - Flood: categorical penalty (physical danger)
+        - Heat: continuous penalty based on HVI (social vulnerability / exposure proxy)
+        - Tree coverage: REDUCES weight (shade is beneficial)
+        - AQI: small continuous penalty (background air quality)
+        - Grade: continuous penalty for uphill segments (mobility / exertion)
+
+        Args:
+            data: Edge attribute dict
+            params: ClimateWeightParams with penalty/factor values
+
+        Returns:
+            float: Weighted length for Dijkstra's algorithm
+        """
+        if params is None:
+            params = ClimateWeightParams()
+
+        length = float(data.get('length', 100))
+
+        # === FLOOD: Categorical penalty (physical danger) ===
+        flood_risk = float(data.get('flood_risk', 0.1))
+        if flood_risk >= 1.0:
+            flood_mult = params.flood_penalty_deep      # Deep flooding: major penalty
+        elif flood_risk >= 0.6:
+            flood_mult = params.flood_penalty_shallow   # Shallow flooding: moderate penalty
+        else:
+            flood_mult = 1.0                            # No flooding: no penalty
+
+        # === HEAT: Continuous penalty based on HVI ===
+        heat_risk = float(data.get('heat_risk', 0.5))
+        # At heat_factor=0.3: HVI 1 (0.2) adds 6%, HVI 5 (1.0) adds 30%
+        heat_mult = 1.0 + params.heat_factor * heat_risk
+
+        # === TREE COVERAGE: Reduces weight (shade is good) ===
+        tree_coverage = float(data.get('tree_coverage', 0.0))
+        # At shade_factor=0.3: 0% trees = 1.0x, 100% trees = 0.7x
+        shade_mult = 1.0 - (params.shade_factor * tree_coverage)
+
+        # === AIR QUALITY: Small continuous penalty ===
+        aqi_risk = float(data.get('air_quality_risk', 0.0))
+        # At aqi_factor=0.1: worst AQI adds 10%
+        aqi_mult = 1.0 + params.aqi_factor * aqi_risk
+
+        # === GRADE: Continuous penalty for steep uphill segments ===
+        # Grade is stored as decimal (0.05 = 5% grade)
+        # Normalize: 10% grade (0.1) → grade_norm = 1.0
+        grade = abs(float(data.get('grade', 0) or 0))
+        grade_norm = min(grade * 10, 1.0)  # Cap at 10% grade
+        # At grade_factor=0.2: flat = 1.0x, 10% grade = 1.2x
+        grade_mult = 1.0 + params.grade_factor * grade_norm
+
+        # Combine multiplicatively
+        return length * flood_mult * heat_mult * shade_mult * aqi_mult * grade_mult
+
+    def _create_weight_function(self, params: ClimateWeightParams = None):
+        """Create a weight function for NetworkX routing with given climate parameters.
+
+        Note: For MultiDiGraph, NetworkX passes the edge data as {key: {attrs}} dict,
+        not the {attrs} dict directly. We extract the first edge's attributes.
+        """
+        if params is None:
+            params = ClimateWeightParams()
+
+        def weight_func(u, v, data):
+            # For MultiDiGraph, data is {key: {attrs}} - extract first edge's attrs
+            if isinstance(data, dict) and data:
+                first_key = next(iter(data))
+                if isinstance(first_key, int) and isinstance(data[first_key], dict):
+                    data = data[first_key]
+            return self._compute_edge_weight(data, params)
+
+        return weight_func
+
+    def _compute_route_metrics(self, route: list[int]) -> RouteMetrics:
+        """Compute elevation metrics for a route."""
+        if not route or len(route) < 2:
+            return RouteMetrics()
+
+        elevations = []
+        grades = []
+        elevation_gain = 0
+        elevation_loss = 0
+
+        for i, node in enumerate(route):
+            elev = self.G.nodes[node].get("elevation", 0) or 0
+            elevations.append(elev)
+
+            if i > 0:
+                diff = elev - elevations[i-1]
+                if diff > 0:
+                    elevation_gain += diff
+                else:
+                    elevation_loss += abs(diff)
+
+                edge_data = self.G.get_edge_data(route[i-1], node)
+                if edge_data:
+                    first_edge = list(edge_data.values())[0] if isinstance(edge_data, dict) else edge_data
+                    grade = abs(first_edge.get("grade", 0)) * 100
+                    grades.append(grade)
+
+        max_elev = max(elevations) if elevations else 0
+        min_elev = min(elevations) if elevations else 0
+        avg_grade = sum(grades) / len(grades) if grades else 0
+        max_grade = max(grades) if grades else 0
+
+        if elevation_gain < 5 and max_grade < 3:
+            difficulty = "flat"
+        elif elevation_gain < 15 or max_grade < 8:
+            difficulty = "moderate"
+        else:
+            difficulty = "hilly"
+
+        return RouteMetrics(
+            elevation_gain_m=round(elevation_gain, 1),
+            elevation_loss_m=round(elevation_loss, 1),
+            max_elevation_m=round(max_elev, 1),
+            min_elevation_m=round(min_elev, 1),
+            avg_grade_pct=round(avg_grade, 1),
+            max_grade_pct=round(max_grade, 1),
+            difficulty=difficulty
+        )
+
+    def _compute_climate_metrics(self, route: list[int]) -> ClimateMetrics:
+        """Compute climate risk metrics for a route.
+
+        Climate risk is now computed at runtime using a simple weighted formula:
+            climate_risk = 0.5 * flood_risk + 0.3 * heat_risk + 0.2 * air_quality_risk
+
+        Tree coverage is tracked but used separately (reduces routing weight).
+        """
+        if not route or len(route) < 2 or not self.has_climate_data:
+            return ClimateMetrics()
+
+        flood_risks = []
+        heat_risks = []
+        air_quality_risks = []
+        tree_coverages = []
+        climate_risks = []
+        flood_exposure = 0.0  # meters in flood risk > 0.3
+
+        for i in range(len(route) - 1):
+            u, v = route[i], route[i + 1]
+            edge_data = self.G.get_edge_data(u, v)
+            if not edge_data:
+                continue
+
+            # Get first edge (MultiDiGraph may have multiple)
+            if isinstance(edge_data, dict) and 0 in edge_data:
+                data = edge_data[0]
+            else:
+                data = next(iter(edge_data.values())) if isinstance(edge_data, dict) else edge_data
+
+            flood = float(data.get("flood_risk", 0) or 0)
+            heat = float(data.get("heat_risk", 0) or 0)
+            air_quality = float(data.get("air_quality_risk", 0) or 0)
+            tree_coverage = float(data.get("tree_coverage", 0) or 0)
+            length = float(data.get("length", 0) or 0)
+
+            # Compute combined climate risk at runtime
+            climate = 0.5 * flood + 0.3 * heat + 0.2 * air_quality
+
+            flood_risks.append(flood)
+            heat_risks.append(heat)
+            air_quality_risks.append(air_quality)
+            tree_coverages.append(tree_coverage)
+            climate_risks.append(climate)
+
+            if flood > 0.3:
+                flood_exposure += length
+
+        if not climate_risks:
+            return ClimateMetrics()
+
+        return ClimateMetrics(
+            avg_climate_risk=round(sum(climate_risks) / len(climate_risks), 3),
+            max_climate_risk=round(max(climate_risks), 3),
+            avg_flood_risk=round(sum(flood_risks) / len(flood_risks), 3),
+            max_flood_risk=round(max(flood_risks), 3),
+            avg_heat_risk=round(sum(heat_risks) / len(heat_risks), 3),
+            max_heat_risk=round(max(heat_risks), 3),
+            avg_air_quality_risk=round(sum(air_quality_risks) / len(air_quality_risks), 3),
+            max_air_quality_risk=round(max(air_quality_risks), 3),
+            avg_tree_coverage=round(sum(tree_coverages) / len(tree_coverages), 3),
+            flood_exposure_m=round(flood_exposure, 1),
+        )
+
+    # -------------------------------------------------------------------------
+    # Route computation
+    # -------------------------------------------------------------------------
+
+    def _compute_single_route(
+        self,
+        G: nx.MultiDiGraph,
+        origin_node: int,
+        dest_node: int,
+        weight_key: str = "length"
+    ) -> RouteOption | None:
+        """Compute a single route."""
+        try:
+            route = nx.shortest_path(G, origin_node, dest_node, weight=weight_key)
+            distance = sum(
+                self.G[u][v][0].get("length", 0) for u, v in zip(route[:-1], route[1:])
+            )
+            return RouteOption(
+                name="",
+                label="",
+                color="",
+                coords=self._get_route_coords(route),
+                distance_m=round(distance, 1),
+                time_min=round(distance / WALK_SPEED_M_PER_MIN, 1),
+                metrics=self._compute_route_metrics(route),
+                route_nodes=route,
+                climate_metrics=self._compute_climate_metrics(route),
+            )
+        except (nx.NetworkXNoPath, Exception):
+            return None
+
+    def _compute_single_route_igraph(
+        self,
+        origin_node: int,
+        dest_node: int,
+        weight_attr: str = "length"
+    ) -> RouteOption | None:
+        """Compute a single route using igraph for better performance."""
+        if not self.use_igraph or self.ig_graph is None:
+            return None
+
+        try:
+            ig_origin = self.ig_node_map.get(origin_node)
+            ig_dest = self.ig_node_map.get(dest_node)
+
+            if ig_origin is None or ig_dest is None:
+                return None
+
+            # Get shortest path using specified weight
+            path = self.ig_graph.get_shortest_paths(
+                ig_origin, to=ig_dest, weights=weight_attr, output="vpath"
+            )[0]
+
+            if not path:
+                return None
+
+            # Convert back to NetworkX node IDs
+            route = [self.ig_reverse_map[ig_node] for ig_node in path]
+
+            # Compute distance using original graph
+            distance = sum(
+                self.G[u][v][0].get("length", 0) for u, v in zip(route[:-1], route[1:])
+            )
+
+            return RouteOption(
+                name="",
+                label="",
+                color="",
+                coords=self._get_route_coords(route),
+                distance_m=round(distance, 1),
+                time_min=round(distance / WALK_SPEED_M_PER_MIN, 1),
+                metrics=self._compute_route_metrics(route),
+                route_nodes=route,
+                climate_metrics=self._compute_climate_metrics(route),
+            )
+        except Exception:
+            return None
+
+    def route(
+        self,
+        origin_coords: tuple[float, float],
+        dest_coords: tuple[float, float],
+        mode: str = "safest",
+        climate_params: ClimateWeightParams = None
+    ) -> RouteOption | None:
+        """
+        Compute a single route between two points with runtime climate weight calculation.
+
+        Climate weights are computed at RUNTIME using configurable parameters,
+        allowing the LLM to adjust based on user context (flooding, heat, asthma, etc.).
+
+        Args:
+            origin_coords: (lat, lon) tuple for origin
+            dest_coords: (lat, lon) tuple for destination
+            mode: 'safest' (use runtime climate weights) or 'fastest' (use length only)
+            climate_params: ClimateWeightParams for runtime weight calculation.
+                           If None, uses default parameters.
+
+        Returns:
+            RouteOption or None if no path found
+        """
+        if not self._loaded:
+            return None
+
+        origin_lat, origin_lon = origin_coords
+        dest_lat, dest_lon = dest_coords
+
+        try:
+            origin_node = self._get_nearest_node(origin_lat, origin_lon)
+            dest_node = self._get_nearest_node(dest_lat, dest_lon)
+        except Exception:
+            return None
+
+        # For 'fastest' mode, use simple length-based routing
+        if mode == "fastest" or mode == "fast":
+            result = self._compute_single_route(self.G, origin_node, dest_node, "length")
+            if result:
+                result.name = "fastest"
+                result.label = "Fastest"
+                result.color = ROUTE_COLORS.get("shortest", "#3b82f6")
+            return result
+
+        # For 'safest' mode, use runtime climate weight calculation
+        if climate_params is None:
+            climate_params = ClimateWeightParams()
+
+        # Use NetworkX with callable weight function for runtime calculation
+        weight_func = self._create_weight_function(climate_params)
+        result = self._compute_single_route_with_weight_func(
+            origin_node, dest_node, weight_func
+        )
+
+        if result:
+            result.name = "safest"
+            result.label = "Safest"
+            result.color = ROUTE_COLORS.get("safest", "#10b981")
+        return result
+
+    def _compute_single_route_with_weight_func(
+        self,
+        origin_node: int,
+        dest_node: int,
+        weight_func
+    ) -> RouteOption | None:
+        """Compute a single route using a callable weight function."""
+        try:
+            route = nx.shortest_path(self.G, origin_node, dest_node, weight=weight_func)
+            distance = sum(
+                self.G[u][v][0].get("length", 0) for u, v in zip(route[:-1], route[1:])
+            )
+            return RouteOption(
+                name="",
+                label="",
+                color="",
+                coords=self._get_route_coords(route),
+                distance_m=round(distance, 1),
+                time_min=round(distance / WALK_SPEED_M_PER_MIN, 1),
+                metrics=self._compute_route_metrics(route),
+                route_nodes=route,
+                climate_metrics=self._compute_climate_metrics(route),
+            )
+        except (nx.NetworkXNoPath, Exception):
+            return None
+
+    def compare_routes(
+        self,
+        origin_coords: tuple[float, float],
+        dest_coords: tuple[float, float],
+        dest_name: str = "Destination",
+        climate_params: ClimateWeightParams = None
+    ) -> RouteComparisonResult:
+        """
+        Compare shortest and safest routes between two points.
+
+        Returns both routes with comparison statistics showing the trade-off
+        between distance and climate risk.
+
+        Args:
+            origin_coords: (lat, lon) tuple for origin
+            dest_coords: (lat, lon) tuple for destination
+            dest_name: Optional name for the destination
+            climate_params: ClimateWeightParams for runtime weight calculation
+
+        Returns:
+            RouteComparisonResult with both routes and comparison stats
+        """
+        if not self._loaded:
+            return RouteComparisonResult(success=False, error="Engine not loaded")
+
+        if not self.has_climate_data:
+            return RouteComparisonResult(
+                success=False,
+                error="Climate data not available. Load climate-enhanced network first."
+            )
+
+        origin_lat, origin_lon = origin_coords
+        dest_lat, dest_lon = dest_coords
+
+        # Compute both routes - fastest uses length, safest uses climate weights
+        fastest = self.route(origin_coords, dest_coords, mode="fastest")
+        safest = self.route(origin_coords, dest_coords, mode="safest", climate_params=climate_params)
+
+        if not fastest:
+            return RouteComparisonResult(success=False, error="No path found for fastest route")
+        if not safest:
+            return RouteComparisonResult(success=False, error="No path found for safest route")
+
+        # Calculate comparison statistics
+        extra_distance_m = safest.distance_m - fastest.distance_m
+        extra_distance_pct = (extra_distance_m / fastest.distance_m * 100) if fastest.distance_m > 0 else 0
+
+        # Risk reduction is the difference in average climate risk
+        risk_reduction = fastest.climate_metrics.avg_climate_risk - safest.climate_metrics.avg_climate_risk
+
+        return RouteComparisonResult(
+            success=True,
+            shortest=fastest,
+            safest=safest,
+            origin=(origin_lat, origin_lon),
+            destination=(dest_lat, dest_lon),
+            dest_name=dest_name,
+            extra_distance_m=extra_distance_m,
+            extra_distance_pct=extra_distance_pct,
+            risk_reduction=risk_reduction,
+        )
+
+    def compute_routes(
+        self,
+        origin_lat: float,
+        origin_lon: float,
+        dest_lat: float,
+        dest_lon: float,
+        dest_name: str = "Destination",
+        climate_params: ClimateWeightParams = None
+    ) -> RoutingResult:
+        """Compute multiple route alternatives between two points.
+
+        Climate weights are computed at RUNTIME using configurable parameters.
+        The safest route uses runtime weight calculation based on flood, heat,
+        tree coverage, and air quality factors.
+
+        Args:
+            origin_lat, origin_lon: Origin coordinates
+            dest_lat, dest_lon: Destination coordinates
+            dest_name: Name of destination
+            climate_params: ClimateWeightParams for runtime weight calculation
+        """
+        if not self._loaded:
+            return RoutingResult(success=False, error="Engine not loaded")
+
+        try:
+            origin_node = self._get_nearest_node(origin_lat, origin_lon)
+            dest_node = self._get_nearest_node(dest_lat, dest_lon)
+        except Exception as e:
+            return RoutingResult(success=False, error=f"Could not locate points: {e}")
+
+        alternatives = []
+
+        # Shortest route (length only)
+        shortest = self._compute_single_route(self.G, origin_node, dest_node, "length")
+        if shortest:
+            shortest.name = "shortest"
+            shortest.label = "Shortest"
+            shortest.color = ROUTE_COLORS["shortest"]
+            alternatives.append(shortest)
+
+        # Flattest route
+        G_flat = self._apply_elevation_weights(penalty_factor=5.0)
+        flattest = self._compute_single_route(G_flat, origin_node, dest_node, "weighted_length")
+        if flattest and (not shortest or flattest.coords != shortest.coords):
+            flattest.name = "flattest"
+            flattest.label = "Flattest"
+            flattest.color = ROUTE_COLORS["flattest"]
+            alternatives.append(flattest)
+
+        # Balanced route
+        G_balanced = self._apply_elevation_weights(penalty_factor=2.0)
+        balanced = self._compute_single_route(G_balanced, origin_node, dest_node, "weighted_length")
+        if balanced:
+            existing_coords = [r.coords for r in alternatives]
+            if balanced.coords not in existing_coords:
+                balanced.name = "balanced"
+                balanced.label = "Balanced"
+                balanced.color = ROUTE_COLORS["balanced"]
+                alternatives.append(balanced)
+
+        # Safest route (climate-aware with runtime weight calculation)
+        if self.has_climate_data:
+            if climate_params is None:
+                climate_params = ClimateWeightParams()
+
+            weight_func = self._create_weight_function(climate_params)
+            safest = self._compute_single_route_with_weight_func(origin_node, dest_node, weight_func)
+            if safest:
+                existing_coords = [r.coords for r in alternatives]
+                if safest.coords not in existing_coords:
+                    # Different route - add as separate option
+                    safest.name = "safest"
+                    safest.label = "Safest (Climate)"
+                    safest.color = ROUTE_COLORS["safest"]
+                    alternatives.append(safest)
+                else:
+                    # Safest route has same path as an existing route (likely shortest)
+                    # Update the existing route to show it's ALSO the safest option
+                    for route in alternatives:
+                        if route.coords == safest.coords:
+                            if route.name == "shortest":
+                                route.label = "Shortest & Safest (Climate)"
+                            route.name = "safest"  # Mark as safest for recommendation
+                            break
+
+        if not alternatives:
+            return RoutingResult(success=False, error="No path found")
+
+        # CLIMATE-AWARE BY DEFAULT: Always recommend safest route when climate
+        # data is available to protect users from flood and heat exposure.
+        if self.has_climate_data and any(r.name == "safest" for r in alternatives):
+            recommended = "safest"
+        elif any(r.name == "flattest" for r in alternatives):
+            recommended = "flattest"
+        else:
+            recommended = "shortest"
+
+        return RoutingResult(
+            success=True,
+            recommended=recommended,
+            alternatives=alternatives,
+            origin=(origin_lat, origin_lon),
+            destination=(dest_lat, dest_lon),
+            dest_name=dest_name
+        )
+
+    def find_nearest_resource(
+        self,
+        resource_type: str,
+        origin_lat: float,
+        origin_lon: float,
+        prefer_safe: bool = True,
+        climate_params: ClimateWeightParams = None
+    ) -> tuple[dict[str, Any], dict | None]:
+        """
+        Find nearest resource of a given type with climate-aware route alternatives.
+
+        This function:
+        1. Finds the nearest resource by ROUTED distance (not crow-flies)
+        2. Computes multiple route alternatives (shortest, flattest, safest)
+        3. Recommends the safest route when climate data is available
+
+        Climate weights are computed at RUNTIME using configurable parameters,
+        allowing the LLM to adjust based on user context (flooding, heat, asthma, etc.).
+
+        Args:
+            resource_type: Type of resource to find
+            origin_lat: Origin latitude
+            origin_lon: Origin longitude
+            prefer_safe: If True and climate data available, prefer climate-safe routes
+            climate_params: ClimateWeightParams for runtime weight calculation
+        """
+        if not self._loaded:
+            return {"error": "Engine not loaded"}, None
+
+        if self.resources_df is None:
+            return {"error": "Resources not loaded"}, None
+
+        candidates = self.resources_df[self.resources_df["type"] == resource_type]
+        if len(candidates) == 0:
+            return {"error": f"No resources of type '{resource_type}' found"}, None
+
+        try:
+            origin_node = self._get_nearest_node(origin_lat, origin_lon)
+        except Exception as e:
+            return {"error": f"Could not find origin: {e}"}, None
+
+        # Find the nearest resource by ROUTED distance (not crow-flies)
+        # Use simple length-based routing to find which resource is nearest
+        best_resource = None
+        best_distance = float("inf")
+
+        for _, row in candidates.iterrows():
+            try:
+                dest_node = self._get_nearest_node(row["lat"], row["lon"])
+                # Use actual path length to determine nearest
+                route_length = nx.shortest_path_length(
+                    self.G, origin_node, dest_node, weight="length"
+                )
+                if route_length < best_distance:
+                    best_distance = route_length
+                    best_resource = row.to_dict()
+            except (nx.NetworkXNoPath, Exception):
+                continue
+
+        if best_resource is None:
+            return {"error": f"Could not find route to any {resource_type}"}, None
+
+        # Now compute route alternatives to the nearest resource
+        # This provides shortest, flattest, and safest (climate-aware) routes
+        routing_result = self.compute_routes(
+            origin_lat=origin_lat,
+            origin_lon=origin_lon,
+            dest_lat=best_resource["lat"],
+            dest_lon=best_resource["lon"],
+            dest_name=best_resource["name"],
+            climate_params=climate_params
+        )
+
+        if not routing_result.success:
+            return {"error": routing_result.error or "Could not compute routes"}, None
+
+        # Get the recommended route (safest when climate data available)
+        recommended_route = next(
+            (r for r in routing_result.alternatives if r.name == routing_result.recommended),
+            routing_result.alternatives[0] if routing_result.alternatives else None
+        )
+        if not recommended_route:
+            return {"error": "No route alternatives computed"}, None
+
+        # Build map data with all route alternatives
+        map_data = {
+            "routes": [
+                {
+                    "coords": alt.coords,
+                    "color": alt.color,
+                    "label": alt.label,
+                    "name": alt.name,
+                }
+                for alt in routing_result.alternatives
+            ],
+            "origin": [origin_lat, origin_lon],
+            "destination": [best_resource["lat"], best_resource["lon"]],
+            "dest_name": best_resource["name"],
+            "recommended": routing_result.recommended,
+        }
+
+        # Build result with resource info and route alternatives
+        result = {
+            "found": True,
+            "name": best_resource["name"],
+            "type": best_resource["type"],
+            "category": best_resource.get("category", ""),
+            "lat": best_resource["lat"],
+            "lon": best_resource["lon"],
+            "origin": {"lat": origin_lat, "lon": origin_lon},
+            # Include all route alternatives
+            "alternatives": [alt.to_dict() for alt in routing_result.alternatives],
+            "recommended": routing_result.recommended,
+            # Recommended route metrics for backward compatibility
+            "distance_meters": round(recommended_route.distance_m, 1),
+            "walking_time_minutes": round(recommended_route.time_min, 1),
+            "route_metrics": recommended_route.metrics.to_dict() if recommended_route.metrics else {},
+            "climate_metrics": recommended_route.climate_metrics.to_dict() if recommended_route.climate_metrics else {},
+            "climate_aware": prefer_safe and self.has_climate_data,
+        }
+
+        return result, map_data
+
+    def list_resources(self, resource_type: str = "", category: str = "") -> dict[str, Any]:
+        """List available resources with optional filtering."""
+        if self.resources_df is None:
+            return {"error": "Resources not loaded"}
+
+        df = self.resources_df.copy()
+        if category:
+            df = df[df["category"] == category]
+        if resource_type:
+            df = df[df["type"] == resource_type]
+
+        summary = df.groupby("type").agg({"name": "count", "category": "first"}).rename(
+            columns={"name": "count"}
+        ).to_dict("index")
+
+        return {
+            "total_count": len(df),
+            "by_type": summary,
+            "resources": df[["name", "type", "category", "lat", "lon"]].to_dict("records")[:20]
+        }
+
+    # -------------------------------------------------------------------------
+    # Isochrone Generation (reachable area within X minutes)
+    # -------------------------------------------------------------------------
+
+    def generate_isochrone(
+        self,
+        origin_lat: float,
+        origin_lon: float,
+        time_limits: list[int] = None,
+        resource_types: list[str] = None
+    ) -> IsochroneResult:
+        """
+        Generate isochrones showing areas reachable within given time limits.
+
+        Uses igraph SSSP if available for better performance, otherwise NetworkX.
+
+        Args:
+            origin_lat: Origin latitude
+            origin_lon: Origin longitude
+            time_limits: List of time limits in minutes (default: [5, 10, 15])
+            resource_types: Optional filter for resources to include
+
+        Returns:
+            IsochroneResult with polygon boundaries and resources within reach
+        """
+        if not self._loaded:
+            return IsochroneResult(success=False, error="Engine not loaded")
+
+        if time_limits is None:
+            time_limits = [5, 10, 15]
+
+        time_limits = sorted(time_limits)
+        max_time = max(time_limits)
+        max_distance = max_time * WALK_SPEED_M_PER_MIN
+
+        try:
+            origin_node = self._get_nearest_node(origin_lat, origin_lon)
+        except Exception as e:
+            return IsochroneResult(success=False, error=f"Could not locate origin: {e}")
+
+        # Compute distances from origin to all reachable nodes
+        if self.use_igraph and self.ig_graph is not None:
+            # Use igraph SSSP (faster for large graphs)
+            node_distances = self._compute_sssp_igraph(origin_node, max_distance)
+        else:
+            # Use NetworkX Dijkstra
+            node_distances = self._compute_sssp_networkx(origin_node, max_distance)
+
+        # Build isochrone polygons for each time limit
+        isochrones = []
+        for time_min in time_limits:
+            distance_limit = time_min * WALK_SPEED_M_PER_MIN
+            reachable_nodes = [n for n, d in node_distances.items() if d <= distance_limit]
+
+            if not reachable_nodes:
+                continue
+
+            # Get convex hull of reachable nodes
+            polygon_coords = self._nodes_to_polygon(reachable_nodes)
+
+            isochrones.append({
+                "time_min": time_min,
+                "polygon_coords": polygon_coords,
+                "color": ISOCHRONE_COLORS.get(time_min, "#6366f1"),
+                "node_count": len(reachable_nodes),
+            })
+
+        # Find resources within the max isochrone
+        resources_within = []
+        if self.resources_df is not None:
+            max_distance_nodes = {n for n, d in node_distances.items() if d <= max_distance}
+
+            for _, row in self.resources_df.iterrows():
+                if resource_types and row["type"] not in resource_types:
+                    continue
+
+                try:
+                    resource_node = self._get_nearest_node(row["lat"], row["lon"])
+                    if resource_node in max_distance_nodes:
+                        dist = node_distances.get(resource_node, float("inf"))
+                        time_to_reach = dist / WALK_SPEED_M_PER_MIN
+                        resources_within.append({
+                            "name": row["name"],
+                            "type": row["type"],
+                            "category": row.get("category", ""),
+                            "lat": row["lat"],
+                            "lon": row["lon"],
+                            "distance_meters": round(dist, 1),
+                            "walking_time_minutes": round(time_to_reach, 1),
+                        })
+                except Exception:
+                    continue
+
+            # Sort by distance
+            resources_within.sort(key=lambda x: x["distance_meters"])
+
+        return IsochroneResult(
+            success=True,
+            origin=(origin_lat, origin_lon),
+            isochrones=isochrones,
+            resources_within=resources_within[:20],  # Limit for display
+        )
+
+    def _compute_sssp_igraph(self, origin_node: int, max_distance: float) -> dict[int, float]:
+        """Compute single-source shortest paths using igraph."""
+        ig_origin = self.ig_node_map.get(origin_node)
+        if ig_origin is None:
+            return {}
+
+        # Run Dijkstra from origin using igraph's shortest_paths
+        all_distances = self.ig_graph.distances(source=ig_origin, weights="weight", mode="out")[0]
+
+        # Convert back to NetworkX node IDs
+        distances = {}
+        for ig_node, dist in enumerate(all_distances):
+            if dist != float("inf") and dist <= max_distance:
+                nx_node = self.ig_reverse_map.get(ig_node)
+                if nx_node is not None:
+                    distances[nx_node] = dist
+
+        return distances
+
+    def _compute_sssp_networkx(self, origin_node: int, max_distance: float) -> dict[int, float]:
+        """Compute single-source shortest paths using NetworkX."""
+        try:
+            # Use cutoff for efficiency
+            lengths = nx.single_source_dijkstra_path_length(
+                self.G, origin_node, cutoff=max_distance, weight="length"
+            )
+            return dict(lengths)
+        except Exception:
+            return {}
+
+    def _nodes_to_polygon(self, nodes: list[int]) -> list[tuple[float, float]]:
+        """Convert a set of nodes to a convex hull polygon in lat/lon."""
+        if len(nodes) < 3:
+            return []
+
+        # Get coordinates
+        coords = []
+        for node in nodes:
+            x = self.G.nodes[node].get("x", 0)
+            y = self.G.nodes[node].get("y", 0)
+            coords.append([x, y])
+
+        coords = np.array(coords)
+
+        # Compute convex hull
+        try:
+            from scipy.spatial import ConvexHull
+            hull = ConvexHull(coords)
+            hull_points = coords[hull.vertices]
+
+            # Convert to lat/lon
+            if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+                import pyproj
+                transformer = pyproj.Transformer.from_crs(
+                    self.G.graph["crs"], "EPSG:4326", always_xy=True
+                )
+                result = []
+                for x, y in hull_points:
+                    lon, lat = transformer.transform(x, y)
+                    result.append((lat, lon))
+                # Close the polygon
+                result.append(result[0])
+                return result
+            else:
+                result = [(y, x) for x, y in hull_points]
+                result.append(result[0])
+                return result
+        except Exception:
+            return []
+
+    # -------------------------------------------------------------------------
+    # Find Along Route (POI discovery along a route corridor)
+    # -------------------------------------------------------------------------
+
+    def find_along_route(
+        self,
+        origin_lat: float,
+        origin_lon: float,
+        dest_lat: float,
+        dest_lon: float,
+        buffer_meters: float = 100,
+        resource_types: list[str] = None
+    ) -> AlongRouteResult:
+        """
+        Find resources/POIs along a route corridor.
+
+        Args:
+            origin_lat, origin_lon: Route start
+            dest_lat, dest_lon: Route end
+            buffer_meters: Width of corridor to search (default 100m)
+            resource_types: Optional filter for resource types
+
+        Returns:
+            AlongRouteResult with POIs found along the route
+        """
+        if not self._loaded:
+            return AlongRouteResult(success=False, error="Engine not loaded")
+
+        if self.resources_df is None:
+            return AlongRouteResult(success=False, error="Resources not loaded")
+
+        # Compute the route first
+        routing_result = self.compute_routes(origin_lat, origin_lon, dest_lat, dest_lon)
+        if not routing_result.success:
+            return AlongRouteResult(success=False, error=routing_result.error)
+
+        # Get the recommended route
+        recommended = next(
+            (r for r in routing_result.alternatives if r.name == routing_result.recommended),
+            routing_result.alternatives[0]
+        )
+
+        route_coords = recommended.coords
+        if not route_coords:
+            return AlongRouteResult(success=False, error="No route coordinates")
+
+        # Convert route to projected coordinates for distance calculations
+        if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+            import pyproj
+            transformer = pyproj.Transformer.from_crs(
+                "EPSG:4326", self.G.graph["crs"], always_xy=True
+            )
+            projected_route = []
+            for lat, lon in route_coords:
+                x, y = transformer.transform(lon, lat)
+                projected_route.append([x, y])
+            projected_route = np.array(projected_route)
+        else:
+            projected_route = np.array([[lon, lat] for lat, lon in route_coords])
+
+        # Find resources within buffer distance of route
+        pois_found = []
+
+        for _, row in self.resources_df.iterrows():
+            if resource_types and row["type"] not in resource_types:
+                continue
+
+            # Get resource in projected coordinates
+            if "crs" in self.G.graph and self.G.graph["crs"] != "EPSG:4326":
+                x, y = transformer.transform(row["lon"], row["lat"])
+                point = np.array([x, y])
+            else:
+                point = np.array([row["lon"], row["lat"]])
+
+            # Calculate minimum distance to route
+            min_dist = self._point_to_polyline_distance(point, projected_route)
+
+            if min_dist <= buffer_meters:
+                # Find which segment of the route it's nearest to (for ordering)
+                segment_idx = self._nearest_segment_index(point, projected_route)
+
+                pois_found.append({
+                    "name": row["name"],
+                    "type": row["type"],
+                    "category": row.get("category", ""),
+                    "lat": row["lat"],
+                    "lon": row["lon"],
+                    "distance_from_route_m": round(min_dist, 1),
+                    "route_segment": segment_idx,
+                })
+
+        # Sort by route segment (so POIs appear in order along the route)
+        pois_found.sort(key=lambda x: x["route_segment"])
+
+        return AlongRouteResult(
+            success=True,
+            route_coords=route_coords,
+            pois_found=pois_found,
+            origin=(origin_lat, origin_lon),
+            destination=(dest_lat, dest_lon),
+            buffer_meters=buffer_meters,
+            climate_metrics=recommended.climate_metrics,
+        )
+
+    def _point_to_polyline_distance(self, point: np.ndarray, polyline: np.ndarray) -> float:
+        """Calculate minimum distance from a point to a polyline."""
+        min_dist = float("inf")
+
+        for i in range(len(polyline) - 1):
+            seg_start = polyline[i]
+            seg_end = polyline[i + 1]
+
+            # Vector from start to end
+            seg_vec = seg_end - seg_start
+            seg_len_sq = np.dot(seg_vec, seg_vec)
+
+            if seg_len_sq == 0:
+                # Segment is a point
+                dist = np.linalg.norm(point - seg_start)
+            else:
+                # Project point onto segment
+                t = max(0, min(1, np.dot(point - seg_start, seg_vec) / seg_len_sq))
+                projection = seg_start + t * seg_vec
+                dist = np.linalg.norm(point - projection)
+
+            min_dist = min(min_dist, dist)
+
+        return min_dist
+
+    def _nearest_segment_index(self, point: np.ndarray, polyline: np.ndarray) -> int:
+        """Find which segment of the polyline is nearest to the point."""
+        min_dist = float("inf")
+        nearest_idx = 0
+
+        for i in range(len(polyline) - 1):
+            seg_start = polyline[i]
+            seg_end = polyline[i + 1]
+            seg_vec = seg_end - seg_start
+            seg_len_sq = np.dot(seg_vec, seg_vec)
+
+            if seg_len_sq == 0:
+                dist = np.linalg.norm(point - seg_start)
+            else:
+                t = max(0, min(1, np.dot(point - seg_start, seg_vec) / seg_len_sq))
+                projection = seg_start + t * seg_vec
+                dist = np.linalg.norm(point - projection)
+
+            if dist < min_dist:
+                min_dist = dist
+                nearest_idx = i
+
+        return nearest_idx
+
+    # -------------------------------------------------------------------------
+    # Geocoding
+    # -------------------------------------------------------------------------
+
+    def geocode_query(self, query: str) -> tuple[str, dict]:
+        """Resolve place names in query to coordinates."""
+        geocode_info = {}
+        modified = query
+        query_lower = query.lower()
+
+        # Sort by name length for greedy matching
+        sorted_places = sorted(self.known_places.items(), key=lambda x: -len(x[0]))
+        used_spans = []
+
+        for name_lower, info in sorted_places:
+            pattern = r"\b" + re.escape(name_lower) + r"\b"
+            for match in re.finditer(pattern, query_lower):
+                start, end = match.span()
+                overlaps = any(not (end <= us or start >= ue) for us, ue in used_spans)
+                if not overlaps:
+                    geocode_info[info["name"]] = {
+                        "lat": info["lat"],
+                        "lon": info["lon"],
+                        "name": info["name"]
+                    }
+                    original_text = query[start:end]
+                    modified = re.compile(re.escape(original_text), re.IGNORECASE).sub(
+                        f"(lat {info['lat']:.6f}, lon {info['lon']:.6f})",
+                        modified,
+                        count=1
+                    )
+                    used_spans.append((start, end))
+
+        return modified, geocode_info
+
+
+# =============================================================================
+# Tool Executor (bridges LLM output to engine)
+# =============================================================================
+
+def _safe_str(val, default: str = "") -> str:
+    if val is None:
+        return default
+    if isinstance(val, list):
+        return str(val[0]) if val else default
+    return str(val)
+
+
+def _safe_float(val, default: float) -> float:
+    if val is None:
+        return default
+    if isinstance(val, list):
+        val = val[0] if val else default
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def _parse_climate_params(args: dict) -> ClimateWeightParams:
+    """Extract climate weight parameters from tool args.
+
+    The LLM can pass these parameters based on user context:
+    - flood_penalty_deep: 5.0 default, 10.0 for active flooding
+    - flood_penalty_shallow: 2.0 default, 4.0 for flooding conditions
+    - heat_factor: 0.3 default, 0.5 for hot days
+    - shade_factor: 0.3 default, 0.5 for shade-seeking
+    - aqi_factor: 0.1 default, 0.5 for respiratory concerns
+    - grade_factor: 0.2 default, 0.5 for elderly/mobility-impaired users
+    """
+    return ClimateWeightParams(
+        flood_penalty_deep=_safe_float(args.get("flood_penalty_deep"), 5.0),
+        flood_penalty_shallow=_safe_float(args.get("flood_penalty_shallow"), 2.0),
+        heat_factor=_safe_float(args.get("heat_factor"), 0.3),
+        shade_factor=_safe_float(args.get("shade_factor"), 0.3),
+        aqi_factor=_safe_float(args.get("aqi_factor"), 0.1),
+        grade_factor=_safe_float(args.get("grade_factor"), 0.2),
+    )
+
+
+def execute_tool(
+    tool_name: str,
+    args: dict,
+    engine: RoutingEngine
+) -> tuple[dict[str, Any], dict | None]:
+    """Execute a tool by name using the routing engine.
+
+    Climate weight parameters can be passed in args and will be used for
+    runtime weight calculation when routing.
+    """
+    # Parse climate parameters from args (LLM can set these based on context)
+    climate_params = _parse_climate_params(args)
+
+    if tool_name == "list_resources":
+        result = engine.list_resources(
+            resource_type=_safe_str(args.get("resource_type"), ""),
+            category=_safe_str(args.get("category"), "")
+        )
+        return result, None
+
+    elif tool_name == "find_nearest":
+        lat = args.get("lat") or args.get("origin_lat")
+        lon = args.get("lon") or args.get("origin_lon")
+        return engine.find_nearest_resource(
+            resource_type=_safe_str(args.get("resource_type"), ""),
+            origin_lat=_safe_float(lat, BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(lon, BROWNSVILLE_CENTER["lon"]),
+            climate_params=climate_params
+        )
+
+    elif tool_name == "calculate_route":
+        # Check for routing_mode parameter
+        routing_mode = _safe_str(args.get("routing_mode"), "safe")
+
+        result = engine.compute_routes(
+            origin_lat=_safe_float(args.get("start_lat") or args.get("origin_lat"), BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(args.get("start_lon") or args.get("origin_lon"), BROWNSVILLE_CENTER["lon"]),
+            dest_lat=_safe_float(args.get("end_lat") or args.get("dest_lat"), BROWNSVILLE_CENTER["lat"]),
+            dest_lon=_safe_float(args.get("end_lon") or args.get("dest_lon"), BROWNSVILLE_CENTER["lon"]),
+            dest_name=_safe_str(args.get("dest_name"), "Destination"),
+            climate_params=climate_params
+        )
+        return result.to_dict(), result.to_map_data()
+
+    elif tool_name == "generate_isochrone":
+        # Parse time limits - handle various formats like "10", "10 minutes", "5, 10, 15"
+        time_limits = args.get("time_limits", [5, 10, 15])
+        if isinstance(time_limits, str):
+            # Split by comma and extract numeric values
+            parsed = []
+            for x in time_limits.split(","):
+                # Extract just the numeric part (handles "10 minutes", "15 min", etc.)
+                import re
+                match = re.search(r'(\d+)', x.strip())
+                if match:
+                    parsed.append(int(match.group(1)))
+            time_limits = parsed if parsed else [5, 10, 15]
+        elif isinstance(time_limits, (int, float)):
+            time_limits = [int(time_limits)]
+        elif isinstance(time_limits, list):
+            # Ensure all elements are integers (LLM may return strings like ["5", "10"])
+            time_limits = [int(x) if isinstance(x, (int, float, str)) and str(x).isdigit() else 10 for x in time_limits]
+            if not time_limits:
+                time_limits = [5, 10, 15]
+
+        # Parse resource types filter
+        resource_types = args.get("resource_types")
+        if isinstance(resource_types, str):
+            resource_types = [x.strip() for x in resource_types.split(",")]
+
+        lat = args.get("lat") or args.get("origin_lat")
+        lon = args.get("lon") or args.get("origin_lon")
+
+        result = engine.generate_isochrone(
+            origin_lat=_safe_float(lat, BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(lon, BROWNSVILLE_CENTER["lon"]),
+            time_limits=time_limits,
+            resource_types=resource_types
+        )
+        return result.to_dict(), result.to_map_data()
+
+    elif tool_name == "find_along_route":
+        # Parse resource types filter
+        resource_types = args.get("resource_types")
+        if isinstance(resource_types, str):
+            resource_types = [x.strip() for x in resource_types.split(",")]
+
+        result = engine.find_along_route(
+            origin_lat=_safe_float(args.get("start_lat") or args.get("origin_lat"), BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(args.get("start_lon") or args.get("origin_lon"), BROWNSVILLE_CENTER["lon"]),
+            dest_lat=_safe_float(args.get("end_lat") or args.get("dest_lat"), BROWNSVILLE_CENTER["lat"]),
+            dest_lon=_safe_float(args.get("end_lon") or args.get("dest_lon"), BROWNSVILLE_CENTER["lon"]),
+            buffer_meters=_safe_float(args.get("buffer_meters"), 100),
+            resource_types=resource_types
+        )
+        return result.to_dict(), result.to_map_data()
+
+    elif tool_name == "compare_routes":
+        # Compare fastest vs safest (climate-aware) routes
+        origin_lat = _safe_float(args.get("start_lat") or args.get("origin_lat"), BROWNSVILLE_CENTER["lat"])
+        origin_lon = _safe_float(args.get("start_lon") or args.get("origin_lon"), BROWNSVILLE_CENTER["lon"])
+        dest_lat = _safe_float(args.get("end_lat") or args.get("dest_lat"), BROWNSVILLE_CENTER["lat"])
+        dest_lon = _safe_float(args.get("end_lon") or args.get("dest_lon"), BROWNSVILLE_CENTER["lon"])
+
+        result = engine.compare_routes(
+            origin_coords=(origin_lat, origin_lon),
+            dest_coords=(dest_lat, dest_lon),
+            dest_name=_safe_str(args.get("dest_name"), "Destination"),
+            climate_params=climate_params
+        )
+        return result.to_dict(), result.to_map_data()
+
+    elif tool_name == "climate_route":
+        # Single route with mode selection and climate parameters
+        origin_lat = _safe_float(args.get("start_lat") or args.get("origin_lat"), BROWNSVILLE_CENTER["lat"])
+        origin_lon = _safe_float(args.get("start_lon") or args.get("origin_lon"), BROWNSVILLE_CENTER["lon"])
+        dest_lat = _safe_float(args.get("end_lat") or args.get("dest_lat"), BROWNSVILLE_CENTER["lat"])
+        dest_lon = _safe_float(args.get("end_lon") or args.get("dest_lon"), BROWNSVILLE_CENTER["lon"])
+        mode = _safe_str(args.get("mode") or args.get("routing_mode"), "safest")
+
+        result = engine.route(
+            origin_coords=(origin_lat, origin_lon),
+            dest_coords=(dest_lat, dest_lon),
+            mode=mode,
+            climate_params=climate_params
+        )
+
+        if result is None:
+            return {"error": "No path found"}, None
+
+        map_data = {
+            "routes": [{
+                "coords": result.coords,
+                "color": result.color,
+                "label": result.label,
+                "name": result.name,
+            }],
+            "origin": [origin_lat, origin_lon],
+            "destination": [dest_lat, dest_lon],
+        }
+
+        return result.to_dict(), map_data
+
+    else:
+        return {"error": f"Unknown tool: {tool_name}"}, None

core/tools.py

@@ -0,0 +1,884 @@
+"""
+Routing tools for the Emergency Routing Assistant.
+
+Uses dream-meridian pattern:
+1. Geocode place names BEFORE sending to LLM
+2. LLM outputs simple JSON tool call
+3. Execute tool and return result
+"""
+
+import os
+import re
+import networkx as nx
+import pandas as pd
+import geopandas as gpd
+import osmnx as ox
+import requests
+from typing import Any
+
+# Walking speed: ~4.5 km/h = 75 m/min
+WALK_SPEED_M_PER_MIN = 75
+
+# Elevation penalty factor for routing (higher = more avoidance of elevation gain)
+ELEVATION_PENALTY_FACTOR = 3.0
+
+# Brownsville center and bounds
+BROWNSVILLE_CENTER = {"lat": 40.6594, "lon": -73.9126}
+BROWNSVILLE_BOUNDS = {
+    "min_lat": 40.64,
+    "max_lat": 40.68,
+    "min_lon": -73.93,
+    "max_lon": -73.89
+}
+
+# Known places - loaded from data/brownsville/places.csv
+# These are matched BEFORE sending query to LLM
+KNOWN_PLACES = {}
+
+
+def load_known_places():
+    """Load known places from the places.csv file."""
+    global KNOWN_PLACES
+
+    # Look in project root's data directory (one level up from core/)
+    places_path = os.path.join(os.path.dirname(__file__), "..", "data", "brownsville", "places.csv")
+
+    if os.path.exists(places_path):
+        try:
+            df = pd.read_csv(places_path)
+            for _, row in df.iterrows():
+                name_lower = row['name_lower']
+                KNOWN_PLACES[name_lower] = {
+                    "lat": row['lat'],
+                    "lon": row['lon'],
+                    "name": row['name']
+                }
+            print(f"Loaded {len(KNOWN_PLACES)} places for geocoding")
+        except Exception as e:
+            print(f"Warning: Could not load places: {e}")
+    else:
+        print(f"Warning: places.csv not found at {places_path}")
+
+
+# Load places on module import
+load_known_places()
+
+# Intersection patterns to match
+INTERSECTION_PATTERN = re.compile(
+    r"(\w+(?:\s+\w+)?)\s+(?:and|&|at)\s+(\w+(?:\s+\w+)?)",
+    re.IGNORECASE
+)
+
+# ============================================================================
+# Geocoding (runs BEFORE LLM)
+# ============================================================================
+
+def find_place_in_query(query: str) -> list[tuple[str, dict]]:
+    """
+    Find known place names in a query.
+    Returns list of (matched_text, place_info) tuples.
+    Matches longest places first.
+    """
+    query_lower = query.lower()
+    matches = []
+    used_spans = []
+
+    # Sort by name length (longest first) for greedy matching
+    sorted_places = sorted(KNOWN_PLACES.items(), key=lambda x: -len(x[0]))
+
+    for name_lower, info in sorted_places:
+        # Use word boundaries
+        pattern = r"\b" + re.escape(name_lower) + r"\b"
+        for match in re.finditer(pattern, query_lower):
+            start, end = match.span()
+
+            # Check overlap with existing matches
+            overlaps = any(
+                not (end <= us or start >= ue) for us, ue in used_spans
+            )
+
+            if not overlaps:
+                original_text = query[start:end]
+                matches.append((original_text, info))
+                used_spans.append((start, end))
+
+    return matches
+
+
+def geocode_nominatim(place_name: str) -> dict | None:
+    """Fallback: geocode using Nominatim API."""
+    try:
+        search_query = f"{place_name}, Brownsville, Brooklyn, NY"
+        url = "https://nominatim.openstreetmap.org/search"
+        params = {
+            "q": search_query,
+            "format": "json",
+            "limit": 3,
+            "viewbox": f"{BROWNSVILLE_BOUNDS['min_lon']},{BROWNSVILLE_BOUNDS['max_lat']},{BROWNSVILLE_BOUNDS['max_lon']},{BROWNSVILLE_BOUNDS['min_lat']}",
+            "bounded": 0
+        }
+        headers = {"User-Agent": "BrownsvilleEmergencyApp/1.0"}
+
+        response = requests.get(url, params=params, headers=headers, timeout=5)
+        results = response.json()
+
+        if results:
+            # Find result nearest to Brownsville
+            for r in results:
+                lat, lon = float(r["lat"]), float(r["lon"])
+                if (BROWNSVILLE_BOUNDS["min_lat"] - 0.02 <= lat <= BROWNSVILLE_BOUNDS["max_lat"] + 0.02 and
+                    BROWNSVILLE_BOUNDS["min_lon"] - 0.02 <= lon <= BROWNSVILLE_BOUNDS["max_lon"] + 0.02):
+                    return {"name": place_name, "lat": lat, "lon": lon}
+            # Fallback to first result
+            return {"name": place_name, "lat": float(results[0]["lat"]), "lon": float(results[0]["lon"])}
+    except Exception:
+        pass
+    return None
+
+
+def geocode_query(query: str, resources_df: pd.DataFrame = None) -> tuple[str, dict]:
+    """
+    Process query to resolve place names to coordinates BEFORE sending to LLM.
+
+    Returns:
+        tuple: (modified_query, geocode_info)
+        - modified_query: Query with place names replaced by coordinates
+        - geocode_info: Dict of resolved places
+    """
+    geocode_info = {}
+    modified = query
+
+    # First try known places
+    matches = find_place_in_query(query)
+
+    for original_text, info in matches:
+        geocode_info[info["name"]] = {
+            "lat": info["lat"],
+            "lon": info["lon"],
+            "name": info["name"]
+        }
+        # Replace in query with coordinates
+        pattern = re.compile(re.escape(original_text), re.IGNORECASE)
+        modified = pattern.sub(
+            f"(lat {info['lat']:.6f}, lon {info['lon']:.6f})",
+            modified,
+            count=1
+        )
+
+    # If no matches, try to find location phrases and geocode them
+    if not matches:
+        # Look for "near X", "at X", "to X" patterns
+        location_patterns = [
+            r"near\s+([A-Za-z][A-Za-z\s]+?)(?:\s+(?:and|&)\s+|\s*$)",
+            r"to\s+([A-Za-z][A-Za-z\s]+?)(?:\s+(?:and|&)\s+|\s*$)",
+            r"at\s+([A-Za-z][A-Za-z\s]+?)(?:\s+(?:and|&)\s+|\s*$)",
+        ]
+        for pattern in location_patterns:
+            match = re.search(pattern, query, re.IGNORECASE)
+            if match:
+                place_name = match.group(1).strip()
+                # Skip if it's a resource type
+                if place_name.lower() not in ["pharmacy", "clinic", "hospital", "school", "library", "fire station", "police"]:
+                    result = geocode_nominatim(place_name)
+                    if result:
+                        geocode_info[result["name"]] = result
+                        modified = query.replace(
+                            match.group(0),
+                            f"near (lat {result['lat']:.6f}, lon {result['lon']:.6f}) "
+                        )
+                        break
+
+    return modified, geocode_info
+
+
+def _convert_climate_attrs_to_float(G: nx.MultiDiGraph) -> None:
+    """Convert climate attributes from strings to floats (GraphML stores all as strings)."""
+    climate_attrs = ['flood_risk', 'heat_risk', 'climate_risk', 'climate_weight']
+
+    for u, v, data in G.edges(data=True):
+        for attr in climate_attrs:
+            if attr in data and isinstance(data[attr], str):
+                try:
+                    data[attr] = float(data[attr])
+                except (ValueError, TypeError):
+                    data[attr] = 0.0
+
+
+def load_network_and_resources() -> tuple[nx.MultiDiGraph | None, pd.DataFrame | None, tuple[float, float]]:
+    """Load the walking network and resources from saved files."""
+    data_dir = os.path.join(os.path.dirname(__file__), "data", "brownsville")
+
+    # Default center
+    center = (40.6594, -73.9126)
+
+    try:
+        # Load walking network
+        graphml_path = os.path.join(data_dir, "walking_network_final.graphml")
+        if os.path.exists(graphml_path):
+            G_walk = ox.load_graphml(graphml_path)
+        else:
+            # Fallback: load from OSM directly
+            from shapely.geometry import box
+            brownsville_bbox = box(-73.93, 40.64, -73.89, 40.68)
+            G_walk = ox.graph_from_polygon(brownsville_bbox, network_type='walk', simplify=True)
+
+        # Convert climate attributes from strings to floats
+        _convert_climate_attrs_to_float(G_walk)
+
+        # Project the graph to enable fast nearest_nodes lookup without scikit-learn
+        G_walk = ox.project_graph(G_walk)
+
+        # Load resources
+        resources_path = os.path.join(data_dir, "all_resources.csv")
+        if os.path.exists(resources_path):
+            resources_df = pd.read_csv(resources_path)
+        else:
+            # Try GeoJSON
+            geojson_path = os.path.join(data_dir, "all_resources.geojson")
+            if os.path.exists(geojson_path):
+                gdf = gpd.read_file(geojson_path)
+                resources_df = pd.DataFrame({
+                    "name": gdf["name"],
+                    "type": gdf["type"],
+                    "category": gdf["category"],
+                    "lat": gdf.geometry.y,
+                    "lon": gdf.geometry.x
+                })
+            else:
+                resources_df = None
+
+        return G_walk, resources_df, center
+
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        return None, None, center
+
+
+def get_nearest_node(G: nx.MultiDiGraph, lat: float, lon: float) -> int:
+    """Find the nearest network node to a point (handles projected graphs)."""
+    # For projected graphs, convert lat/lon to projected coordinates
+    if "crs" in G.graph and G.graph["crs"] != "EPSG:4326":
+        import pyproj
+        transformer = pyproj.Transformer.from_crs("EPSG:4326", G.graph["crs"], always_xy=True)
+        x, y = transformer.transform(lon, lat)
+        return ox.nearest_nodes(G, x, y)
+    return ox.nearest_nodes(G, lon, lat)
+
+
+def get_route_coords(G: nx.MultiDiGraph, route: list) -> list[tuple[float, float]]:
+    """Extract lat/lon coordinates from route nodes (handles projected graphs)."""
+    if "crs" in G.graph and G.graph["crs"] != "EPSG:4326":
+        import pyproj
+        transformer = pyproj.Transformer.from_crs(G.graph["crs"], "EPSG:4326", always_xy=True)
+        coords = []
+        for node in route:
+            x, y = G.nodes[node]["x"], G.nodes[node]["y"]
+            lon, lat = transformer.transform(x, y)
+            coords.append((lat, lon))
+        return coords
+    return [(G.nodes[node]["y"], G.nodes[node]["x"]) for node in route]
+
+
+def compute_route_metrics(G: nx.MultiDiGraph, route: list) -> dict:
+    """
+    Compute detailed metrics for a route including elevation profile.
+
+    Returns dict with:
+        - elevation_gain_m: Total meters climbed
+        - elevation_loss_m: Total meters descended
+        - max_elevation_m: Highest point on route
+        - min_elevation_m: Lowest point on route
+        - avg_grade_pct: Average slope percentage
+        - max_grade_pct: Steepest segment
+        - difficulty: "flat", "moderate", or "hilly"
+    """
+    if not route or len(route) < 2:
+        return {
+            "elevation_gain_m": 0, "elevation_loss_m": 0,
+            "max_elevation_m": 0, "min_elevation_m": 0,
+            "avg_grade_pct": 0, "max_grade_pct": 0,
+            "difficulty": "flat"
+        }
+
+    elevations = []
+    grades = []
+    elevation_gain = 0
+    elevation_loss = 0
+
+    for i, node in enumerate(route):
+        elev = G.nodes[node].get("elevation", 0)
+        if elev is None:
+            elev = 0
+        elevations.append(elev)
+
+        if i > 0:
+            prev_elev = elevations[i-1]
+            diff = elev - prev_elev
+            if diff > 0:
+                elevation_gain += diff
+            else:
+                elevation_loss += abs(diff)
+
+            # Get grade from edge if available
+            prev_node = route[i-1]
+            edge_data = G.get_edge_data(prev_node, node)
+            if edge_data:
+                # MultiDiGraph returns dict of edges
+                first_edge = list(edge_data.values())[0] if isinstance(edge_data, dict) else edge_data
+                grade = abs(first_edge.get("grade", 0)) * 100  # Convert to percentage
+                grades.append(grade)
+
+    max_elev = max(elevations) if elevations else 0
+    min_elev = min(elevations) if elevations else 0
+    avg_grade = sum(grades) / len(grades) if grades else 0
+    max_grade = max(grades) if grades else 0
+
+    # Classify difficulty
+    if elevation_gain < 5 and max_grade < 3:
+        difficulty = "flat"
+    elif elevation_gain < 15 or max_grade < 8:
+        difficulty = "moderate"
+    else:
+        difficulty = "hilly"
+
+    return {
+        "elevation_gain_m": round(elevation_gain, 1),
+        "elevation_loss_m": round(elevation_loss, 1),
+        "max_elevation_m": round(max_elev, 1),
+        "min_elevation_m": round(min_elev, 1),
+        "avg_grade_pct": round(avg_grade, 1),
+        "max_grade_pct": round(max_grade, 1),
+        "difficulty": difficulty
+    }
+
+
+def has_climate_data(G: nx.MultiDiGraph) -> bool:
+    """Check if the graph has climate data on edges."""
+    sample_edge = next(iter(G.edges(data=True)), None)
+    if sample_edge and "climate_weight" in sample_edge[2]:
+        return True
+    return False
+
+
+def compute_climate_metrics(G: nx.MultiDiGraph, route: list) -> dict:
+    """
+    Compute climate risk metrics for a route.
+
+    Returns dict with:
+        - avg_flood_risk: Average flood risk along route (0-1)
+        - max_flood_risk: Maximum flood risk encountered
+        - avg_heat_risk: Average heat risk along route (0-1)
+        - max_heat_risk: Maximum heat risk encountered
+        - avg_climate_risk: Combined climate risk (0-1)
+        - flood_exposure_m: Meters of route in high flood risk areas (>0.3)
+    """
+    if not route or len(route) < 2:
+        return {
+            "avg_flood_risk": 0, "max_flood_risk": 0,
+            "avg_heat_risk": 0, "max_heat_risk": 0,
+            "avg_climate_risk": 0, "flood_exposure_m": 0
+        }
+
+    flood_risks = []
+    heat_risks = []
+    climate_risks = []
+    flood_exposure = 0.0
+
+    for i in range(len(route) - 1):
+        u, v = route[i], route[i + 1]
+        edge_data = G.get_edge_data(u, v)
+        if not edge_data:
+            continue
+
+        # Get first edge (MultiDiGraph may have multiple)
+        if isinstance(edge_data, dict) and 0 in edge_data:
+            data = edge_data[0]
+        else:
+            data = next(iter(edge_data.values())) if isinstance(edge_data, dict) else edge_data
+
+        flood = float(data.get("flood_risk", 0) or 0)
+        heat = float(data.get("heat_risk", 0) or 0)
+        climate = float(data.get("climate_risk", 0) or 0)
+        length = float(data.get("length", 0) or 0)
+
+        flood_risks.append(flood)
+        heat_risks.append(heat)
+        climate_risks.append(climate)
+
+        if flood > 0.3:
+            flood_exposure += length
+
+    if not climate_risks:
+        return {
+            "avg_flood_risk": 0, "max_flood_risk": 0,
+            "avg_heat_risk": 0, "max_heat_risk": 0,
+            "avg_climate_risk": 0, "flood_exposure_m": 0
+        }
+
+    return {
+        "avg_flood_risk": round(sum(flood_risks) / len(flood_risks), 3),
+        "max_flood_risk": round(max(flood_risks), 3),
+        "avg_heat_risk": round(sum(heat_risks) / len(heat_risks), 3),
+        "max_heat_risk": round(max(heat_risks), 3),
+        "avg_climate_risk": round(sum(climate_risks) / len(climate_risks), 3),
+        "flood_exposure_m": round(flood_exposure, 1)
+    }
+
+
+def apply_elevation_weights(G: nx.MultiDiGraph, penalty_factor: float = ELEVATION_PENALTY_FACTOR) -> nx.MultiDiGraph:
+    """
+    Create a copy of the graph with edge weights adjusted for elevation.
+
+    Penalizes uphill segments to find routes that minimize climbing.
+    """
+    G_weighted = G.copy()
+
+    for u, v, key, data in G_weighted.edges(keys=True, data=True):
+        base_length = data.get("length", 1)
+
+        # Get elevation change
+        elev_u = G_weighted.nodes[u].get("elevation", 0) or 0
+        elev_v = G_weighted.nodes[v].get("elevation", 0) or 0
+        elev_diff = elev_v - elev_u
+
+        # Only penalize uphill (positive elevation change)
+        if elev_diff > 0:
+            # Penalty proportional to climb: each meter of climb adds penalty_factor meters equivalent
+            penalty = elev_diff * penalty_factor
+            data["weighted_length"] = base_length + penalty
+        else:
+            data["weighted_length"] = base_length
+
+    return G_weighted
+
+
+
+
+def list_resources(
+    resources_df: pd.DataFrame,
+    category: str = "",
+    resource_type: str = ""
+) -> dict[str, Any]:
+    """List available resources with optional filtering."""
+    if resources_df is None:
+        return {"error": "Resources not loaded"}
+
+    df = resources_df.copy()
+
+    # Ensure category and resource_type are strings (LLM might pass lists or other types)
+    if isinstance(category, list):
+        category = category[0] if category else ""
+    if isinstance(resource_type, list):
+        resource_type = resource_type[0] if resource_type else ""
+
+    category = str(category) if category else ""
+    resource_type = str(resource_type) if resource_type else ""
+
+    if category:
+        df = df[df["category"] == category]
+
+    if resource_type:
+        df = df[df["type"] == resource_type]
+
+    # Group by type
+    summary = df.groupby("type").agg({
+        "name": "count",
+        "category": "first"
+    }).rename(columns={"name": "count"}).to_dict("index")
+
+    # List of resources
+    resources = df[["name", "type", "category", "lat", "lon"]].to_dict("records")
+
+    return {
+        "total_count": len(df),
+        "by_type": summary,
+        "resources": resources[:20]  # Limit to 20 for display
+    }
+
+
+def find_nearest(
+    G: nx.MultiDiGraph,
+    resources_df: pd.DataFrame,
+    resource_type: str,
+    origin_lat: float = 40.6594,
+    origin_lon: float = -73.9126,
+    prefer_flat: bool = True,
+    prefer_safe: bool = True
+) -> tuple[dict[str, Any], dict | None]:
+    """
+    Find the nearest resource of a given type with climate and elevation-aware routing.
+
+    Args:
+        G: Walking network graph
+        resources_df: DataFrame of resources
+        resource_type: Type of resource to find
+        origin_lat: Origin latitude
+        origin_lon: Origin longitude
+        prefer_flat: If True, prefer routes with less elevation gain
+        prefer_safe: If True and climate data available, prefer climate-safe routes
+    """
+    if resources_df is None:
+        return {"error": "Resources not loaded"}, None
+
+    # Ensure resource_type is a string
+    if isinstance(resource_type, list):
+        resource_type = resource_type[0] if resource_type else ""
+    resource_type = str(resource_type) if resource_type else ""
+
+    if not resource_type:
+        return {"error": "resource_type is required"}, None
+
+    # Filter by type
+    candidates = resources_df[resources_df["type"] == resource_type]
+
+    if len(candidates) == 0:
+        return {"error": f"No resources of type '{resource_type}' found"}, None
+
+    # Get origin node
+    try:
+        origin_node = get_nearest_node(G, origin_lat, origin_lon)
+    except Exception as e:
+        return {"error": f"Could not find origin on network: {e}"}, None
+
+    # Choose routing strategy based on climate data availability
+    graph_has_climate = has_climate_data(G)
+
+    if prefer_safe and graph_has_climate:
+        # Use climate-aware routing (uses pre-computed climate_weight)
+        G_routing = G
+        weight_key = "climate_weight"
+    elif prefer_flat:
+        # Fall back to elevation-aware routing
+        G_routing = apply_elevation_weights(G)
+        weight_key = "weighted_length"
+    else:
+        G_routing = G
+        weight_key = "length"
+
+    # Find nearest
+    best_resource = None
+    best_distance = float("inf")
+    best_route = None
+    best_actual_distance = 0
+
+    for _, row in candidates.iterrows():
+        try:
+            dest_node = get_nearest_node(G, row["lat"], row["lon"])
+            # Use weighted distance for comparison
+            weighted_distance = nx.shortest_path_length(G_routing, origin_node, dest_node, weight=weight_key)
+
+            if weighted_distance < best_distance:
+                best_distance = weighted_distance
+                best_resource = row.to_dict()
+                best_route = nx.shortest_path(G_routing, origin_node, dest_node, weight=weight_key)
+                # Calculate actual distance (unweighted)
+                best_actual_distance = nx.shortest_path_length(G, origin_node, dest_node, weight="length")
+        except nx.NetworkXNoPath:
+            continue
+        except Exception:
+            continue
+
+    if best_resource is None:
+        return {"error": f"Could not find a route to any {resource_type}"}, None
+
+    walk_time = best_actual_distance / WALK_SPEED_M_PER_MIN
+
+    # Compute route metrics
+    route_metrics = compute_route_metrics(G, best_route)
+
+    # Build map data (convert projected coords to lat/lon)
+    route_coords = get_route_coords(G, best_route)
+
+    map_data = {
+        "route_coords": route_coords,
+        "origin": [origin_lat, origin_lon],
+        "destination": [best_resource["lat"], best_resource["lon"]],
+        "dest_name": best_resource["name"],
+        "distance": best_actual_distance
+    }
+
+    result = {
+        "found": True,
+        "name": best_resource["name"],
+        "type": best_resource["type"],
+        "category": best_resource["category"],
+        "lat": best_resource["lat"],
+        "lon": best_resource["lon"],
+        "distance_meters": round(best_actual_distance, 1),
+        "walking_time_minutes": round(walk_time, 1),
+        "origin": {"lat": origin_lat, "lon": origin_lon},
+        "route_metrics": route_metrics
+    }
+
+    # Add climate metrics if available
+    if graph_has_climate:
+        result["climate_metrics"] = compute_climate_metrics(G, best_route)
+        result["climate_aware"] = prefer_safe
+
+    return result, map_data
+
+
+def compute_single_route(
+    G: nx.MultiDiGraph,
+    origin_node: int,
+    dest_node: int,
+    weight_key: str = "length"
+) -> dict | None:
+    """Compute a single route and its metrics."""
+    try:
+        route = nx.shortest_path(G, origin_node, dest_node, weight=weight_key)
+        # Always compute actual distance using length
+        distance = sum(
+            G[u][v][0].get("length", 0) for u, v in zip(route[:-1], route[1:])
+        )
+        walk_time = distance / WALK_SPEED_M_PER_MIN
+        route_metrics = compute_route_metrics(G, route)
+        route_coords = get_route_coords(G, route)
+
+        return {
+            "route": route,
+            "coords": route_coords,
+            "distance_m": round(distance, 1),
+            "time_min": round(walk_time, 1),
+            "metrics": route_metrics
+        }
+    except nx.NetworkXNoPath:
+        return None
+    except Exception:
+        return None
+
+
+def compute_alternative_routes(
+    G: nx.MultiDiGraph,
+    origin_lat: float,
+    origin_lon: float,
+    dest_lat: float,
+    dest_lon: float
+) -> list[dict]:
+    """
+    Compute multiple route alternatives with different optimization criteria.
+
+    Returns list of route options:
+        - shortest: Minimum distance
+        - flattest: Minimum elevation gain (penalizes uphill)
+        - balanced: Compromise between distance and elevation
+        - safest: Minimum climate risk (flood + heat) if climate data available
+    """
+    origin_node = get_nearest_node(G, origin_lat, origin_lon)
+    dest_node = get_nearest_node(G, dest_lat, dest_lon)
+
+    routes = []
+    graph_has_climate = has_climate_data(G)
+
+    # 1. Shortest route (distance only)
+    shortest = compute_single_route(G, origin_node, dest_node, weight_key="length")
+    if shortest:
+        shortest["name"] = "shortest"
+        shortest["label"] = "Shortest"
+        shortest["color"] = "#3b82f6"  # Blue
+        if graph_has_climate:
+            shortest["climate_metrics"] = compute_climate_metrics(G, shortest["route"])
+        routes.append(shortest)
+
+    # 2. Flattest route (heavy elevation penalty)
+    G_flat = apply_elevation_weights(G, penalty_factor=5.0)
+    flattest = compute_single_route(G_flat, origin_node, dest_node, weight_key="weighted_length")
+    if flattest:
+        flattest["name"] = "flattest"
+        flattest["label"] = "Flattest"
+        flattest["color"] = "#22c55e"  # Green
+        if graph_has_climate:
+            flattest["climate_metrics"] = compute_climate_metrics(G, flattest["route"])
+        # Check if it's actually different from shortest
+        if not shortest or flattest["coords"] != shortest["coords"]:
+            routes.append(flattest)
+
+    # 3. Balanced route (moderate elevation penalty)
+    G_balanced = apply_elevation_weights(G, penalty_factor=2.0)
+    balanced = compute_single_route(G_balanced, origin_node, dest_node, weight_key="weighted_length")
+    if balanced:
+        balanced["name"] = "balanced"
+        balanced["label"] = "Balanced"
+        balanced["color"] = "#f59e0b"  # Amber
+        if graph_has_climate:
+            balanced["climate_metrics"] = compute_climate_metrics(G, balanced["route"])
+        # Check if it's different from both shortest and flattest
+        existing_coords = [r["coords"] for r in routes]
+        if balanced["coords"] not in existing_coords:
+            routes.append(balanced)
+
+    # 4. Safest route (climate-aware) - only if climate data available
+    if graph_has_climate:
+        safest = compute_single_route(G, origin_node, dest_node, weight_key="climate_weight")
+        if safest:
+            safest["name"] = "safest"
+            safest["label"] = "Safest (Climate)"
+            safest["color"] = "#10b981"  # Emerald
+            safest["climate_metrics"] = compute_climate_metrics(G, safest["route"])
+            # Check if it's different from existing routes
+            existing_coords = [r["coords"] for r in routes]
+            if safest["coords"] not in existing_coords:
+                routes.append(safest)
+
+    return routes
+
+
+def calculate_route(
+    G: nx.MultiDiGraph,
+    origin_lat: float,
+    origin_lon: float,
+    dest_lat: float,
+    dest_lon: float,
+    dest_name: str = "Destination",
+    prefer_flat: bool = True,
+    prefer_safe: bool = True
+) -> tuple[dict[str, Any], dict | None]:
+    """
+    Calculate multiple walking routes between two points with different criteria.
+
+    Args:
+        G: Walking network graph
+        origin_lat, origin_lon: Origin coordinates
+        dest_lat, dest_lon: Destination coordinates
+        dest_name: Name of destination
+        prefer_flat: Prefer routes with less elevation gain
+        prefer_safe: If True and climate data available, recommend safest route
+    """
+    try:
+        # Compute all route alternatives
+        alternatives = compute_alternative_routes(G, origin_lat, origin_lon, dest_lat, dest_lon)
+
+        if not alternatives:
+            return {"error": "No path found between origin and destination"}, None
+
+        # Check if climate data is available
+        graph_has_climate = has_climate_data(G)
+
+        # Pick recommended route based on preferences
+        if prefer_safe and graph_has_climate:
+            recommended = next((r for r in alternatives if r["name"] == "safest"), alternatives[0])
+        elif prefer_flat:
+            recommended = next((r for r in alternatives if r["name"] == "flattest"), alternatives[0])
+        else:
+            recommended = next((r for r in alternatives if r["name"] == "shortest"), alternatives[0])
+
+        # Build map data with all routes
+        map_data = {
+            "routes": [
+                {
+                    "coords": r["coords"],
+                    "color": r["color"],
+                    "label": r["label"],
+                    "name": r["name"]
+                }
+                for r in alternatives
+            ],
+            "origin": [origin_lat, origin_lon],
+            "destination": [dest_lat, dest_lon],
+            "dest_name": dest_name,
+            "distance": recommended["distance_m"],
+            # Keep route_coords for backwards compatibility
+            "route_coords": recommended["coords"]
+        }
+
+        # Build alternatives with climate metrics if available
+        alt_list = []
+        for r in alternatives:
+            alt_info = {
+                "name": r["name"],
+                "label": r["label"],
+                "distance_meters": r["distance_m"],
+                "walking_time_minutes": r["time_min"],
+                "route_metrics": r["metrics"]
+            }
+            if graph_has_climate and "climate_metrics" in r:
+                alt_info["climate_metrics"] = r["climate_metrics"]
+            alt_list.append(alt_info)
+
+        # Build result
+        result = {
+            "success": True,
+            "recommended": recommended["name"],
+            "alternatives": alt_list,
+            "distance_meters": recommended["distance_m"],
+            "walking_time_minutes": recommended["time_min"],
+            "route_points": len(recommended["route"]),
+            "origin": {"lat": origin_lat, "lon": origin_lon},
+            "destination": {"lat": dest_lat, "lon": dest_lon, "name": dest_name},
+            "route_metrics": recommended["metrics"]
+        }
+
+        # Add climate metrics to result if available
+        if graph_has_climate:
+            result["climate_aware"] = True
+            if "climate_metrics" in recommended:
+                result["climate_metrics"] = recommended["climate_metrics"]
+
+        return result, map_data
+
+    except nx.NetworkXNoPath:
+        return {"error": "No path found between origin and destination"}, None
+    except Exception as e:
+        return {"error": f"Route calculation failed: {e}"}, None
+
+
+def _safe_str(val, default: str = "") -> str:
+    """Safely convert a value to string, handling lists."""
+    if val is None:
+        return default
+    if isinstance(val, list):
+        return str(val[0]) if val else default
+    return str(val)
+
+
+def _safe_float(val, default: float) -> float:
+    """Safely convert a value to float."""
+    if val is None:
+        return default
+    if isinstance(val, list):
+        val = val[0] if val else default
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def execute_tool(
+    tool_name: str,
+    args: dict,
+    G: nx.MultiDiGraph,
+    resources_df: pd.DataFrame
+) -> tuple[dict[str, Any], dict | None]:
+    """Execute a tool by name with given arguments."""
+    if tool_name == "list_resources":
+        result = list_resources(
+            resources_df,
+            category=_safe_str(args.get("category"), ""),
+            resource_type=_safe_str(args.get("resource_type"), "")
+        )
+        return result, None
+
+    elif tool_name == "find_nearest":
+        # Accept both "lat"/"lon" (from system prompt) and "origin_lat"/"origin_lon"
+        lat = args.get("lat") or args.get("origin_lat")
+        lon = args.get("lon") or args.get("origin_lon")
+        return find_nearest(
+            G,
+            resources_df,
+            resource_type=_safe_str(args.get("resource_type"), ""),
+            origin_lat=_safe_float(lat, BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(lon, BROWNSVILLE_CENTER["lon"])
+        )
+
+    elif tool_name == "calculate_route":
+        return calculate_route(
+            G,
+            origin_lat=_safe_float(args.get("start_lat") or args.get("origin_lat"), BROWNSVILLE_CENTER["lat"]),
+            origin_lon=_safe_float(args.get("start_lon") or args.get("origin_lon"), BROWNSVILLE_CENTER["lon"]),
+            dest_lat=_safe_float(args.get("end_lat") or args.get("dest_lat"), BROWNSVILLE_CENTER["lat"]),
+            dest_lon=_safe_float(args.get("end_lon") or args.get("dest_lon"), BROWNSVILLE_CENTER["lon"]),
+            dest_name=_safe_str(args.get("dest_name"), "Destination")
+        )
+
+    else:
+        return {"error": f"Unknown tool: {tool_name}"}, None

data/brownsville/graph_cache.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39d0af50afbc39fdfd05246ee2d4874a6daf978444012d06caaa5c800537618c
+size 2786588

data/brownsville/pois_metadata.json

@@ -0,0 +1,31 @@
+{
+  "location": "Brownsville, Brooklyn, New York City, USA",
+  "center": [
+    40.6594,
+    -73.9126
+  ],
+  "bounds": {
+    "min_lat": 40.64,
+    "max_lat": 40.68,
+    "min_lon": -73.93,
+    "max_lon": -73.89
+  },
+  "created": "2026-01-16 21:37:19",
+  "updated": "2026-01-16",
+  "enriched": true,
+  "stats": {
+    "emergency_services": 10,
+    "community_resources": 35,
+    "places": 25233,
+    "total_resources": 1204,
+    "bodegas": 168,
+    "grocery_stores": 73,
+    "supermarkets": 9
+  },
+  "data_sources": [
+    "nyc_facilities",
+    "osm",
+    "overpass",
+    "ny_state_retail"
+  ]
+}

data/tool_embeddings.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6324efa3251f3b319f206fb683e298c03d0b58f668a7b16cb3f673cf07b5dc3
+size 8882

requirements.txt

@@ -0,0 +1,14 @@
+streamlit>=1.28.0
+pandas>=2.1.0
+folium>=0.14.0
+streamlit-folium>=0.15.0
+networkx>=3.0
+osmnx>=1.6.0
+ollama>=0.1.0
+geopandas>=0.14.0
+shapely>=2.0.0
+scikit-learn>=1.3.0
+pyproj>=3.6.0
+igraph>=0.11.0
+sentence-transformers>=2.2.0
+numpy>=1.24.0

start.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Start Ollama server in the background
+ollama serve &
+
+# Wait for Ollama to be ready
+echo "Waiting for Ollama to start..."
+until curl -s http://localhost:11434/api/tags > /dev/null 2>&1; do
+    sleep 1
+done
+echo "Ollama is ready!"
+
+# Pull the model (if not already present)
+echo "Pulling qwen2.5:3b model..."
+ollama pull qwen2.5:3b
+
+# Start Streamlit
+echo "Starting Streamlit app..."
+exec streamlit run app.py