Uploaded codebass

app.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+CAVA Platform - Main Application
+"""
+
+from config import (
+    API_KEY,
+    NASA_FIRMS_MAP_KEY,
+    GRADIO_SERVER_NAME,
+    GRADIO_SERVER_PORT,
+    GRADIO_SHARE,
+    model,
+)
+from ui.ui import ClimateRiskUI
+
+
+def main():
+    """Main function to launch the application."""
+
+    # Check API key configuration
+    if not API_KEY or API_KEY == "your-anthropic-api-key-here":
+        print("⚠️  WARNING: ANTHROPIC_API_KEY not properly configured!")
+        print("   Please add your API key to the .env file:")
+        print("   ANTHROPIC_API_KEY=your-actual-api-key-here")
+        print("   You can get one at: https://console.anthropic.com/")
+        print("")
+    else:
+        print("✅ Anthropic API key loaded from .env file")
+
+    if not NASA_FIRMS_MAP_KEY or NASA_FIRMS_MAP_KEY == "your-nasa-firms-api-key-here":
+        print("ℹ️  NASA FIRMS API key not configured (optional)")
+        print("   For wildfire data, add to .env: NASA_FIRMS_MAP_KEY=your-key")
+        print("")
+    else:
+        print("✅ NASA FIRMS API key loaded from .env file")
+
+    try:
+        ui = ClimateRiskUI(model)
+        app = ui.create_interface()
+
+        print("🚀 Launching CAVA-AI Platform...")
+        print(f"📱 Open your browser and go to: http://localhost:{GRADIO_SERVER_PORT}")
+        print("")
+
+        app.launch(
+            server_name=GRADIO_SERVER_NAME,
+            server_port=GRADIO_SERVER_PORT,
+            share=GRADIO_SHARE,
+            show_error=True,
+        )
+
+    except Exception as e:
+        print(f"❌ Launch error: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,32 @@
+import os
+from dotenv import load_dotenv
+from smolagents import LiteLLMModel
+
+from phoenix.otel import register
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+
+register()
+SmolagentsInstrumentor().instrument()
+
+import os
+
+load_dotenv()
+
+# API Configuration
+API_KEY = os.getenv("OPENAI_API_KEY", "ANTHROPIC_API_KEY")
+if not API_KEY:
+    print("⚠️ API key not found in .env file!")
+
+NASA_FIRMS_MAP_KEY = os.getenv("NASA_FIRMS_MAP_KEY", "b16df29134bfb809c751d7e283c71312")
+
+# Server configuration
+GRADIO_SERVER_NAME = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
+GRADIO_SERVER_PORT = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+GRADIO_SHARE = os.getenv("GRADIO_SHARE", "False").lower() == "true"
+
+# Model configuration
+MODEL_ID = os.getenv("MODEL_ID", "claude-sonnet-4-20250514")
+
+
+# Initialize the model
+model = LiteLLMModel(model_id=MODEL_ID, api_key="PLACE ANTHROPIC API KEY OR OTHER API KEY HERE")

mapping_utils.py

@@ -0,0 +1,517 @@
+import requests
+import folium
+
+COUNTRIES_AND_CITIES = {
+    "Afghanistan": ["Kabul", "Kandahar", "Herat", "Mazar-i-Sharif", "Jalalabad"],
+    "Albania": ["Tirana", "Durrës", "Vlorë", "Shkodër", "Fier"],
+    "Algeria": ["Algiers", "Oran", "Constantine", "Annaba", "Blida"],
+    "Argentina": ["Buenos Aires", "Córdoba", "Rosario", "Mendoza", "La Plata"],
+    "Armenia": ["Yerevan", "Gyumri", "Vanadzor", "Vagharshapat", "Hrazdan"],
+    "Australia": [
+        "Sydney",
+        "Melbourne",
+        "Brisbane",
+        "Perth",
+        "Adelaide",
+        "Gold Coast",
+        "Newcastle",
+        "Canberra",
+        "Sunshine Coast",
+        "Wollongong",
+    ],
+    "Austria": ["Vienna", "Graz", "Linz", "Salzburg", "Innsbruck"],
+    "Azerbaijan": ["Baku", "Ganja", "Sumqayit", "Mingachevir", "Lankaran"],
+    "Bahrain": ["Manama", "Riffa", "Muharraq", "Hamad Town", "A'ali"],
+    "Bangladesh": ["Dhaka", "Chittagong", "Sylhet", "Rajshahi", "Khulna"],
+    "Belarus": ["Minsk", "Gomel", "Mogilev", "Vitebsk", "Grodno"],
+    "Belgium": ["Brussels", "Antwerp", "Ghent", "Charleroi", "Liège"],
+    "Bolivia": ["La Paz", "Santa Cruz", "Cochabamba", "Sucre", "Oruro"],
+    "Bosnia and Herzegovina": ["Sarajevo", "Banja Luka", "Tuzla", "Zenica", "Mostar"],
+    "Brazil": [
+        "São Paulo",
+        "Rio de Janeiro",
+        "Brasília",
+        "Salvador",
+        "Fortaleza",
+        "Belo Horizonte",
+        "Manaus",
+        "Curitiba",
+        "Recife",
+        "Goiânia",
+    ],
+    "Bulgaria": ["Sofia", "Plovdiv", "Varna", "Burgas", "Ruse"],
+    "Cambodia": ["Phnom Penh", "Siem Reap", "Battambang", "Sihanoukville", "Poipet"],
+    "Canada": [
+        "Toronto",
+        "Montreal",
+        "Vancouver",
+        "Calgary",
+        "Edmonton",
+        "Ottawa",
+        "Winnipeg",
+        "Quebec City",
+        "Hamilton",
+        "Kitchener",
+    ],
+    "Chile": ["Santiago", "Valparaíso", "Concepción", "La Serena", "Antofagasta"],
+    "China": [
+        "Shanghai",
+        "Beijing",
+        "Chongqing",
+        "Tianjin",
+        "Guangzhou",
+        "Shenzhen",
+        "Wuhan",
+        "Dongguan",
+        "Chengdu",
+        "Nanjing",
+    ],
+    "Colombia": ["Bogotá", "Medellín", "Cali", "Barranquilla", "Cartagena"],
+    "Croatia": ["Zagreb", "Split", "Rijeka", "Osijek", "Zadar"],
+    "Czech Republic": ["Prague", "Brno", "Ostrava", "Plzen", "Liberec"],
+    "Denmark": ["Copenhagen", "Aarhus", "Odense", "Aalborg", "Esbjerg"],
+    "Ecuador": ["Quito", "Guayaquil", "Cuenca", "Santo Domingo", "Machala"],
+    "Egypt": ["Cairo", "Alexandria", "Giza", "Shubra El Kheima", "Port Said"],
+    "Estonia": ["Tallinn", "Tartu", "Narva", "Pärnu", "Kohtla-Järve"],
+    "Ethiopia": ["Addis Ababa", "Dire Dawa", "Mekelle", "Adama", "Awassa"],
+    "Finland": ["Helsinki", "Espoo", "Tampere", "Vantaa", "Oulu"],
+    "France": [
+        "Paris",
+        "Lyon",
+        "Marseille",
+        "Toulouse",
+        "Nice",
+        "Nantes",
+        "Strasbourg",
+        "Montpellier",
+        "Bordeaux",
+        "Lille",
+    ],
+    "Georgia": ["Tbilisi", "Batumi", "Kutaisi", "Rustavi", "Gori"],
+    "Germany": [
+        "Berlin",
+        "Hamburg",
+        "Munich",
+        "Cologne",
+        "Frankfurt",
+        "Stuttgart",
+        "Düsseldorf",
+        "Dortmund",
+        "Essen",
+        "Leipzig",
+    ],
+    "Ghana": ["Accra", "Kumasi", "Tamale", "Takoradi", "Cape Coast"],
+    "Greece": ["Athens", "Thessaloniki", "Patras", "Heraklion", "Larissa"],
+    "Hungary": ["Budapest", "Debrecen", "Szeged", "Miskolc", "Pécs"],
+    "Iceland": ["Reykjavik", "Kópavogur", "Hafnarfjörður", "Akureyri", "Reykjanesbær"],
+    "India": [
+        "Mumbai",
+        "Delhi",
+        "Bangalore",
+        "Hyderabad",
+        "Chennai",
+        "Kolkata",
+        "Ahmedabad",
+        "Pune",
+        "Surat",
+        "Jaipur",
+    ],
+    "Indonesia": [
+        "Jakarta",
+        "Surabaya",
+        "Bandung",
+        "Bekasi",
+        "Medan",
+        "Tangerang",
+        "Depok",
+        "Semarang",
+        "Palembang",
+        "Makassar",
+    ],
+    "Iran": ["Tehran", "Mashhad", "Isfahan", "Karaj", "Shiraz"],
+    "Iraq": ["Baghdad", "Basra", "Mosul", "Erbil", "Najaf"],
+    "Ireland": ["Dublin", "Cork", "Limerick", "Galway", "Waterford"],
+    "Israel": ["Jerusalem", "Tel Aviv", "Haifa", "Rishon LeZion", "Petah Tikva"],
+    "Italy": [
+        "Rome",
+        "Milan",
+        "Naples",
+        "Turin",
+        "Palermo",
+        "Genoa",
+        "Bologna",
+        "Florence",
+        "Bari",
+        "Catania",
+    ],
+    "Japan": [
+        "Tokyo",
+        "Osaka",
+        "Yokohama",
+        "Nagoya",
+        "Sapporo",
+        "Fukuoka",
+        "Kobe",
+        "Kawasaki",
+        "Kyoto",
+        "Saitama",
+    ],
+    "Jordan": ["Amman", "Zarqa", "Irbid", "Russeifa", "Wadi as-Ser"],
+    "Kazakhstan": ["Almaty", "Nur-Sultan", "Shymkent", "Aktobe", "Taraz"],
+    "Kenya": ["Nairobi", "Mombasa", "Kisumu", "Nakuru", "Eldoret"],
+    "Kuwait": ["Kuwait City", "Al Ahmadi", "Hawalli", "As Salimiyah", "Sabah as Salim"],
+    "Latvia": ["Riga", "Daugavpils", "Liepāja", "Jelgava", "Jūrmala"],
+    "Lebanon": ["Beirut", "Tripoli", "Sidon", "Tyre", "Nabatieh"],
+    "Lithuania": ["Vilnius", "Kaunas", "Klaipėda", "Šiauliai", "Panevėžys"],
+    "Luxembourg": [
+        "Luxembourg City",
+        "Esch-sur-Alzette",
+        "Differdange",
+        "Dudelange",
+        "Ettelbruck",
+    ],
+    "Malaysia": ["Kuala Lumpur", "George Town", "Ipoh", "Shah Alam", "Petaling Jaya"],
+    "Mexico": [
+        "Mexico City",
+        "Guadalajara",
+        "Monterrey",
+        "Puebla",
+        "Tijuana",
+        "León",
+        "Juárez",
+        "Torreón",
+        "Querétaro",
+        "Mérida",
+    ],
+    "Morocco": ["Casablanca", "Rabat", "Fez", "Marrakech", "Agadir"],
+    "Nepal": ["Kathmandu", "Pokhara", "Lalitpur", "Bharatpur", "Biratnagar"],
+    "Netherlands": [
+        "Amsterdam",
+        "Rotterdam",
+        "The Hague",
+        "Utrecht",
+        "Eindhoven",
+        "Tilburg",
+        "Groningen",
+        "Almere",
+        "Breda",
+        "Nijmegen",
+    ],
+    "New Zealand": ["Auckland", "Wellington", "Christchurch", "Hamilton", "Tauranga"],
+    "Nigeria": ["Lagos", "Abuja", "Kano", "Ibadan", "Port Harcourt"],
+    "Norway": [
+        "Oslo",
+        "Bergen",
+        "Trondheim",
+        "Stavanger",
+        "Drammen",
+        "Fredrikstad",
+        "Kristiansand",
+        "Sandnes",
+        "Tromsø",
+        "Sarpsborg",
+    ],
+    "Pakistan": ["Karachi", "Lahore", "Faisalabad", "Rawalpindi", "Multan"],
+    "Peru": ["Lima", "Arequipa", "Trujillo", "Chiclayo", "Huancayo"],
+    "Philippines": ["Manila", "Quezon City", "Davao", "Cebu City", "Zamboanga"],
+    "Poland": ["Warsaw", "Kraków", "Łódź", "Wrocław", "Poznań"],
+    "Portugal": ["Lisbon", "Porto", "Vila Nova de Gaia", "Amadora", "Braga"],
+    "Qatar": ["Doha", "Al Rayyan", "Umm Salal", "Al Wakrah", "Al Khor"],
+    "Romania": ["Bucharest", "Cluj-Napoca", "Timișoara", "Iași", "Constanța"],
+    "Russia": [
+        "Moscow",
+        "Saint Petersburg",
+        "Novosibirsk",
+        "Yekaterinburg",
+        "Kazan",
+        "Nizhny Novgorod",
+        "Chelyabinsk",
+        "Samara",
+        "Omsk",
+        "Rostov-on-Don",
+    ],
+    "Saudi Arabia": ["Riyadh", "Jeddah", "Mecca", "Medina", "Dammam"],
+    "Serbia": ["Belgrade", "Novi Sad", "Niš", "Kragujevac", "Subotica"],
+    "Singapore": ["Singapore"],
+    "Slovakia": ["Bratislava", "Košice", "Prešov", "Žilina", "Banská Bystrica"],
+    "Slovenia": ["Ljubljana", "Maribor", "Celje", "Kranj", "Velenje"],
+    "South Africa": [
+        "Cape Town",
+        "Johannesburg",
+        "Durban",
+        "Pretoria",
+        "Port Elizabeth",
+    ],
+    "South Korea": [
+        "Seoul",
+        "Busan",
+        "Incheon",
+        "Daegu",
+        "Daejeon",
+        "Gwangju",
+        "Suwon",
+        "Ulsan",
+        "Changwon",
+        "Goyang",
+    ],
+    "Spain": [
+        "Madrid",
+        "Barcelona",
+        "Valencia",
+        "Seville",
+        "Zaragoza",
+        "Málaga",
+        "Murcia",
+        "Palma",
+        "Las Palmas",
+        "Bilbao",
+    ],
+    "Sri Lanka": [
+        "Colombo",
+        "Dehiwala-Mount Lavinia",
+        "Moratuwa",
+        "Sri Jayawardenepura Kotte",
+        "Negombo",
+    ],
+    "Sweden": [
+        "Stockholm",
+        "Gothenburg",
+        "Malmö",
+        "Uppsala",
+        "Västerås",
+        "Örebro",
+        "Linköping",
+        "Helsingborg",
+        "Jönköping",
+        "Norrköping",
+    ],
+    "Switzerland": [
+        "Zurich",
+        "Geneva",
+        "Basel",
+        "Bern",
+        "Lausanne",
+        "Winterthur",
+        "Lucerne",
+        "St. Gallen",
+        "Lugano",
+        "Biel/Bienne",
+    ],
+    "Thailand": ["Bangkok", "Chiang Mai", "Pattaya", "Phuket", "Hat Yai"],
+    "Turkey": [
+        "Istanbul",
+        "Ankara",
+        "Izmir",
+        "Bursa",
+        "Adana",
+        "Gaziantep",
+        "Konya",
+        "Antalya",
+        "Kayseri",
+        "Mersin",
+    ],
+    "Ukraine": ["Kyiv", "Kharkiv", "Odesa", "Dnipro", "Donetsk"],
+    "United Arab Emirates": ["Dubai", "Abu Dhabi", "Sharjah", "Al Ain", "Ajman"],
+    "United Kingdom": [
+        "London",
+        "Birmingham",
+        "Manchester",
+        "Leeds",
+        "Liverpool",
+        "Sheffield",
+        "Bristol",
+        "Glasgow",
+        "Leicester",
+        "Edinburgh",
+    ],
+    "United States": [
+        "New York",
+        "Los Angeles",
+        "Chicago",
+        "Houston",
+        "Phoenix",
+        "Philadelphia",
+        "San Antonio",
+        "San Diego",
+        "Dallas",
+        "San Jose",
+    ],
+    "Uruguay": ["Montevideo", "Salto", "Paysandú", "Las Piedras", "Rivera"],
+    "Venezuela": ["Caracas", "Maracaibo", "Valencia", "Barquisimeto", "Maracay"],
+    "Vietnam": ["Ho Chi Minh City", "Hanoi", "Da Nang", "Bien Hoa", "Hue"],
+}
+
+US_STATES = [
+    "Alabama",
+    "Alaska",
+    "Arizona",
+    "Arkansas",
+    "California",
+    "Colorado",
+    "Connecticut",
+    "Delaware",
+    "Florida",
+    "Georgia",
+    "Hawaii",
+    "Idaho",
+    "Illinois",
+    "Indiana",
+    "Iowa",
+    "Kansas",
+    "Kentucky",
+    "Louisiana",
+    "Maine",
+    "Maryland",
+    "Massachusetts",
+    "Michigan",
+    "Minnesota",
+    "Mississippi",
+    "Missouri",
+    "Montana",
+    "Nebraska",
+    "Nevada",
+    "New Hampshire",
+    "New Jersey",
+    "New Mexico",
+    "New York",
+    "North Carolina",
+    "North Dakota",
+    "Ohio",
+    "Oklahoma",
+    "Oregon",
+    "Pennsylvania",
+    "Rhode Island",
+    "South Carolina",
+    "South Dakota",
+    "Tennessee",
+    "Texas",
+    "Utah",
+    "Vermont",
+    "Virginia",
+    "Washington",
+    "West Virginia",
+    "Wisconsin",
+    "Wyoming",
+    "District of Columbia",
+]
+
+
+def get_coordinates_from_dropdown(country: str, city: str, state: str = None) -> tuple:
+    """Get coordinates using dropdown selections"""
+    if not country or not city:
+        return None, "Please select both country and city."
+
+    if country == "United States" and state:
+        query = f"{city}, {state}, United States"
+    else:
+        query = f"{city}, {country}"
+
+    try:
+        url = "https://nominatim.openstreetmap.org/search"
+        params = {"q": query, "format": "json", "limit": 1}
+        headers = {"User-Agent": "ClimateRiskTool/1.0"}
+
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        data = response.json()
+
+        if data:
+            lat = float(data[0]["lat"])
+            lon = float(data[0]["lon"])
+            return (
+                lat,
+                lon,
+            ), f"✅ Location found: {data[0].get('display_name', query)}"
+        else:
+            return None, f"❌ Location '{city}' not found in {country}."
+
+    except Exception as e:
+        return None, f"❌ Error looking up location: {str(e)}"
+
+
+def create_risk_map(
+    lat: float, lon: float, city: str, country: str, risk_analysis: dict = None
+) -> str:
+    import folium
+
+    # Carte centrée sur la ville
+    m = folium.Map(location=[lat, lon], zoom_start=10, tiles="OpenStreetMap")
+
+    # Définition du popup de risque
+    marker_color = "blue"
+    popup_html = f"<b>{city}, {country}</b><br>Lat: {lat:.4f}<br>Lon: {lon:.4f}"
+
+    # S'il y a des risques, complète le popup et change la couleur du marker
+    if risk_analysis and isinstance(risk_analysis, dict):
+        risks = risk_analysis.get("risk_analysis", {})
+        popup_html += "<br><b>Risks for this location:</b><br>"
+        max_level = 0
+        for risk_name, risk_data in risks.items():
+            if isinstance(risk_data, dict):
+                risk_level = risk_data.get("risk_level", 0)
+                max_level = max(max_level, risk_level)
+                if risk_level > 80:
+                    emoji = "🔴"
+                elif risk_level > 60:
+                    emoji = "🟠"
+                elif risk_level > 40:
+                    emoji = "🟡"
+                elif risk_level > 20:
+                    emoji = "🟢"
+                else:
+                    emoji = "⚪"
+                popup_html += f"{emoji} <b>{risk_name.title()}:</b> {risk_level}/100<br>"
+
+        # Couleur du marker selon le risque max détecté
+        if max_level > 80:
+            marker_color = "red"
+        elif max_level > 60:
+            marker_color = "orange"
+        elif max_level > 40:
+            marker_color = "lightgreen"
+        elif max_level > 20:
+            marker_color = "green"
+        else:
+            marker_color = "blue"
+
+    # Création du marker principal
+    marker = folium.Marker(
+        [lat, lon],
+        popup=popup_html,
+        tooltip=f"Risks for {city}",
+        icon=folium.Icon(color=marker_color, icon="info-sign"),
+    )
+    marker.add_to(m)
+
+    # Script pour ouvrir automatiquement le popup à l’affichage
+    script = f"""
+    <script>
+        var marker = {marker.get_name()};
+        marker.openPopup();
+    </script>
+    """
+    m.get_root().html.add_child(folium.Element(script))
+
+    # Légende
+    legend_html = """
+    <div style="position: fixed; 
+                top: 10px; right: 10px; width: 280px; height: auto; 
+                background-color: white; border: 2px solid grey; z-index: 9999; 
+                font-size: 13px; padding: 12px; border-radius: 10px;
+                box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+        <h4 style="margin: 0 0 10px 0;">🗺️ Legend</h4>
+        <div><span style="color:red;">🔴</span> High risk<br>
+        <span style="color:orange;">🟠</span> Moderate risk<br>
+        <span style="color:yellow;">🟡</span> Mild risk<br>
+        <span style="color:green;">🟢</span> Low risk</div>
+    </div>
+    """
+    m.get_root().html.add_child(folium.Element(legend_html))
+
+    return m._repr_html_()
+
+def get_city_suggestions(country: str) -> str:
+    """Return city suggestions for selected country"""
+    if country in COUNTRIES_AND_CITIES:
+        cities = COUNTRIES_AND_CITIES[country]
+        return f"💡 Popular cities in {country}: {', '.join(cities[:8])}..."
+    return ""

orchestrator.py

@@ -0,0 +1,79 @@
+from datetime import datetime
+from agents.risk_agent import RiskAnalysisAgent
+from agents.recommendation_agents import (
+    EmergencyRecommendationAgent,
+    HouseholdAdaptationAgent,
+    BusinessContinuityAgent,
+    FinancialAdaptationAgent,
+)
+
+
+class ClimateRiskOrchestrator:
+    """Main orchestrator that coordinates all agents."""
+
+    def __init__(self, model):
+        self.risk_agent = RiskAnalysisAgent(model)
+        self.emergency_agent = EmergencyRecommendationAgent(model)
+        self.household_agent = HouseholdAdaptationAgent(model)
+        self.business_agent = BusinessContinuityAgent(model)
+        self.financial_agent = FinancialAdaptationAgent(model)
+
+    def analyze_and_recommend(self, user_query: str, user_profile: dict) -> dict:
+        """Main method that coordinates risk analysis and recommendation generation."""
+        try:
+            print("🔍 Analyzing risks...")
+            risk_analysis = self.risk_agent.analyze_risks(user_query)
+
+            recommendations = {}
+
+            print("🚨 Generating emergency recommendations...")
+            recommendations["emergency"] = (
+                self.emergency_agent.generate_emergency_recommendations(
+                    risk_analysis, user_profile
+                )
+            )
+
+            print("💰 Generating financial recommendations...")
+            recommendations["financial"] = (
+                self.financial_agent.generate_financial_recommendations(
+                    risk_analysis, user_profile
+                )
+            )
+
+            profile_type = user_profile.get("type", "general").lower()
+
+            if profile_type in [
+                "household",
+                "residential",
+                "general",
+                "general public",
+            ]:
+                print("🏠 Generating household recommendations...")
+                recommendations["household"] = (
+                    self.household_agent.generate_household_recommendations(
+                        risk_analysis, user_profile
+                    )
+                )
+
+            if profile_type in ["business", "business owner"]:
+                print("🏢 Generating business recommendations...")
+                recommendations["business"] = (
+                    self.business_agent.generate_business_recommendations(
+                        risk_analysis, user_profile
+                    )
+                )
+
+            return {
+                "risk_analysis": risk_analysis,
+                "recommendations": recommendations,
+                "generated_at": datetime.now().isoformat(),
+                "user_profile": user_profile,
+            }
+
+        except Exception as e:
+            return {
+                "error": f"Analysis failed: {str(e)}",
+                "risk_analysis": {},
+                "recommendations": {},
+                "generated_at": datetime.now().isoformat(),
+            }

recommendation_agents.py

@@ -0,0 +1,355 @@
+import json
+import ast
+from typing import List
+import litellm
+from smolagents import CodeAgent
+from tools.tools import find_local_emergency_resources
+
+
+class EmergencyRecommendationAgent:
+    """Agent focused on emergency preparedness recommendations."""
+
+    def __init__(self, model):
+        self.agent = CodeAgent(
+            tools=[find_local_emergency_resources],
+            model=model,
+            additional_authorized_imports=["json", "datetime"],
+        )
+
+    def generate_emergency_recommendations(
+        self, risk_analysis: dict, user_profile: dict
+    ) -> List[str]:
+        """Generate emergency preparedness recommendations."""
+
+        prompt = f"""
+You are an emergency preparedness expert. Based on this risk analysis and user profile, generate 3-7 specific, actionable emergency recommendations.
+
+Risk Analysis: {str(risk_analysis)}
+User Profile: {str(user_profile)}
+
+Your recommendations should be:
+- Specific and actionable
+- Tailored to the identified risks
+- Appropriate for the user's situation
+- Prioritized by urgency/importance
+
+Focus on immediate actions they can take to prepare for or mitigate the identified risks.
+
+IMPORTANT: Return a simple Python list of strings, like this:
+["Create an emergency kit with 72 hours of supplies", "Identify evacuation routes", "Install smoke detectors"]
+
+Do not return JSON or any other format - just a Python list.
+"""
+
+        try:
+            try:
+                response = self.agent.run(prompt)
+            except Exception as e:
+                print(e)
+            #response = self.agent.run(prompt)
+            #response = litellm.completion(messages=prompt, model="anthropic/claude-sonnet-4-20250514")
+
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, str):
+                try:
+                    return ast.literal_eval(response)
+                except (ValueError, SyntaxError):
+                    try:
+                        return json.loads(response)
+                    except json.JSONDecodeError:
+                        return self._extract_recommendations_from_text(response)
+            else:
+                return [
+                    "Prepare emergency supplies",
+                    "Review evacuation plans",
+                    "Monitor weather alerts",
+                ]
+
+        except Exception as e:
+            print(f"Emergency recommendations error: {e}")
+            return [
+                "Create an emergency kit with 72 hours of supplies",
+                "Identify and practice evacuation routes",
+                "Keep important documents in waterproof container",
+                "Monitor local emergency alerts and warnings",
+            ]
+
+    def _extract_recommendations_from_text(self, text: str) -> List[str]:
+        """Extract recommendations from text response."""
+        lines = text.split("\n")
+        recommendations = []
+        for line in lines:
+            line = line.strip()
+            if line and (
+                line.startswith("-") or line.startswith("•") or line.startswith("*")
+            ):
+                recommendations.append(line[1:].strip())
+            elif line and line[0].isdigit() and "." in line:
+                recommendations.append(line.split(".", 1)[1].strip())
+        return (
+            recommendations[:7]
+            if recommendations
+            else ["Prepare emergency supplies", "Review evacuation plans"]
+        )
+
+
+class HouseholdAdaptationAgent:
+    """Agent for household-level climate adaptation recommendations."""
+
+    def __init__(self, model):
+        self.agent = CodeAgent(
+            tools=[], model=model, additional_authorized_imports=["json"]
+        )
+
+    def generate_household_recommendations(
+        self, risk_analysis: dict, user_profile: dict
+    ) -> List[str]:
+        """Generate household adaptation recommendations."""
+
+        prompt = f"""
+You are a household climate adaptation specialist. Based on the risk analysis and user profile, generate 3-8 specific recommendations for household-level climate adaptations.
+
+Risk Analysis: {str(risk_analysis)}
+User Profile: {str(user_profile)}
+
+Your recommendations should address:
+- Home modifications for identified risks
+- Energy efficiency improvements
+- Comfort and health considerations
+- Cost-effective solutions
+- Long-term resilience building
+
+Focus on practical, implementable actions that enhance the household's resilience to the identified climate risks.
+
+IMPORTANT: Return a simple Python list of strings.
+
+Do not return JSON - just a Python list.
+"""
+
+        try:
+            try:
+                response = self.agent.run(prompt)
+            except Exception as e:
+                print(e)
+            #response = self.agent.run(prompt)
+            #response = litellm.completion(messages=prompt, model="anthropic/claude-sonnet-4-20250514")
+
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, str):
+                try:
+                    return ast.literal_eval(response)
+                except (ValueError, SyntaxError):
+                    try:
+                        return json.loads(response)
+                    except json.JSONDecodeError:
+                        return self._extract_recommendations_from_text(response)
+            else:
+                return [
+                    "Improve home insulation",
+                    "Install efficient heating/cooling",
+                    "Weather-proof windows and doors",
+                ]
+
+        except Exception as e:
+            print(f"Household recommendations error: {e}")
+            return [
+                "Improve home insulation to reduce energy costs",
+                "Install programmable thermostat",
+                "Weather-strip doors and windows",
+                "Consider backup power options",
+            ]
+
+    def _extract_recommendations_from_text(self, text: str) -> List[str]:
+        """Extract recommendations from text response."""
+        lines = text.split("\n")
+        recommendations = []
+        for line in lines:
+            line = line.strip()
+            if line and (
+                line.startswith("-") or line.startswith("•") or line.startswith("*")
+            ):
+                recommendations.append(line[1:].strip())
+            elif line and line[0].isdigit() and "." in line:
+                recommendations.append(line.split(".", 1)[1].strip())
+        return (
+            recommendations[:8]
+            if recommendations
+            else ["Improve home insulation", "Install efficient heating/cooling"]
+        )
+
+
+class BusinessContinuityAgent:
+    """Agent for business continuity and adaptation recommendations."""
+
+    def __init__(self, model):
+        self.agent = CodeAgent(
+            tools=[], model=model, additional_authorized_imports=["json"]
+        )
+
+    def generate_business_recommendations(
+        self, risk_analysis: dict, user_profile: dict
+    ) -> List[str]:
+        """Generate business continuity recommendations."""
+
+        prompt = f"""
+You are a business continuity and climate adaptation consultant. Generate 4-10 specific recommendations for business resilience based on the risk analysis and user profile.
+
+Risk Analysis: {str(risk_analysis)}
+User Profile: {str(user_profile)}
+
+Consider:
+- Operational continuity during climate events
+- Supply chain resilience
+- Infrastructure protection
+- Employee safety
+- Financial risk management
+- Market opportunities in climate adaptation
+
+Provide actionable, business-focused recommendations that address the specific risks identified.
+
+IMPORTANT: Return a simple Python list of strings.
+
+Do not return JSON - just a Python list.
+"""
+
+        try:
+            try:
+                response = self.agent.run(prompt)
+            except Exception as e:
+                print(e)            
+            #response = self.agent.run(prompt)
+            #response = litellm.completion(messages=prompt, model="anthropic/claude-sonnet-4-20250514")
+
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, str):
+                try:
+                    return ast.literal_eval(response)
+                except (ValueError, SyntaxError):
+                    try:
+                        return json.loads(response)
+                    except json.JSONDecodeError:
+                        return self._extract_recommendations_from_text(response)
+            else:
+                return [
+                    "Develop business continuity plan",
+                    "Review insurance coverage",
+                    "Diversify supply chains",
+                ]
+
+        except Exception as e:
+            print(f"Business recommendations error: {e}")
+            return [
+                "Develop comprehensive business continuity plan",
+                "Review and update insurance coverage",
+                "Diversify supply chain sources",
+                "Create employee safety protocols",
+            ]
+
+    def _extract_recommendations_from_text(self, text: str) -> List[str]:
+        """Extract recommendations from text response."""
+        lines = text.split("\n")
+        recommendations = []
+        for line in lines:
+            line = line.strip()
+            if line and (
+                line.startswith("-") or line.startswith("•") or line.startswith("*")
+            ):
+                recommendations.append(line[1:].strip())
+            elif line and line[0].isdigit() and "." in line:
+                recommendations.append(line.split(".", 1)[1].strip())
+        return (
+            recommendations[:10]
+            if recommendations
+            else ["Develop business continuity plan", "Review insurance coverage"]
+        )
+
+
+class FinancialAdaptationAgent:
+    """Agent focused on financial planning and climate risk economics."""
+
+    def __init__(self, model):
+        self.agent = CodeAgent(
+            tools=[], model=model, additional_authorized_imports=["json"]
+        )
+
+    def generate_financial_recommendations(
+        self, risk_analysis: dict, user_profile: dict
+    ) -> List[str]:
+        """Generate financial planning recommendations for climate risks."""
+
+        prompt = f"""
+You are a financial advisor specializing in climate risk management. Generate 4-7 specific financial recommendations based on the risk analysis.
+
+Risk Analysis: {str(risk_analysis)}
+User Profile: {str(user_profile)}
+
+Address:
+- Insurance coverage optimization
+- Emergency fund planning
+- Climate-resilient investments
+- Government incentives and rebates
+- Tax implications of adaptations
+- Long-term financial planning for climate change
+- Risk transfer mechanisms
+
+Provide actionable financial strategies that help manage the economic impacts of identified climate risks.
+
+IMPORTANT: Return a simple Python list of strings.
+
+Do not return JSON - just a Python list.
+"""
+
+        try:
+            try:
+                response = self.agent.run(prompt)
+            except Exception as e:
+                print(e)            
+            #response = self.agent.run(prompt)
+            #response = litellm.completion(messages=prompt, model="anthropic/claude-sonnet-4-20250514")
+
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, str):
+                try:
+                    return ast.literal_eval(response)
+                except (ValueError, SyntaxError):
+                    try:
+                        return json.loads(response)
+                    except json.JSONDecodeError:
+                        return self._extract_recommendations_from_text(response)
+            else:
+                return [
+                    "Review insurance coverage",
+                    "Build emergency fund",
+                    "Explore tax incentives",
+                ]
+
+        except Exception as e:
+            print(f"Financial recommendations error: {e}")
+            return [
+                "Review and update insurance coverage for climate risks",
+                "Build emergency fund covering 3-6 months expenses",
+                "Explore government incentives for climate adaptations",
+                "Consider climate-resilient investment options",
+            ]
+
+    def _extract_recommendations_from_text(self, text: str) -> List[str]:
+        """Extract recommendations from text response."""
+        lines = text.split("\n")
+        recommendations = []
+        for line in lines:
+            line = line.strip()
+            if line and (
+                line.startswith("-") or line.startswith("•") or line.startswith("*")
+            ):
+                recommendations.append(line[1:].strip())
+            elif line and line[0].isdigit() and "." in line:
+                recommendations.append(line.split(".", 1)[1].strip())
+        return (
+            recommendations[:7]
+            if recommendations
+            else ["Review insurance coverage", "Build emergency fund"]
+        )

requirements.txt

@@ -0,0 +1,15 @@
+smolagents
+smolagents[litellm,gradio,mcp]
+gradio
+requests>=2.28.0
+litellm>=1.0.0
+python-dateutil>=2.8.0
+pandas>=1.5.0
+plotly>=5.0.0
+folium>=0.14.0
+urllib3>=1.26.0
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+fpdf>=1.7.2

risk_agent.py

@@ -0,0 +1,171 @@
+import json
+import litellm
+from smolagents import CodeAgent
+from tools.tools import (
+    get_coordinates,
+    get_earthquake_data,
+    get_nasa_fire_data,
+    get_full_daily_forecast,
+    climate_change_data,
+    get_full_air_quality_forecast,
+    get_full_marine_daily_forecast,
+    get_full_flood_daily_forecast,
+    get_full_satellite_radiation,
+)
+
+class RiskAnalysisAgent:
+    """Agent responsible for analyzing risks based on user input and available data."""
+
+    def __init__(self, model):
+        self.agent = CodeAgent(
+            tools=[
+                get_coordinates,
+                get_earthquake_data,
+                get_nasa_fire_data,
+                get_full_daily_forecast,
+                climate_change_data,
+                get_full_air_quality_forecast,
+                get_full_marine_daily_forecast,
+                get_full_flood_daily_forecast,
+                get_full_satellite_radiation,
+            ],
+            model=model,
+            additional_authorized_imports=["json", "datetime", "math"],
+        )
+
+    def analyze_risks(self, user_query: str) -> dict:
+        """Analyze risks based on user query."""
+
+        analysis_prompt = f"""
+You are an expert climate risk analyst. A user has submitted this query: "{user_query}"
+
+Your task:
+1. Extract the location from the query
+2. Identify what types of risks they're asking about
+3. Gather relevant data using the available tools:
+   - Use get_full_daily_forecast for detailed weather data
+   - Use climate_change_data for long-term climate projections
+   - Use get_full_air_quality_forecast for air quality risks
+   - Use get_full_marine_daily_forecast for coastal/marine risks
+   - Use get_full_flood_daily_forecast for detailed flood data
+   - Use get_full_satellite_radiation for solar radiation data
+4. Analyze the risk levels for each identified hazard
+5. Return a comprehensive risk analysis
+
+For each risk type you identify, provide:
+- Risk level (0-100 scale)
+- Key factors contributing to the risk
+- Time horizon (immediate, short-term, long-term)
+- Confidence level in your assessment
+- Historical context (when available)
+- Future projections (when available)
+
+Focus on being thorough but concise. Use your judgment to determine which data sources are most relevant.
+
+IMPORTANT: Return a valid Python dictionary (not JSON string) in this exact format:
+{{
+    "location": {{"city": "CityName", "country": "CountryName", "lat": 0.0, "lon": 0.0}},
+    "identified_risks": ["risk1", "risk2"],
+    "risk_analysis": {{
+        "earthquake": {{
+            "risk_level": 25,
+            "contributing_factors": ["seismic activity", "building codes"],
+            "time_horizon": "long-term",
+            "Detailed analysis": "",
+            "confidence": "medium",
+            "key_insights": "Moderate earthquake risk due to regional seismic activity",
+            "historical_context": "Historical earthquake data analysis",
+            "future_projections": "Projected seismic activity trends"
+        }},
+        "wildfire": {{
+            "risk_level": 60,
+            "contributing_factors": ["dry conditions", "vegetation"],
+            "time_horizon": "immediate",
+            "Detailed analysis": "",
+            "confidence": "high",
+            "key_insights": "High wildfire risk during dry season",
+            "historical_context": "Past wildfire patterns",
+            "future_projections": "Climate change impact on fire risk"
+        }},
+        "climate": {{
+            "risk_level": 45,
+            "contributing_factors": ["temperature trends", "precipitation changes"],
+            "time_horizon": "long-term",
+            "confidence": "high",
+            "Detailed analysis": "",
+            "key_insights": "Significant climate change impacts expected",
+            "future_projections": "Climate model predictions"
+        }}
+    }},
+    "overall_assessment": "Very detailed overall risk summary here"
+}}
+"""
+
+        try:
+
+            try:
+                response = self.agent.run(analysis_prompt)
+            except Exception as e:
+               print(e)
+
+            #response = litellm.completion(messages=analysis_prompt, model="anthropic/claude-sonnet-4-20250514")
+
+            if isinstance(response, dict):
+                return response
+            elif isinstance(response, str):
+                try:
+                    return json.loads(response)
+                except json.JSONDecodeError:
+                    return {
+                        "location": {
+                            "city": "Unknown",
+                            "country": "Unknown",
+                            "lat": 0.0,
+                            "lon": 0.0,
+                        },
+                        "identified_risks": ["general climate risks"],
+                        "risk_analysis": {
+                            "general": {
+                                "risk_level": 30,
+                                "contributing_factors": ["climate change"],
+                                "time_horizon": "long-term",
+                                "confidence": "medium",
+                                "key_insights": f"Analysis of query: {user_query}",
+                            }
+                        },
+                        "overall_assessment": f"Climate risk analysis for: {user_query}",
+                    }
+            else:
+                return {
+                    "location": {
+                        "city": "Unknown",
+                        "country": "Unknown",
+                        "lat": 0.0,
+                        "lon": 0.0,
+                    },
+                    "identified_risks": ["climate risks"],
+                    "risk_analysis": {
+                        "general": {
+                            "risk_level": 30,
+                            "contributing_factors": ["climate factors"],
+                            "time_horizon": "medium-term",
+                            "confidence": "medium",
+                            "key_insights": "General climate risk assessment",
+                        }
+                    },
+                    "overall_assessment": "Basic climate risk analysis completed",
+                }
+        except Exception as e:
+            print(f"Risk analysis error: {e}")
+            return {
+                "error": f"Risk analysis failed: {str(e)}",
+                "location": {
+                    "city": "Unknown",
+                    "country": "Unknown",
+                    "lat": 0.0,
+                    "lon": 0.0,
+                },
+                "identified_risks": [],
+                "risk_analysis": {},
+                "overall_assessment": "Analysis could not be completed",
+            }

tools.py

@@ -0,0 +1,721 @@
+import math
+import requests
+import matplotlib.pyplot as plt
+import seaborn as sns
+import tempfile
+import os
+from config import NASA_FIRMS_MAP_KEY
+from datetime import datetime, timedelta
+from smolagents import tool
+from fpdf import FPDF
+
+
+@tool
+def get_coordinates(city: str) -> dict:
+    """Get latitude and longitude of a city using OpenStreetMap Nominatim API.
+
+    Args:
+        city: Name of the city to get coordinates for
+
+    Returns:
+        Dict with city name, latitude, longitude, or error message
+    """
+    url = "https://nominatim.openstreetmap.org/search"
+    params = {"q": city, "format": "json", "limit": 1}
+    headers = {"User-Agent": "ClimateRiskTool/1.0"}
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        data = response.json()
+        if not data:
+            return {"error": f"City '{city}' not found"}
+        return {
+            "city": city,
+            "latitude": float(data[0]["lat"]),
+            "longitude": float(data[0]["lon"]),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_weather_forecast(lat: float, lon: float) -> dict:
+    """Get weather forecast data for risk analysis.
+
+    Args:
+        lat: Latitude coordinate
+        lon: Longitude coordinate
+
+    Returns:
+        Dict with weather forecast data or error message
+    """
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "daily": [
+            "temperature_2m_max",
+            "temperature_2m_min",
+            "precipitation_sum",
+            "wind_speed_10m_max",
+            "wind_gusts_10m_max",
+            "relative_humidity_2m_min",
+        ],
+        "forecast_days": 7,
+        "timezone": "auto",
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_flood_data(lat: float, lon: float) -> dict:
+    """Get flood forecast data.
+
+    Args:
+        lat: Latitude coordinate
+        lon: Longitude coordinate
+
+    Returns:
+        Dict with flood forecast data or error message
+    """
+    url = "https://flood-api.open-meteo.com/v1/flood"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "daily": ["river_discharge", "river_discharge_mean", "river_discharge_max"],
+        "forecast_days": 7,
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_earthquake_data(
+    lat: float, lon: float, radius_km: float = 100, days: int = 30
+) -> dict:
+    """Get raw earthquake data from USGS.
+
+    Args:
+        lat: Latitude coordinate
+        lon: Longitude coordinate
+        radius_km: Search radius in kilometers (default 100km)
+        days: Number of days to look back (default 30 days)
+
+    Returns:
+        Dict with raw earthquake data from USGS
+    """
+    url = "https://earthquake.usgs.gov/fdsnws/event/1/query"
+
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=days)
+
+    params = {
+        "format": "geojson",
+        "starttime": start_date.strftime("%Y-%m-%d"),
+        "endtime": end_date.strftime("%Y-%m-%d"),
+        "latitude": lat,
+        "longitude": lon,
+        "maxradiuskm": radius_km,
+        "minmagnitude": 1.0,
+        "orderby": "time-desc",
+    }
+
+    try:
+        response = requests.get(url, params=params, timeout=15)
+        response.raise_for_status()
+        data = response.json()
+
+        earthquakes = []
+        for feature in data.get("features", []):
+            props = feature["properties"]
+            coords = feature["geometry"]["coordinates"]
+
+            earthquakes.append(
+                {
+                    "magnitude": props.get("mag"),
+                    "place": props.get("place"),
+                    "time": props.get("time"),
+                    "depth": coords[2] if len(coords) > 2 else None,
+                    "latitude": coords[1],
+                    "longitude": coords[0],
+                    "alert": props.get("alert"),
+                    "significance": props.get("sig"),
+                    "event_type": props.get("type"),
+                    "title": props.get("title"),
+                }
+            )
+
+        return {
+            "earthquakes": earthquakes,
+            "query_location": {
+                "lat": lat,
+                "lon": lon,
+                "radius_km": radius_km,
+                "days": days,
+            },
+            "data_source": "USGS",
+        }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_nasa_fire_data(
+    lat: float, lon: float, radius_km: float = 50, days: int = 2
+) -> dict:
+    """Get raw wildfire detection data from NASA FIRMS satellites.
+
+    Args:
+        lat: Latitude coordinate
+        lon: Longitude coordinate
+        radius_km: Search radius in kilometers (default 50km)
+        days: Number of days to look back (default 2 days)
+
+    Returns:
+        Dict with raw fire detection data from NASA satellites
+    """
+    if not NASA_FIRMS_MAP_KEY or NASA_FIRMS_MAP_KEY == "your-nasa-firms-api-key-here":
+        return {"error": "NASA FIRMS API key not configured in .env file"}
+
+    try:
+        lat_offset = radius_km / 111.0
+        lon_offset = radius_km / (111.0 * abs(math.cos(math.radians(lat))))
+        bbox = f"{lat - lat_offset},{lon - lon_offset},{lat + lat_offset},{lon + lon_offset}"
+
+        modis_url = f"https://firms.modaps.eosdis.nasa.gov/api/area/csv/{NASA_FIRMS_MAP_KEY}/MODIS_NRT/{bbox}/{days}"
+        viirs_url = f"https://firms.modaps.eosdis.nasa.gov/api/area/csv/{NASA_FIRMS_MAP_KEY}/VIIRS_NOAA20_NRT/{bbox}/{days}"
+
+        all_fires = []
+
+        try:
+            modis_response = requests.get(modis_url, timeout=15)
+            if modis_response.status_code == 200 and modis_response.text.strip():
+                all_fires.extend(_parse_nasa_csv(modis_response.text, "MODIS"))
+        except:
+            pass
+
+        try:
+            viirs_response = requests.get(viirs_url, timeout=15)
+            if viirs_response.status_code == 200 and viirs_response.text.strip():
+                all_fires.extend(_parse_nasa_csv(viirs_response.text, "VIIRS"))
+        except:
+            pass
+
+        return {
+            "fires": all_fires,
+            "query_location": {
+                "lat": lat,
+                "lon": lon,
+                "radius_km": radius_km,
+                "days": days,
+            },
+            "data_source": "NASA_FIRMS",
+        }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _parse_nasa_csv(csv_text: str, source: str) -> list:
+    """Parse NASA FIRMS CSV data.
+
+    Args:
+        csv_text: CSV text data from NASA FIRMS API
+        source: Source identifier (MODIS or VIIRS)
+
+    Returns:
+        List of fire detection dictionaries
+    """
+    fires = []
+    lines = csv_text.strip().split("\n")
+
+    if len(lines) < 2:
+        return fires
+
+    for line in lines[1:]:
+        try:
+            values = line.split(",")
+            if len(values) >= 9:
+                fires.append(
+                    {
+                        "latitude": float(values[0]),
+                        "longitude": float(values[1]),
+                        "brightness": float(values[2]) if values[2] else 0,
+                        "scan": float(values[3]) if values[3] else 0,
+                        "track": float(values[4]) if values[4] else 0,
+                        "acq_date": values[5],
+                        "acq_time": values[6],
+                        "satellite": values[7],
+                        "confidence": int(values[8]) if values[8].isdigit() else 50,
+                        "version": values[9] if len(values) > 9 else "",
+                        "bright_t31": (
+                            float(values[10]) if len(values) > 10 and values[10] else 0
+                        ),
+                        "frp": (
+                            float(values[11]) if len(values) > 11 and values[11] else 0
+                        ),
+                        "daynight": values[12] if len(values) > 12 else "",
+                        "source": source,
+                    }
+                )
+        except (ValueError, IndexError):
+            continue
+
+    return fires
+
+
+@tool
+def find_local_emergency_resources(lat: float, lon: float) -> dict:
+    """Find local emergency resources and contacts.
+
+    Args:
+        lat: Latitude coordinate
+        lon: Longitude coordinate
+
+    Returns:
+        Dict with local emergency resources or error message
+    """
+    try:
+        query = f"""
+        [out:json][timeout:15];
+        (
+          node[amenity=hospital](around:10000,{lat},{lon});
+          node[amenity=fire_station](around:10000,{lat},{lon});
+          node[amenity=police](around:10000,{lat},{lon});
+        );
+        out center meta;
+        """
+
+        response = requests.post(
+            "https://overpass-api.de/api/interpreter", data=query, timeout=20
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            resources = []
+
+            for element in data.get("elements", [])[:5]:
+                tags = element.get("tags", {})
+                resources.append(
+                    {
+                        "name": tags.get("name", "Unnamed facility"),
+                        "type": tags.get("amenity", "unknown"),
+                        "latitude": element.get("lat", lat),
+                        "longitude": element.get("lon", lon),
+                    }
+                )
+
+            return {"local_resources": resources}
+
+        return {"local_resources": []}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def generate_analysis_report(
+    data: dict, filename: str = "climate_risk_report.pdf"
+) -> dict:
+    """Generate a consolidated analysis report with visualizations.
+
+    Args:
+        data: Consolidated data from various tools, expected to include:
+              - weather forecast
+              - flood data
+              - earthquake data
+              - fire data
+        filename: Desired filename for the exported PDF report
+
+    Returns:
+        Dict with success message and file path or error
+    """
+    try:
+        # Temporary directory for plots
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Initialize the PDF
+            pdf = FPDF()
+            pdf.set_auto_page_break(auto=True, margin=15)
+            pdf.add_page()
+            pdf.set_font("Arial", size=12)
+            pdf.set_text_color(50, 50, 50)
+
+            # Add Title
+            pdf.set_font("Arial", style="B", size=16)
+            pdf.cell(0, 10, "Climate Risk Analysis Report", ln=True, align="C")
+            pdf.ln(10)  # Line break
+
+            # Helper function to save and plot visualizations
+            def save_plot(fig, plot_name):
+                path = f"{temp_dir}/{plot_name}.png"
+                fig.savefig(path)
+                plt.close(fig)
+                return path
+
+            # Plot weather data
+            weather_data = data.get("weather_forecast", {}).get("daily", {})
+            if weather_data:
+                dates = [
+                    d for d in range(1, len(weather_data["temperature_2m_max"]) + 1)
+                ]
+                weather_df = {
+                    "Day": dates,
+                    "Max Temperature (°C)": weather_data["temperature_2m_max"],
+                    "Min Temperature (°C)": weather_data["temperature_2m_min"],
+                    "Precipitation (mm)": weather_data["precipitation_sum"],
+                }
+
+                fig, ax = plt.subplots(figsize=(8, 5))
+                sns.lineplot(
+                    x="Day",
+                    y="Max Temperature (°C)",
+                    data=weather_df,
+                    ax=ax,
+                    label="Max Temp",
+                    color="red",
+                )
+                sns.lineplot(
+                    x="Day",
+                    y="Min Temperature (°C)",
+                    data=weather_df,
+                    ax=ax,
+                    label="Min Temp",
+                    color="blue",
+                )
+                sns.barplot(
+                    x="Day",
+                    y="Precipitation (mm)",
+                    data=weather_df,
+                    ax=ax,
+                    color="gray",
+                    alpha=0.5,
+                )
+                ax.set_title("Weather Forecast")
+                ax.set_xlabel("Day")
+                ax.set_ylabel("Values")
+                ax.legend()
+
+                weather_plot_path = save_plot(fig, "weather_plot")
+                pdf.image(weather_plot_path, x=10, y=None, w=180)
+                pdf.ln(10)
+
+            # Plot earthquake data
+            earthquake_data = data.get("earthquake_data", {}).get("earthquakes", [])
+            if earthquake_data:
+                magnitudes = [
+                    eq["magnitude"] for eq in earthquake_data if eq.get("magnitude")
+                ]
+                depths = [eq["depth"] for eq in earthquake_data if eq.get("depth")]
+                places = [eq["place"] for eq in earthquake_data]
+
+                fig, ax = plt.subplots(figsize=(8, 5))
+                sns.scatterplot(
+                    x=depths, y=magnitudes, hue=places, ax=ax, palette="tab10", s=100
+                )
+                ax.set_title("Earthquake Analysis")
+                ax.set_xlabel("Depth (km)")
+                ax.set_ylabel("Magnitude")
+                ax.legend(bbox_to_anchor=(1.05, 1), loc="upper left")
+
+                earthquake_plot_path = save_plot(fig, "earthquake_plot")
+                pdf.image(earthquake_plot_path, x=10, y=None, w=180)
+                pdf.ln(10)
+
+            # Plot fire data
+            fire_data = data.get("fire_data", {}).get("fires", [])
+            if fire_data:
+                brightness = [fire["brightness"] for fire in fire_data]
+                confidence = [fire["confidence"] for fire in fire_data]
+
+                fig, ax = plt.subplots(figsize=(8, 5))
+                sns.histplot(
+                    brightness,
+                    bins=20,
+                    ax=ax,
+                    kde=True,
+                    color="orange",
+                    label="Brightness",
+                )
+                sns.histplot(
+                    confidence,
+                    bins=20,
+                    ax=ax,
+                    kde=True,
+                    color="green",
+                    alpha=0.5,
+                    label="Confidence",
+                )
+                ax.set_title("Wildfire Brightness vs Confidence")
+                ax.set_xlabel("Value")
+                ax.legend()
+
+                fire_plot_path = save_plot(fig, "fire_plot")
+                pdf.image(fire_plot_path, x=10, y=None, w=180)
+                pdf.ln(10)
+
+            # Save PDF report
+            pdf_output_path = os.path.join(temp_dir, filename)
+            pdf.output(pdf_output_path)
+            return {"success": True, "file_path": pdf_output_path}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_full_daily_forecast(lat: float, lon: float) -> dict:
+    """
+    Get all available daily weather forecast parameters from Open-Meteo API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+    Returns:
+        Dict with all daily forecast data or error.
+    """
+    daily_params = [
+        "temperature_2m_max", "temperature_2m_mean", "temperature_2m_min",
+        "apparent_temperature_max", "apparent_temperature_mean", "apparent_temperature_min",
+        "precipitation_sum", "rain_sum", "showers_sum", "snowfall_sum",
+        "precipitation_hours",
+        "precipitation_probability_max", "precipitation_probability_mean", "precipitation_probability_min",
+        "weather_code", "sunrise", "sunset",
+        "sunshine_duration", "daylight_duration",
+        "wind_speed_10m_max", "wind_gusts_10m_max", "wind_direction_10m_dominant",
+        "shortwave_radiation_sum", "et0_fao_evapotranspiration",
+        "uv_index_max", "uv_index_clear_sky_max"
+    ]
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "timezone": "auto",
+        "daily": ",".join(daily_params)
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def climate_change_data(
+    lat: float,
+    lon: float,
+    start_date: str = "1950-01-01",
+    end_date: str = "2050-12-31",
+    models: list[str] = None
+) -> dict:
+    """
+    Get all available daily climate parameters from Open-Meteo Climate API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+        start_date: Start date in yyyy-mm-dd (default 1950-01-01).
+        end_date: End date in yyyy-mm-dd (default 2050-12-31).
+        models: Optional list of climate models (default: all models).
+    Returns:
+        Dict with all daily climate data or error.
+    """
+    daily_params = [
+        "temperature_2m_max", "temperature_2m_min", "temperature_2m_mean",
+        "cloud_cover_mean",
+        "relative_humidity_2m_max", "relative_humidity_2m_min", "relative_humidity_2m_mean",
+        "soil_moisture_0_to_10cm_mean",
+        "precipitation_sum", "rain_sum", "snowfall_sum",
+        "wind_speed_10m_mean", "wind_speed_10m_max",
+        "pressure_msl_mean",
+        "shortwave_radiation_sum"
+    ]
+    if models is None:
+        models = [
+            "CMCC_CM2_VHR4", "FGOALS_f3_H", "HiRAM_SIT_HR",
+            "MRI_AGCM3_2_S", "EC_Earth3P_HR", "MPI_ESM1_2_XR", "NICAM16_8S"
+        ]
+    url = "https://climate-api.open-meteo.com/v1/climate"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "start_date": start_date,
+        "end_date": end_date,
+        "models": ",".join(models),
+        "daily": ",".join(daily_params),
+        "timezone": "auto"
+    }
+    try:
+        response = requests.get(url, params=params, timeout=60)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_full_air_quality_forecast(
+    lat: float,
+    lon: float,
+    forecast_days: int = 5,
+    past_days: int = 0,
+    domain: str = "auto"
+) -> dict:
+    """
+    Get all available hourly air quality forecast parameters from Open-Meteo Air Quality API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+        forecast_days: Number of forecast days (default 5, max 7).
+        past_days: Number of past days (default 0, max 92).
+        domain: 'auto', 'cams_europe', or 'cams_global'.
+    Returns:
+        Dict with all hourly air quality data or error.
+    """
+    hourly_params = [
+        "pm10", "pm2_5", "carbon_monoxide", "carbon_dioxide",
+        "nitrogen_dioxide", "sulphur_dioxide", "ozone", "aerosol_optical_depth",
+        "dust", "uv_index", "uv_index_clear_sky", "ammonia", "methane",
+        "alder_pollen", "birch_pollen", "grass_pollen", "mugwort_pollen",
+        "olive_pollen", "ragweed_pollen", "european_aqi", "us_aqi"
+    ]
+
+    url = "https://air-quality-api.open-meteo.com/v1/air-quality"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "forecast_days": min(max(forecast_days, 0), 7),
+        "past_days": min(max(past_days, 0), 92),
+        "hourly": ",".join(hourly_params),
+        "domains": domain,
+        "timezone": "auto",
+    }
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_full_marine_daily_forecast(lat: float, lon: float) -> dict:
+    """
+    Get all available daily marine forecast parameters from Open-Meteo Marine API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+    Returns:
+        Dict with all daily marine forecast data or error.
+    """
+    daily_params = [
+        "wave_height_max", "wind_wave_height_max", "swell_wave_height_max",
+        "wave_direction_dominant", "wind_wave_direction_dominant", "swell_wave_direction_dominant",
+        "wave_period_max", "wind_wave_period_max", "swell_wave_period_max",
+        "wind_wave_peak_period_max", "swell_wave_peak_period_max"
+    ]
+    url = "https://marine-api.open-meteo.com/v1/marine"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "timezone": "auto",
+        "daily": ",".join(daily_params)
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def get_full_flood_daily_forecast(lat: float, lon: float) -> dict:
+    """
+    Get all available daily flood parameters from Open-Meteo Flood API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+    Returns:
+        Dict with all daily flood forecast data or error.
+    """
+    daily_params = [
+        "river_discharge",
+        "river_discharge_mean",
+        "river_discharge_median",
+        "river_discharge_max",
+        "river_discharge_min",
+        "river_discharge_p25",
+        "river_discharge_p75"
+    ]
+    url = "https://flood-api.open-meteo.com/v1/flood"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "daily": ",".join(daily_params)
+    }
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+@tool
+def get_full_satellite_radiation(
+    lat: float,
+    lon: float,
+    start_date: str = None,
+    end_date: str = None,
+    hourly_native: bool = False,
+    tilt: int = 0,
+    azimuth: int = 0
+) -> dict:
+    """
+    Get all available hourly satellite solar radiation parameters from Open-Meteo Satellite API.
+    Args:
+        lat: Latitude.
+        lon: Longitude.
+        start_date: (optional) Start date (yyyy-mm-dd). If None, today.
+        end_date: (optional) End date (yyyy-mm-dd). If None, today.
+        hourly_native: Use native satellite temporal resolution (10/15/30min) if True, else hourly.
+        tilt: Tilt for GTI (default 0 = horizontal).
+        azimuth: Azimuth for GTI (default 0 = south).
+    Returns:
+        Dict with all hourly satellite solar radiation data or error.
+    """
+    hourly_params = [
+        "shortwave_radiation", "diffuse_radiation", "direct_radiation",
+        "direct_normal_irradiance", "global_tilted_irradiance",
+        "terrestrial_radiation",
+        "shortwave_radiation_instant", "diffuse_radiation_instant", "direct_radiation_instant",
+        "direct_normal_irradiance_instant", "global_tilted_irradiance_instant",
+        "terrestrial_radiation_instant"
+    ]
+    url = "https://satellite-api.open-meteo.com/v1/archive"
+
+    today = datetime.utcnow().date()
+    if start_date is None:
+        start_date = str(today)
+    if end_date is None:
+        end_date = str(today)
+
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "start_date": start_date,
+        "end_date": end_date,
+        "hourly": ",".join(hourly_params),
+        "models": "satellite_radiation_seamless",
+        "timezone": "auto",
+        "tilt": tilt,
+        "azimuth": azimuth,
+    }
+    if hourly_native:
+        params["hourly_native"] = "true"
+
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}

ui.py

@@ -0,0 +1,655 @@
+import gradio as gr
+from datetime import datetime
+import sys
+import threading
+from agents.orchestrator import ClimateRiskOrchestrator
+from tools.mapping_utils import (
+    COUNTRIES_AND_CITIES,
+    US_STATES,
+    get_coordinates_from_dropdown,
+    create_risk_map,
+    get_city_suggestions,
+)
+
+# === LogCatcher  ===
+class LogCatcher:
+    def __init__(self):
+        self.buffer = ""
+        self.lock = threading.Lock()
+        self._stdout = sys.stdout
+        self._stderr = sys.stderr
+
+    def write(self, msg):
+        with self.lock:
+            self.buffer += msg
+            self._stdout.write(msg)
+
+    def flush(self):
+        pass
+
+    def get_logs(self):
+        with self.lock:
+            return self.buffer
+
+    def clear(self):
+        with self.lock:
+            self.buffer = ""
+
+    def redirect(self):
+        sys.stdout = self
+        sys.stderr = self
+
+    def restore(self):
+        sys.stdout = self._stdout
+        sys.stderr = self._stderr
+
+    def isatty(self):
+        return False
+
+    def fileno(self):
+        return self._stdout.fileno()
+
+logcatcher = LogCatcher()
+logcatcher.redirect()
+
+class ClimateRiskUI:
+    """User interface for the climate risk system with dropdown and map functionality."""
+
+    def __init__(self, model):
+        self.orchestrator = ClimateRiskOrchestrator(model)
+        self.theme = gr.themes.Soft(
+            primary_hue="blue", secondary_hue="gray", neutral_hue="slate"
+        )
+
+    def update_business_visibility(self, profile_type):
+        show_business = profile_type == "Business Owner"
+        return gr.Dropdown(visible=show_business)
+
+    def analyze_with_dropdown(
+        self,
+        country,
+        city,
+        state,
+        profile_type,
+        business_type,
+        vulnerable_groups,
+    ):
+        logcatcher.clear()
+        
+        if not country or not city:
+            return (
+                "Please select both country and city.",
+                "",
+                "",
+            )
+
+        coords_result, validation_message = get_coordinates_from_dropdown(country, city, state)
+        if coords_result is None:
+            return validation_message, "", ""
+
+        lat, lon = coords_result
+
+        state_info = f", {state}" if state else ""
+        location_full = f"{city}{state_info}, {country}"
+
+        base_query = f"Perform a comprehensive climate risk assessment for {location_full}."
+
+        profile_context = ""
+        if profile_type.lower() == "business owner":
+            business_detail = f" as a {business_type}" if business_type else ""
+            profile_context = (
+                f" Focus on business continuity risks{business_detail}, including supply chain vulnerabilities, operational disruptions, infrastructure threats, customer safety, inventory protection, and revenue continuity. Consider industry-specific vulnerabilities and regulatory compliance requirements."
+            )
+        elif profile_type.lower() == "electric utility":
+            profile_context = " Emphasize electric utility risks including power outages, overloads, low reserve generation capacity, extreme weather impacts on electric utility assets, and catastrophic wildfires potential."
+        elif profile_type.lower() == "emergency manager":
+            profile_context = " Prioritize emergency management perspectives including evacuation planning, critical infrastructure vulnerabilities, community preparedness needs, and multi-hazard scenarios."
+        else:
+            profile_context = " Focus on residential safety, household preparedness, health impacts, and community-level risks."
+
+        vulnerable_context = ""
+        if vulnerable_groups:
+            groups_text = ", ".join(vulnerable_groups)
+            vulnerable_context = f" Pay special attention to impacts on vulnerable populations: {groups_text}."
+
+        analysis_requirements = (
+            " Analyze earthquake, wildfire, flood, and extreme weather risks. Provide specific risk levels (0-100 scale), contributing factors, time horizons, and confidence levels. Include recent data and current conditions."
+        )
+
+        user_query = base_query + profile_context + vulnerable_context + analysis_requirements
+
+        user_profile = {
+            "type": profile_type.lower(),
+            "business_type": business_type if profile_type.lower() == "business owner" else None,
+            "vulnerable_groups": vulnerable_groups or [],
+        }
+
+        print(f"[{datetime.now()}] Analyse : {user_query}")
+        result = self.orchestrator.analyze_and_recommend(user_query, user_profile)
+
+        if "error" in result:
+            print(f"[ERROR] {result['error']}")
+            return f"Error: {result['error']}", "", ""
+
+        risk_summary = self._format_risk_analysis(result["risk_analysis"])
+        recommendations_text = self._format_recommendations(result["recommendations"], profile_type)
+        enhanced_map = create_risk_map(lat, lon, city, country, result["risk_analysis"])
+
+        return risk_summary, recommendations_text, enhanced_map
+
+    def update_map_from_location(self, country, city, state=None):
+        if not country or not city:
+            return "Please select both country and city.", ""
+        coords_result, validation_message = get_coordinates_from_dropdown(country, city, state)
+        if coords_result is None:
+            return validation_message, ""
+        lat, lon = coords_result
+        risk_map = create_risk_map(lat, lon, city, country)
+        return validation_message, risk_map
+
+    def update_cities(self, country):
+        suggestions = get_city_suggestions(country)
+        show_state = country == "United States"
+        country_centers = {
+            "France": (48.8566, 2.3522),
+            "United States": (39.8283, -98.5795),
+            "United Kingdom": (51.5074, -0.1278),
+            "Germany": (52.5200, 13.4050),
+            "Japan": (35.6762, 139.6503),
+            "Canada": (45.4215, -75.7040),
+            "Australia": (-35.2809, 149.1300),
+            "Italy": (41.9028, 12.4964),
+            "Spain": (40.4168, -3.7038),
+            "China": (39.9042, 116.4074),
+            "India": (28.6139, 77.2090),
+            "Brazil": (-15.7975, -47.8919),
+        }
+        lat, lon = country_centers.get(country, (48.8566, 2.3522))
+        basic_map = create_risk_map(lat, lon, f"Select a city in {country}", country)
+        return suggestions, gr.Dropdown(visible=show_state), basic_map
+
+    def analyze_user_input(
+        self,
+        user_query: str,
+        profile_type: str,
+        business_type: str,
+        vulnerable_groups: list = None,
+    ):
+        logcatcher.clear()
+        
+        if not user_query.strip():
+            return (
+                "Please enter your climate risk question or location.",
+                "",
+                "<div style='text-align: center; padding: 50px; background-color: #f0f0f0; border-radius: 10px;'>Map will appear here after analysis.</div>",
+            )
+
+        user_profile = {
+            "type": profile_type.lower(),
+            "business_type": business_type if profile_type.lower() == "business owner" else None,
+            "vulnerable_groups": vulnerable_groups or [],
+        }
+
+        print(f"[{datetime.now()}] Analyse: {user_query}")
+        result = self.orchestrator.analyze_and_recommend(user_query, user_profile)
+
+        if "error" in result:
+            print(f"[ERROR] {result['error']}")
+            return f"Error: {result['error']}", "", ""
+
+        risk_summary = self._format_risk_analysis(result["risk_analysis"])
+        recommendations_text = self._format_recommendations(result["recommendations"], profile_type)
+
+        location = result["risk_analysis"].get("location", {})
+        lat = location.get("lat", 0)
+        lon = location.get("lon", 0)
+        city = location.get("city", "Unknown")
+        country = location.get("country", "Unknown")
+        
+        enhanced_map = create_risk_map(lat, lon, city, country, result["risk_analysis"])
+
+        return risk_summary, recommendations_text, enhanced_map
+
+    def _format_risk_analysis(self, risk_analysis: dict) -> str:
+        if not risk_analysis or "error" in risk_analysis:
+            return "Risk analysis not available or failed."
+
+        formatted = f"# 🌍 Climate Risk Analysis\n\n"
+
+        location = risk_analysis.get("location", {})
+        if location:
+            formatted += f"**Location:** {location.get('city', 'Unknown')}, {location.get('country', '')}\n"
+            formatted += f"**Coordinates:** {location.get('lat', 0):.4f}°N, {location.get('lon', 0):.4f}°E\n\n"
+
+        formatted += f"**Analysis Date:** {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
+
+        overall = risk_analysis.get("overall_assessment", "No overall assessment available.")
+        formatted += f"## 📊 Overall Assessment\n{overall}\n\n"
+
+        risks = risk_analysis.get("risk_analysis", {})
+        if risks:
+            formatted += "## 🎯 Individual Risk Assessment\n\n"
+            for risk_name, risk_data in risks.items():
+                if isinstance(risk_data, dict):
+                    risk_level = risk_data.get("risk_level", 0)
+                    if risk_level > 80:
+                        emoji = "🔴"
+                        level_text = "VERY HIGH"
+                    elif risk_level > 60:
+                        emoji = "🟠"
+                        level_text = "HIGH"
+                    elif risk_level > 40:
+                        emoji = "🟡"
+                        level_text = "MODERATE"
+                    elif risk_level > 20:
+                        emoji = "🟢"
+                        level_text = "LOW"
+                    else:
+                        emoji = "⚪"
+                        level_text = "MINIMAL"
+                    formatted += f"### {emoji} {risk_name.title()} Risk\n"
+                    formatted += f"**Risk Level:** {level_text} ({risk_level}/100)\n"
+                    formatted += f"**Time Horizon:** {risk_data.get('time_horizon', 'Unknown')}\n"
+                    formatted += f"**Confidence:** {risk_data.get('confidence', 'Unknown')}\n\n"
+                    if risk_data.get("key_insights"):
+                        formatted += f"**Analysis:** {risk_data['key_insights']}\n\n"
+                    factors = risk_data.get("contributing_factors", [])
+                    if factors:
+                        formatted += f"**Key Factors:** {', '.join(factors)}\n\n"
+        return formatted
+
+    def _format_recommendations(self, recommendations: dict, profile_type: str) -> str:
+        if not recommendations:
+            return "No recommendations available."
+        formatted = f"# 🎯 Personalized Recommendations for {profile_type} **[survivalist mode]**\n\n"
+        if "emergency" in recommendations:
+            formatted += "## 🚨 Emergency Preparedness\n"
+            for rec in recommendations["emergency"]:
+                formatted += f"- {rec}\n"
+            formatted += "\n"
+        if "household" in recommendations:
+            formatted += "## 🏠 Household Adaptations\n"
+            for rec in recommendations["household"]:
+                formatted += f"- {rec}\n"
+            formatted += "\n"
+        if "business" in recommendations:
+            formatted += "## 🏢 Business Continuity\n"
+            for rec in recommendations["business"]:
+                formatted += f"- {rec}\n"
+            formatted += "\n"
+        if "financial" in recommendations:
+            formatted += "## 💰 Financial Planning\n"
+            for rec in recommendations["financial"]:
+                formatted += f"- {rec}\n"
+            formatted += "\n"
+        formatted += "---\n"
+        formatted += "*Recommendations generated by AI agents based on current risk analysis and your profile.*"
+        return formatted
+
+    def create_interface(self):
+        def get_logs():
+            return logcatcher.get_logs()
+
+        with gr.Blocks(
+            theme=self.theme, title="🛰️ CAVA-AI – Agentic AI based Climate Adaption & Vulnerability Assessment Tool"
+        ) as app:
+
+            gr.Markdown(
+            """
+            # 🛰️ CAVA-AI – Agentic AI based Climate Adaption & Vulnerability Assessment Tool
+            
+            <div style='background: linear-gradient(90deg, #f6f8fa 0%, #e2eafc 100%); border-radius: 10px; padding: 16px 18px; font-size: 16px; margin-bottom: 10px;'>
+            <b>🤖 What does CAVA-AI do?</b>
+            <br><br>
+            CAVA-AI's AI agents instantly analyze climate risks <b>(
+                🌪️ Weather, 
+                🌊 Flood, 
+                🌍 Earthquake, 
+                🔥 Wildfire, 
+                🌫️ Air quality, 
+                📈 Climate trends, 
+                ☀️ Solar radiation,
+                🌊 Marine forecast
+            )</b> for a specified location, providing you with clear, actionable recommendations.
+            <br><br>
+            <i>Analysis is fully automated, always up to date, and based on leading data sources: OpenStreetMap 🗺️, Open-Meteo 🌦️, USGS 🌎, NASA FIRMS 🔥.</i>
+            <br><br>
+            <b>How to use CAVA-AI?</b><br>
+            Use the <b>quick location selection</b> (dropdowns and map) 🌍, or ask complex, personalized questions in <b>natural language</b> 💬.
+            </div>
+            """
+            )
+
+            with gr.Tabs():
+                with gr.TabItem("📍 Quick Location Selection"):
+                    with gr.Row():
+                        with gr.Column():
+                            country_dropdown = gr.Dropdown(
+                                choices=list(COUNTRIES_AND_CITIES.keys()),
+                                label="Select Country",
+                                value="United States",
+                                interactive=True,
+                            )
+                            city_input = gr.Textbox(
+                                label="Enter City Name",
+                                placeholder="e.g., Los Angeles, San Francisco, San Diego, ...",
+                                value="Pomona",
+                                interactive=True,
+                                info="Enter any city name in the selected country",
+                            )
+                            state_dropdown = gr.Dropdown(
+                                choices=US_STATES,
+                                label="Select State (US only)",
+                                value="California",
+                                visible=False,
+                                interactive=True,
+                                info="Select state for US locations",
+                            )
+                            city_suggestions = gr.Markdown(
+                                get_city_suggestions("Los Angeles"), visible=True
+                            )
+
+                        with gr.Column():
+                            profile_dropdown = gr.Dropdown(
+                                choices=[
+                                    "General Public",
+                                    "Business Owner",
+                                    "Electric Utility",
+                                    "Emergency Manager",
+                                ],
+                                label="Your Profile",
+                                value="General Public",
+                            )
+                            vulnerable_groups = gr.CheckboxGroup(
+                                choices=[
+                                    "Elderly",
+                                    "Children",
+                                    "Chronic Health Conditions",
+                                    "Pregnant",
+                                ],
+                                label="Vulnerable Groups in Household",
+                            )
+                            business_type_dropdown = gr.Dropdown(
+                                choices=[
+                                    "Restaurant/Food Service",
+                                    "Retail Store",
+                                    "Manufacturing",
+                                    "Construction",
+                                    "Healthcare Facility",
+                                    "Educational Institution",
+                                    "Technology/Software",
+                                    "Transportation/Logistics",
+                                    "Tourism/Hospitality",
+                                    "Financial Services",
+                                    "Real Estate",
+                                    "Agriculture/Farming",
+                                    "Energy/Utilities",
+                                    "Entertainment/Events",
+                                    "Professional Services",
+                                    "Small Office",
+                                    "Warehouse/Distribution",
+                                    "Other",
+                                ],
+                                label="Business Type",
+                                value="Retail Store",
+                                visible=False,
+                                interactive=True,
+                                info="Select your business type for specialized recommendations",
+                            )
+
+                    with gr.Row():
+                        analyze_location_btn = gr.Button(
+                            "🔍 Analyze This Location", variant="primary", size="lg"
+                        )
+                    
+                    with gr.Row():
+                        gr.HTML("""
+                        <div style="display: flex; align-items: center; gap: 10px;">
+                            <h3 style="margin: 0;">🛰️ Agentic Logs</h3>
+                        </div>
+                        """)
+                        
+                    with gr.Row():
+                        logs_box = gr.Textbox(
+                            value=logcatcher.get_logs(),
+                            label="Logs",
+                            lines=17,
+                            max_lines=25,
+                            interactive=False,
+                            elem_id="terminal_logs",
+                            show_copy_button=True,
+                            container=False,
+                        )
+                        logs_timer = gr.Timer(0.5)
+                        logs_timer.tick(get_logs, None, logs_box)
+
+                    with gr.Row():
+                        location_map = gr.HTML(
+                            create_risk_map(47.7486, -3.3667, "Lorient", "France"),
+                            label="Interactive Risk Map",
+                        )
+
+                    with gr.Row():
+                        location_status = gr.Markdown("", visible=True)
+
+                    # Résumé d'analyse dans un cadre custom (CSS)
+                    with gr.Row():
+                        dropdown_risk_summary = gr.Markdown(
+                            "Select a location above to begin analysis.",
+                            label="Risk Assessment Summary",
+                            elem_id="risk_summary_box",
+                        )
+
+                    # Recommandations dans un cadre custom (CSS)
+                    with gr.Row():
+                        dropdown_recommendations = gr.Markdown(
+                            "Recommendations will appear here after analysis.",
+                            label="AI-Generated Recommendations",
+                            elem_id="recommendations_box",
+                        )
+
+                with gr.TabItem("💬 Natural Language Query"):
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            user_query = gr.Textbox(
+                                label="Your Climate Risk Question",
+                                placeholder="Will Southern California experience more wildfires this summer?",
+                                lines=3,
+                                info="Be as specific as possible about location, timeframe, and what you're concerned about.",
+                            )
+                            gr.Markdown(
+                                """
+                            **Examples:**
+                            - "What are the wildfire risks in Southern California this summer?"
+                            - "I live in San Joaquin Valley, can I expect power outages this week ?"
+                            - "I'm planning to move to Long Beach, what climate risks should I be aware of?"
+                            - "How should I prepare for climate change?"
+                            - "What ermergency preparations should SCE make for possible earthquakes?"
+                            """
+                            )
+
+                        with gr.Column(scale=1):
+                            nl_profile_type = gr.Dropdown(
+                                choices=[
+                                    "General Public",
+                                    "Business Owner",
+                                    "Electric Utility",
+                                    "Emergency Manager",
+                                ],
+                                label="Your Profile",
+                                value="General Public",
+                            )
+
+                            nl_business_type_dropdown = gr.Dropdown(
+                                choices=[
+                                    "Restaurant/Food Service",
+                                    "Retail Store",
+                                    "Manufacturing",
+                                    "Construction",
+                                    "Healthcare Facility",
+                                    "Educational Institution",
+                                    "Technology/Software",
+                                    "Transportation/Logistics",
+                                    "Tourism/Hospitality",
+                                    "Financial Services",
+                                    "Real Estate",
+                                    "Agriculture/Farming",
+                                    "Energy/Utilities",
+                                    "Entertainment/Events",
+                                    "Professional Services",
+                                    "Small Office",
+                                    "Warehouse/Distribution",
+                                    "Other",
+                                ],
+                                label="Business Type",
+                                value="Retail Store",
+                                visible=False,
+                                interactive=True,
+                                info="Select your business type for specialized recommendations",
+                            )
+
+                            nl_vulnerable_groups = gr.CheckboxGroup(
+                                choices=[
+                                    "Elderly",
+                                    "Children",
+                                    "Chronic Health Conditions",
+                                    "Pregnant",
+                                ],
+                                label="Vulnerable Groups in Household",
+                            )
+
+                            analyze_btn = gr.Button(
+                                "🔍 Analyze Query & Get Recommendations",
+                                variant="primary",
+                                size="lg",
+                            )
+
+                    with gr.Row():
+                        gr.HTML("""
+                        <div style="display: flex; align-items: center; gap: 10px;">
+                            <h3 style="margin: 0;">🛰️ Agentic Logs</h3>
+                        </div>
+                        """)
+                        
+                    with gr.Row():
+                        nl_logs_box = gr.Textbox(
+                            value=logcatcher.get_logs(),
+                            label="Logs",
+                            lines=17,
+                            max_lines=25,
+                            interactive=False,
+                            elem_id="nl_terminal_logs",
+                            show_copy_button=True,
+                            container=False,
+                        )
+                        nl_logs_timer = gr.Timer(0.5)
+                        nl_logs_timer.tick(get_logs, None, nl_logs_box)
+
+                    with gr.Row():
+                        nl_location_map = gr.HTML(
+                            "<div style='text-align: center; padding: 50px; background-color: #f0f0f0; border-radius: 10px;'>Map will appear here after analysis.</div>",
+                            label="Interactive Risk Map",
+                        )
+
+                    # Résultats d'analyse en langage naturel dans un cadre custom (CSS)
+                    with gr.Row():
+                        risk_analysis_output = gr.Markdown(
+                            "Enter your question above to get started.",
+                            label="Risk Analysis",
+                            elem_id="nl_risk_box",
+                        )
+
+                    # Recommandations NL dans un cadre custom (CSS)
+                    with gr.Row():
+                        recommendations_output = gr.Markdown(
+                            "Personalized recommendations will appear here.",
+                            label="AI-Generated Recommendations",
+                            elem_id="nl_rec_box",
+                        )
+
+            # CSS pour les cadres custom
+            gr.HTML("""
+            <style>
+            #risk_summary_box, #recommendations_box, #nl_risk_box, #nl_rec_box {
+                border: 2px solid #007aff;
+                border-radius: 13px;
+                background: #fafdff;
+                box-shadow: 0 2px 12px rgba(80,140,255,0.08);
+                padding: 20px 15px;
+                margin-top: 10px;
+                margin-bottom: 18px;
+            }
+            #terminal_logs textarea, #nl_terminal_logs textarea {
+                background-color: #181a1b !important;
+                color: #00ff66 !important;
+                font-family: 'Fira Mono', 'Consolas', monospace !important;
+                font-size: 15px;
+                border-radius: 9px !important;
+                border: 2px solid #31343a !important;
+                box-shadow: 0 2px 6px rgba(0,0,0,0.19);
+                padding: 12px 10px !important;
+                min-height: 320px !important;
+                max-height: 420px !important;
+                letter-spacing: 0.5px;
+                line-height: 1.5;
+                overflow-y: auto !important;
+                resize: vertical !important;
+                scrollbar-width: thin;
+                scrollbar-color: #6cf97c #282c34;
+            }
+            #terminal_logs, #nl_terminal_logs {
+                width: 100% !important;
+            }
+            </style>
+            """)
+
+            profile_dropdown.change(
+                fn=self.update_business_visibility,
+                inputs=[profile_dropdown],
+                outputs=[business_type_dropdown],
+            )
+            nl_profile_type.change(
+                fn=self.update_business_visibility,
+                inputs=[nl_profile_type],
+                outputs=[nl_business_type_dropdown],
+            )
+            country_dropdown.change(
+                fn=self.update_cities,
+                inputs=[country_dropdown],
+                outputs=[city_suggestions, state_dropdown, location_map],
+            )
+            city_input.change(
+                fn=self.update_map_from_location,
+                inputs=[country_dropdown, city_input, state_dropdown],
+                outputs=[location_status, location_map],
+            )
+            analyze_location_btn.click(
+                fn=self.analyze_with_dropdown,
+                inputs=[
+                    country_dropdown,
+                    city_input,
+                    state_dropdown,
+                    profile_dropdown,
+                    business_type_dropdown,
+                    vulnerable_groups,
+                ],
+                outputs=[dropdown_risk_summary, dropdown_recommendations, location_map],
+                show_progress="full",
+            )
+            analyze_btn.click(
+                fn=self.analyze_user_input,
+                inputs=[
+                    user_query,
+                    nl_profile_type,
+                    nl_business_type_dropdown,
+                    nl_vulnerable_groups,
+                ],
+                outputs=[
+                    risk_analysis_output,
+                    recommendations_output,
+                    nl_location_map,
+                ],
+                show_progress="full",
+            )
+        
+        return app