save

app.py

@@ -4,6 +4,9 @@ from tools.need_to_destination import NeedToDestinationTool
 from tools.weather_tool import WeatherTool
 from tools.find_flight import FlightsFinderTool
 from tools.final_answer import FinalAnswerTool
+from tools.country_info_tool import CountryInfoTool
+from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import MultiStepAgent, ActionStep, AgentText, AgentImage, AgentAudio, handle_agent_output_types
 from Gradio_UI import GradioUI
 import yaml
 from tool.mock_tools import MoodToNeedTool, NeedToDestinationTool, WeatherTool, FlightsFinderTool, FinalAnswerTool
@@ -37,11 +40,12 @@ with open("prompts.yaml", "r") as f:
 agent = CodeAgent(
     model=model,
     tools=[
-        MoodToNeedTool(),          # Step 1: Mood → Need
-        NeedToDestinationTool(),   # Step 2: Need → Destination
+        MoodToNeedTool(model=model),          # Step 1: Mood → Need
+        NeedToDestinationTool(model=model),   # Step 2: Need → Destination
         WeatherTool(),             # Step 3: Weather for destination
-        FlightsFinderTool(),       # Step 4: Destination → Flights
-        FinalAnswerTool()          # Step 5: Claude wrap
+        FlightsFinderTool(),       # Step 4: Destination → Flights           # Step 5: Claude wrap
+        FinalAnswerTool(),      # Required final output
+        CountryInfoTool()           # Step 6: Country info
     ],
     max_steps=6,
     verbosity_level=1,

prompts.yaml

@@ -3,15 +3,16 @@ system_prompt: |-
   You operate in an autonomous, multi-step thinking loop using Thought → Code → Observation.
 
   Your job is to:
-  - Reflect on the user’s mood
-  - Infer their emotional need
-  - Suggest a travel destination with a matching activity
-  - Check the weather
-  - Decide whether the weather suits the emotional need
-  - If not, suggest another destination
-  - Once happy, find flights from the origin
-  - Wrap everything into an inspirational message
-  - Optionally, add a quote based on the mood
+    - Reflect on the user’s mood
+    - Infer their emotional need
+    - Suggest a travel destination with a matching activity
+    - Check the weather
+    - Retrieve relevant country information
+    - Decide whether the weather and country conditions suit the emotional need
+    - If not, suggest another destination
+    - Once happy, find flights from the origin
+    - Wrap everything into an inspirational message
+    - Optionally, add a quote based on the mood
 
   You must solve the full task by reasoning, calling tools or managed agents if needed, and writing Python code in the Code block.
 
@@ -24,7 +25,32 @@ system_prompt: |-
    ⁠<end_code>
   Observation: result of previous code
 
-  You must output a final result using ⁠ final_answer() ⁠.
+  You must output a final result using ⁠ final_answer() ⁠. 
+
+  
+  🛫 Your very first job is to ensure the user has provided the following inputs:
+  - `mood`: how the user is feeling (e.g., "stressed", "adventurous")
+  - `origin`: the city or airport they’re departing from
+  - `week`: approximate travel week or date range (e.g., "mid July" or "2025-07-15")
+
+  ❗If one or more are missing, ask for them clearly and stop the plan until you receive all of them.
+  
+  Example check code:
+  ```py
+  if not mood or not origin or not week:
+      missing = []
+      if not mood:
+          missing.append("your mood")
+      if not origin:
+          missing.append("your departure city or airport")
+      if not week:
+          missing.append("your travel week or dates")
+
+      print(f"Before we start planning, could you tell me {', '.join(missing)}? 😊")
+  else:
+      print("All required inputs provided. Let's begin planning.")
+  ```<end_code>
+
 
   Your available tools are:
   - mood_to_need(mood: str) → str: Extracts the emotional need behind a mood (e.g., "to reconnect").

tools/country_info_tool.py

@@ -0,0 +1,729 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import requests
+from datetime import datetime, timedelta
+import json
+import os
+from dotenv import load_dotenv
+import re
+import anthropic
+
+class CountryInfoTool(Tool):
+    name = "country_info"
+    description = "Récupère des informations contextuelles importantes sur un pays en temps réel : sécurité, événements actuels, fêtes nationales, climat politique, conseils de voyage."
+    inputs = {
+        'country': {'type': 'string', 'description': 'Le nom du pays en français ou en anglais (ex: "France", "États-Unis", "Japon")'},
+        'info_type': {'type': 'string', 'description': 'Type d\'information recherchée: "all", "security", "events", "holidays", "travel", "politics"', 'nullable': True}
+    }
+    output_type = "string"
+
+    def __init__(self):
+        super().__init__()
+        load_dotenv()
+        
+        # Initialiser le client Claude (Anthropic)
+        self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
+        
+        # Mapping étendu des pays français vers anglais pour les APIs
+        self.country_mapping = {
+            # Europe
+            'france': 'France', 'allemagne': 'Germany', 'italie': 'Italy', 'espagne': 'Spain',
+            'royaume-uni': 'United Kingdom', 'angleterre': 'United Kingdom', 'écosse': 'United Kingdom',
+            'pays-bas': 'Netherlands', 'hollande': 'Netherlands', 'belgique': 'Belgium', 
+            'suisse': 'Switzerland', 'autriche': 'Austria', 'portugal': 'Portugal',
+            'suède': 'Sweden', 'norvège': 'Norway', 'danemark': 'Denmark', 'finlande': 'Finland',
+            'pologne': 'Poland', 'république tchèque': 'Czech Republic', 'tchéquie': 'Czech Republic',
+            'hongrie': 'Hungary', 'roumanie': 'Romania', 'bulgarie': 'Bulgaria',
+            'grèce': 'Greece', 'croatie': 'Croatia', 'slovénie': 'Slovenia', 'slovaquie': 'Slovakia',
+            'estonie': 'Estonia', 'lettonie': 'Latvia', 'lituanie': 'Lithuania',
+            'irlande': 'Ireland', 'islande': 'Iceland', 'malte': 'Malta', 'chypre': 'Cyprus',
+            'serbie': 'Serbia', 'bosnie': 'Bosnia and Herzegovina', 'monténégro': 'Montenegro',
+            'macédoine': 'North Macedonia', 'albanie': 'Albania', 'moldavie': 'Moldova',
+            'ukraine': 'Ukraine', 'biélorussie': 'Belarus', 'russie': 'Russia',
+            
+            # Amériques
+            'états-unis': 'United States', 'usa': 'United States', 'amérique': 'United States',
+            'canada': 'Canada', 'mexique': 'Mexico',
+            'brésil': 'Brazil', 'argentine': 'Argentina', 'chili': 'Chile', 'pérou': 'Peru',
+            'colombie': 'Colombia', 'venezuela': 'Venezuela', 'équateur': 'Ecuador',
+            'bolivie': 'Bolivia', 'paraguay': 'Paraguay', 'uruguay': 'Uruguay',
+            'guatemala': 'Guatemala', 'costa rica': 'Costa Rica', 'panama': 'Panama',
+            'cuba': 'Cuba', 'jamaïque': 'Jamaica', 'haïti': 'Haiti', 'république dominicaine': 'Dominican Republic',
+            
+            # Asie
+            'chine': 'China', 'japon': 'Japan', 'corée du sud': 'South Korea', 'corée du nord': 'North Korea',
+            'inde': 'India', 'pakistan': 'Pakistan', 'bangladesh': 'Bangladesh', 'sri lanka': 'Sri Lanka',
+            'thaïlande': 'Thailand', 'vietnam': 'Vietnam', 'cambodge': 'Cambodia', 'laos': 'Laos',
+            'myanmar': 'Myanmar', 'birmanie': 'Myanmar', 'malaisie': 'Malaysia', 'singapour': 'Singapore',
+            'indonésie': 'Indonesia', 'philippines': 'Philippines', 'brunei': 'Brunei',
+            'mongolie': 'Mongolia', 'kazakhstan': 'Kazakhstan', 'ouzbékistan': 'Uzbekistan',
+            'kirghizistan': 'Kyrgyzstan', 'tadjikistan': 'Tajikistan', 'turkménistan': 'Turkmenistan',
+            'afghanistan': 'Afghanistan', 'iran': 'Iran', 'irak': 'Iraq', 'syrie': 'Syria',
+            'turquie': 'Turkey', 'israël': 'Israel', 'palestine': 'Palestine', 'liban': 'Lebanon',
+            'jordanie': 'Jordan', 'arabie saoudite': 'Saudi Arabia', 'émirats arabes unis': 'United Arab Emirates',
+            'qatar': 'Qatar', 'koweït': 'Kuwait', 'bahreïn': 'Bahrain', 'oman': 'Oman', 'yémen': 'Yemen',
+            
+            # Afrique
+            'maroc': 'Morocco', 'algérie': 'Algeria', 'tunisie': 'Tunisia', 'libye': 'Libya', 'égypte': 'Egypt',
+            'soudan': 'Sudan', 'éthiopie': 'Ethiopia', 'kenya': 'Kenya', 'tanzanie': 'Tanzania',
+            'ouganda': 'Uganda', 'rwanda': 'Rwanda', 'burundi': 'Burundi', 'congo': 'Democratic Republic of the Congo',
+            'république démocratique du congo': 'Democratic Republic of the Congo', 'rdc': 'Democratic Republic of the Congo',
+            'république du congo': 'Republic of the Congo', 'cameroun': 'Cameroon', 'nigeria': 'Nigeria',
+            'ghana': 'Ghana', 'côte d\'ivoire': 'Ivory Coast', 'sénégal': 'Senegal', 'mali': 'Mali',
+            'burkina faso': 'Burkina Faso', 'niger': 'Niger', 'tchad': 'Chad', 'centrafrique': 'Central African Republic',
+            'gabon': 'Gabon', 'guinée équatoriale': 'Equatorial Guinea', 'sao tomé': 'Sao Tome and Principe',
+            'cap-vert': 'Cape Verde', 'guinée-bissau': 'Guinea-Bissau', 'guinée': 'Guinea',
+            'sierra leone': 'Sierra Leone', 'liberia': 'Liberia', 'togo': 'Togo', 'bénin': 'Benin',
+            'mauritanie': 'Mauritania', 'gambie': 'Gambia', 'afrique du sud': 'South Africa',
+            'namibie': 'Namibia', 'botswana': 'Botswana', 'zimbabwe': 'Zimbabwe', 'zambie': 'Zambia',
+            'malawi': 'Malawi', 'mozambique': 'Mozambique', 'madagascar': 'Madagascar', 'maurice': 'Mauritius',
+            'seychelles': 'Seychelles', 'comores': 'Comoros', 'djibouti': 'Djibouti', 'érythrée': 'Eritrea',
+            'somalie': 'Somalia', 'lesotho': 'Lesotho', 'eswatini': 'Eswatini', 'swaziland': 'Eswatini',
+            
+            # Océanie
+            'australie': 'Australia', 'nouvelle-zélande': 'New Zealand', 'fidji': 'Fiji',
+            'papouasie-nouvelle-guinée': 'Papua New Guinea', 'vanuatu': 'Vanuatu', 'samoa': 'Samoa',
+            'tonga': 'Tonga', 'îles salomon': 'Solomon Islands', 'micronésie': 'Micronesia',
+            'palau': 'Palau', 'nauru': 'Nauru', 'kiribati': 'Kiribati', 'tuvalu': 'Tuvalu'
+        }
+        
+        # Codes ISO pour certaines APIs
+        self.country_codes = {
+            'France': 'FR', 'United States': 'US', 'United Kingdom': 'GB',
+            'Germany': 'DE', 'Italy': 'IT', 'Spain': 'ES', 'Japan': 'JP',
+            'China': 'CN', 'India': 'IN', 'Brazil': 'BR', 'Canada': 'CA',
+            'Australia': 'AU', 'Russia': 'RU', 'Mexico': 'MX', 'South Korea': 'KR',
+            'Netherlands': 'NL', 'Belgium': 'BE', 'Switzerland': 'CH',
+            'Sweden': 'SE', 'Norway': 'NO', 'Denmark': 'DK', 'Turkey': 'TR',
+            'Egypt': 'EG', 'Thailand': 'TH', 'Iran': 'IR'
+        }
+
+    def forward(self, country: str, info_type: Optional[str] = "all") -> str:
+        try:
+            # Normaliser le nom du pays
+            country_normalized = self._normalize_country_name(country)
+            
+            if not country_normalized:
+                return f"❌ Pays non reconnu: '{country}'. Essayez avec le nom complet (ex: 'France', 'États-Unis', 'Royaume-Uni')"
+            
+            # Collecter les informations selon le type demandé
+            info_sections = []
+            
+            if info_type in ["all", "security"]:
+                security_info = self._get_security_info(country_normalized)
+                if security_info:
+                    info_sections.append(security_info)
+            
+            if info_type in ["all", "events"]:
+                events_info = self._get_current_events_info(country_normalized)
+                if events_info:
+                    info_sections.append(events_info)
+            
+            if info_type in ["all", "holidays"]:
+                holidays_info = self._get_holidays_info(country_normalized)
+                if holidays_info:
+                    info_sections.append(holidays_info)
+            
+            if info_type in ["all", "travel"]:
+                travel_info = self._get_travel_info(country_normalized)
+                if travel_info:
+                    info_sections.append(travel_info)
+            
+            if info_type in ["all", "politics"]:
+                politics_info = self._get_political_info(country_normalized)
+                if politics_info:
+                    info_sections.append(politics_info)
+            
+            if not info_sections:
+                return f"❌ Aucune information disponible pour {country_normalized} actuellement."
+            
+            # Assembler le rapport final
+            result = f"🌍 **Informations contextuelles pour {country_normalized}**\n"
+            result += f"*Mise à jour: {datetime.now().strftime('%d/%m/%Y %H:%M')}*\n\n"
+            result += "\n\n".join(info_sections)
+            
+            # Ajouter une recommandation finale intelligente si Claude est disponible et qu'on demande toutes les infos
+            if info_type == "all" and self.claude_client:
+                final_recommendation = self._get_llm_final_recommendation(country_normalized, "\n\n".join(info_sections))
+                if final_recommendation:
+                    result += f"\n\n{final_recommendation}"
+            
+            return result
+            
+        except Exception as e:
+            return f"❌ Erreur lors de la récupération des informations: {str(e)}"
+
+    def _normalize_country_name(self, country: str) -> Optional[str]:
+        """Normalise le nom du pays"""
+        country_lower = country.lower().strip()
+        
+        # Vérifier dans le mapping français -> anglais
+        if country_lower in self.country_mapping:
+            return self.country_mapping[country_lower]
+        
+        # Vérifier si c'est déjà un nom anglais valide
+        for french, english in self.country_mapping.items():
+            if country_lower == english.lower():
+                return english
+        
+        # Essayer une correspondance partielle
+        for french, english in self.country_mapping.items():
+            if country_lower in french or french in country_lower:
+                return english
+        
+        # Si pas trouvé dans le mapping, essayer de valider via l'API REST Countries
+        validated_country = self._validate_country_via_api(country)
+        if validated_country:
+            return validated_country
+        
+        return None
+
+    def _validate_country_via_api(self, country: str) -> Optional[str]:
+        """Valide et normalise le nom du pays via l'API REST Countries"""
+        try:
+            # Essayer d'abord avec le nom exact
+            url = f"https://restcountries.com/v3.1/name/{country}"
+            response = requests.get(url, timeout=5)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data:
+                    # Retourner le nom officiel en anglais
+                    return data[0].get('name', {}).get('common', country.title())
+            
+            # Si échec, essayer avec une recherche partielle
+            url = f"https://restcountries.com/v3.1/name/{country}?fullText=false"
+            response = requests.get(url, timeout=5)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data:
+                    # Prendre le premier résultat
+                    return data[0].get('name', {}).get('common', country.title())
+            
+            return None
+            
+        except Exception:
+            # En cas d'erreur, retourner le nom avec la première lettre en majuscule
+            return country.title() if len(country) > 2 else None
+
+    def _get_country_code_from_api(self, country: str) -> Optional[str]:
+        """Récupère le code ISO du pays via l'API REST Countries"""
+        try:
+            url = f"https://restcountries.com/v3.1/name/{country}"
+            response = requests.get(url, timeout=5)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data:
+                    # Retourner le code ISO alpha-2
+                    return data[0].get('cca2', '')
+            
+            return None
+            
+        except Exception:
+            return None
+
+    def _get_security_info(self, country: str) -> str:
+        """Récupère les informations de sécurité avec recherche exhaustive"""
+        try:
+            # Vérifier d'abord si c'est un pays à risque connu
+            risk_level = self._check_known_risk_countries(country)
+            
+            # Recherches multiples avec différents mots-clés
+            all_news_data = []
+            
+            # Recherche 1: Sécurité générale
+            security_keywords = f"{country} travel advisory security warning conflict war"
+            news_data1 = self._search_security_news(security_keywords)
+            all_news_data.extend(news_data1)
+            
+            # Recherche 2: Conflits spécifiques
+            conflict_keywords = f"{country} war conflict violence terrorism attack bombing"
+            news_data2 = self._search_security_news(conflict_keywords)
+            all_news_data.extend(news_data2)
+            
+            # Recherche 3: Instabilité politique
+            political_keywords = f"{country} coup government crisis instability sanctions"
+            news_data3 = self._search_security_news(political_keywords)
+            all_news_data.extend(news_data3)
+            
+            # Recherche 4: Alertes de voyage
+            travel_keywords = f"{country} 'travel ban' 'do not travel' 'avoid travel' embassy"
+            news_data4 = self._search_security_news(travel_keywords)
+            all_news_data.extend(news_data4)
+            
+            # Supprimer les doublons
+            unique_news = []
+            seen_titles = set()
+            for article in all_news_data:
+                title = article.get('title', '')
+                if title and title not in seen_titles:
+                    unique_news.append(article)
+                    seen_titles.add(title)
+            
+            # Analyser les résultats pour déterminer le niveau de sécurité
+            security_level, description, recommendation = self._analyze_security_data(country, unique_news, risk_level)
+            
+            result = f"🛡️ **Sécurité et Conseils de Voyage**\n"
+            result += f"{security_level} **Niveau déterminé par analyse en temps réel**\n"
+            result += f"📋 {description}\n"
+            result += f"🎯 **Recommandation: {recommendation}**"
+            
+            return result
+            
+        except Exception as e:
+            return f"🛡️ **Sécurité**: Erreur lors de la récupération - {str(e)}"
+
+    def _check_known_risk_countries(self, country: str) -> str:
+        """Vérifie si le pays est dans la liste des pays à risque connus"""
+        
+        # Pays à très haut risque (guerre active, conflit majeur)
+        high_risk_countries = [
+            'Ukraine', 'Afghanistan', 'Syria', 'Yemen', 'Somalia', 'South Sudan',
+            'Central African Republic', 'Mali', 'Burkina Faso', 'Niger',
+            'Democratic Republic of the Congo', 'Myanmar', 'Palestine', 'Gaza',
+            'West Bank', 'Iraq', 'Libya', 'Sudan'
+        ]
+        
+        # Pays à risque modéré (instabilité, tensions)
+        moderate_risk_countries = [
+            'Iran', 'North Korea', 'Venezuela', 'Belarus', 'Ethiopia',
+            'Chad', 'Cameroon', 'Nigeria', 'Pakistan', 'Bangladesh',
+            'Haiti', 'Lebanon', 'Turkey', 'Egypt', 'Algeria'
+        ]
+        
+        # Pays avec tensions spécifiques
+        tension_countries = [
+            'Russia', 'China', 'Israel', 'India', 'Kashmir', 'Taiwan',
+            'Hong Kong', 'Thailand', 'Philippines', 'Colombia'
+        ]
+        
+        country_lower = country.lower()
+        
+        for risk_country in high_risk_countries:
+            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
+                return "HIGH_RISK"
+        
+        for risk_country in moderate_risk_countries:
+            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
+                return "MODERATE_RISK"
+                
+        for risk_country in tension_countries:
+            if risk_country.lower() in country_lower or country_lower in risk_country.lower():
+                return "TENSION"
+        
+        return "UNKNOWN"
+
+    def _search_security_news(self, keywords: str) -> list:
+        """Recherche d'actualités de sécurité avec période étendue"""
+        try:
+            # Utiliser NewsAPI si disponible
+            api_key = os.getenv('NEWSAPI_KEY')
+            if api_key:
+                url = "https://newsapi.org/v2/everything"
+                params = {
+                    'q': keywords,
+                    'sortBy': 'publishedAt',
+                    'pageSize': 20,  # Plus d'articles
+                    'language': 'en',
+                    'from': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),  # 30 jours au lieu de 7
+                    'apiKey': api_key
+                }
+                
+                response = requests.get(url, params=params, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                    articles = data.get('articles', [])
+                    
+                    # Filtrer les articles pertinents
+                    relevant_articles = []
+                    for article in articles:
+                        title = article.get('title', '').lower()
+                        description = article.get('description', '').lower()
+                        
+                        # Mots-clés critiques pour filtrer
+                        critical_keywords = ['war', 'conflict', 'attack', 'bombing', 'terrorism', 
+                                           'violence', 'crisis', 'coup', 'sanctions', 'advisory',
+                                           'warning', 'danger', 'risk', 'threat', 'security']
+                        
+                        if any(keyword in title or keyword in description for keyword in critical_keywords):
+                            relevant_articles.append(article)
+                    
+                    return relevant_articles
+            
+            # Fallback: recherche via une API publique alternative
+            return self._search_alternative_news(keywords)
+            
+        except Exception:
+            return []
+
+    def _search_alternative_news(self, keywords: str) -> list:
+        """Recherche alternative sans API key"""
+        try:
+            # Utiliser une API publique comme Guardian ou BBC
+            # Pour l'exemple, on simule une recherche basique
+            dangerous_keywords = ['war', 'conflict', 'terrorism', 'violence', 'crisis', 'coup', 'sanctions']
+            warning_keywords = ['protest', 'unrest', 'advisory', 'caution', 'alert']
+            
+            # Simulation basée sur les mots-clés (à remplacer par vraie API)
+            if any(word in keywords.lower() for word in dangerous_keywords):
+                return [{'title': f'Security concerns in {keywords.split()[0]}', 'description': 'Recent security developments'}]
+            elif any(word in keywords.lower() for word in warning_keywords):
+                return [{'title': f'Travel advisory for {keywords.split()[0]}', 'description': 'Caution advised'}]
+            
+            return []
+            
+        except Exception:
+            return []
+
+    def _analyze_security_data(self, country: str, news_data: list, risk_level: str = "UNKNOWN") -> tuple:
+        """Analyse les données de sécurité avec Claude uniquement"""
+        try:
+            if not self.claude_client:
+                return ("⚪", 
+                       "Claude non disponible", 
+                       "❓ Clé API Anthropic requise pour l'analyse de sécurité")
+            
+            # Préparer le contenu des actualités pour l'analyse
+            news_content = ""
+            for i, article in enumerate(news_data[:10], 1):  # Limiter à 10 articles
+                title = article.get('title', '')
+                description = article.get('description', '')
+                if title or description:
+                    news_content += f"{i}. {title}\n{description}\n\n"
+            
+            # Si pas d'actualités mais pays à haut risque connu, forcer l'analyse
+            if not news_content.strip():
+                if risk_level == "HIGH_RISK":
+                    return ("🔴", 
+                           f"Pays à très haut risque - conflit actif ou guerre",
+                           "🚫 CHANGEZ DE DESTINATION - Zone de conflit active")
+                elif risk_level == "MODERATE_RISK":
+                    return ("🟡", 
+                           f"Pays à risque modéré - instabilité politique",
+                           "⚠️ Voyage possible avec précautions renforcées")
+                else:
+                    return ("🟢", 
+                           f"Aucune actualité de sécurité récente trouvée",
+                           "✅ Destination considérée comme sûre")
+            
+            # Utiliser Claude pour analyser
+            analysis = self._llm_security_analysis(country, news_content, risk_level)
+            
+            if analysis:
+                return analysis
+            else:
+                return ("⚪", 
+                       "Erreur d'analyse Claude", 
+                       "❓ Impossible d'analyser la sécurité actuellement")
+                       
+        except Exception:
+            return ("⚪", "Analyse impossible", "❓ Consultez les sources officielles")
+
+    def _llm_security_analysis(self, country: str, news_content: str, risk_level: str = "UNKNOWN") -> Optional[tuple]:
+        """Utilise Claude pour analyser la sécurité du pays"""
+        try:
+            if not self.claude_client:
+                return None
+                
+            prompt = f"""Analysez les actualités récentes suivantes concernant {country} et déterminez le niveau de sécurité pour un voyageur :
+
+NIVEAU DE RISQUE CONNU : {risk_level}
+- HIGH_RISK = Pays en guerre active ou conflit majeur
+- MODERATE_RISK = Pays avec instabilité politique significative  
+- TENSION = Pays avec tensions géopolitiques
+- UNKNOWN = Pas de classification spéciale
+
+ACTUALITÉS RÉCENTES :
+{news_content}
+
+INSTRUCTIONS CRITIQUES :
+1. Si NIVEAU DE RISQUE = HIGH_RISK, vous DEVEZ recommander CHANGEZ_DE_DESTINATION sauf preuve claire d'amélioration
+2. Pour l'Ukraine, Palestine, Afghanistan, Syrie, Yémen : TOUJOURS ROUGE/CHANGEZ_DE_DESTINATION
+3. Analysez le niveau de risque pour un touriste/voyageur civil
+4. Soyez TRÈS STRICT - la sécurité des voyageurs est prioritaire
+
+Répondez UNIQUEMENT au format JSON suivant :
+
+{{
+    "niveau": "ROUGE|JAUNE|VERT",
+    "description": "Description courte de la situation (max 100 caractères)",
+    "recommandation": "CHANGEZ_DE_DESTINATION|PRECAUTIONS_RENFORCEES|DESTINATION_SURE",
+    "justification": "Explication de votre décision (max 200 caractères)"
+}}
+
+Critères STRICTS :
+- ROUGE/CHANGEZ_DE_DESTINATION : guerre active, conflit armé, terrorisme actif, coup d'état, violence généralisée, zones de combat
+- JAUNE/PRECAUTIONS_RENFORCEES : manifestations violentes, criminalité très élevée, instabilité politique, tensions ethniques
+- VERT/DESTINATION_SURE : pas de risques majeurs pour les civils
+
+PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niveau de sécurité le plus strict."""
+
+            response = self.claude_client.messages.create(
+                model="claude-3-opus-20240229",
+                max_tokens=300,
+                temperature=0.1,
+                system="Vous êtes un expert en sécurité des voyages. Analysez objectivement les risques.",
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            result_text = response.content[0].text.strip()
+            # Parser la réponse JSON
+            try:
+                result = json.loads(result_text)
+                niveau = result.get('niveau', 'VERT')
+                description = result.get('description', 'Analyse effectuée')
+                recommandation = result.get('recommandation', 'DESTINATION_SURE')
+                justification = result.get('justification', '')
+                
+                # Convertir en format attendu
+                if niveau == 'ROUGE':
+                    emoji = "🔴"
+                    advice = "🚫 CHANGEZ DE DESTINATION - " + justification
+                elif niveau == 'JAUNE':
+                    emoji = "🟡"
+                    advice = "⚠️ Voyage possible avec précautions renforcées - " + justification
+                else:
+                    emoji = "🟢"
+                    advice = "✅ Destination considérée comme sûre - " + justification
+                
+                return (emoji, description, advice)
+                
+            except json.JSONDecodeError:
+                return None
+                
+        except Exception:
+            return None
+
+
+
+    def _get_current_events_info(self, country: str) -> str:
+        """Récupère les événements actuels via recherche web"""
+        try:
+            # Rechercher les événements récents
+            events_keywords = f"{country} current events news today recent"
+            events_data = self._search_current_events(events_keywords)
+            
+            if not events_data:
+                return f"📅 **Événements**: Aucun événement majeur détecté pour {country}"
+            
+            result = f"📅 **Événements et Contexte Actuel**\n"
+            for i, event in enumerate(events_data[:5], 1):
+                title = event.get('title', 'Événement non spécifié')
+                result += f"• {title}\n"
+            
+            return result.rstrip()
+            
+        except Exception:
+            return "📅 **Événements**: Erreur lors de la récupération"
+
+    def _search_current_events(self, keywords: str) -> list:
+        """Recherche d'événements actuels"""
+        try:
+            # Utiliser NewsAPI si disponible
+            api_key = os.getenv('NEWSAPI_KEY')
+            if api_key:
+                url = "https://newsapi.org/v2/everything"
+                params = {
+                    'q': keywords,
+                    'sortBy': 'publishedAt',
+                    'pageSize': 5,
+                    'from': (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d'),
+                    'language': 'en',
+                    'apiKey': api_key
+                }
+                
+                response = requests.get(url, params=params, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                    return data.get('articles', [])
+            
+            return []
+            
+        except Exception:
+            return []
+
+    def _get_holidays_info(self, country: str) -> str:
+        """Récupère les fêtes nationales via API"""
+        try:
+            country_code = self.country_codes.get(country, '')
+            
+            # Si pas de code dans notre mapping, essayer de le récupérer via API
+            if not country_code:
+                country_code = self._get_country_code_from_api(country)
+            
+            if not country_code:
+                return f"🎉 **Fêtes**: Code pays non trouvé pour {country}"
+            
+            # Utiliser l'API Calendarific ou similaire
+            holidays_data = self._fetch_holidays_api(country_code)
+            
+            if not holidays_data:
+                return f"🎉 **Fêtes**: Informations non disponibles pour {country}"
+            
+            current_month = datetime.now().month
+            current_year = datetime.now().year
+            
+            result = f"🎉 **Fêtes et Événements Saisonniers**\n"
+            
+            # Filtrer les fêtes du mois actuel et des prochains mois
+            upcoming_holidays = []
+            for holiday in holidays_data:
+                try:
+                    holiday_date = datetime.strptime(holiday.get('date', ''), '%Y-%m-%d')
+                    if holiday_date.month >= current_month and holiday_date.year == current_year:
+                        upcoming_holidays.append(holiday)
+                except:
+                    continue
+            
+            if upcoming_holidays:
+                result += f"**Prochaines fêtes:**\n"
+                for holiday in upcoming_holidays[:5]:
+                    name = holiday.get('name', 'Fête inconnue')
+                    date = holiday.get('date', '')
+                    result += f"• {name} ({date})\n"
+            else:
+                result += f"**Aucune fête majeure prévue dans les prochains mois**\n"
+            
+            return result.rstrip()
+            
+        except Exception:
+            return "🎉 **Fêtes**: Erreur lors de la récupération"
+
+    def _fetch_holidays_api(self, country_code: str) -> list:
+        """Récupère les fêtes via API publique"""
+        try:
+            # Utiliser une API publique de fêtes (exemple: Calendarific, Nager.Date)
+            year = datetime.now().year
+            url = f"https://date.nager.at/api/v3/PublicHolidays/{year}/{country_code}"
+            
+            response = requests.get(url, timeout=10)
+            if response.status_code == 200:
+                return response.json()
+            
+            return []
+            
+        except Exception:
+            return []
+
+    def _get_travel_info(self, country: str) -> str:
+        """Récupère les informations de voyage via API REST Countries"""
+        try:
+            # Utiliser l'API REST Countries
+            url = f"https://restcountries.com/v3.1/name/{country}"
+            response = requests.get(url, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data:
+                    country_data = data[0]
+                    
+                    # Extraire les informations
+                    currencies = country_data.get('currencies', {})
+                    languages = country_data.get('languages', {})
+                    region = country_data.get('region', 'Inconnu')
+                    
+                    currency_name = list(currencies.keys())[0] if currencies else 'Inconnue'
+                    language_list = list(languages.values()) if languages else ['Inconnue']
+                    
+                    result = f"✈️ **Informations Pratiques de Voyage**\n"
+                    result += f"💰 Monnaie: {currency_name}\n"
+                    result += f"🗣️ Langues: {', '.join(language_list[:3])}\n"
+                    result += f"🌍 Région: {region}\n"
+                    result += f"📋 Vérifiez les exigences visa sur le site officiel du pays"
+                    
+                    return result
+            
+            return f"✈️ **Voyage**: Informations non disponibles pour {country}"
+            
+        except Exception:
+            return "✈️ **Voyage**: Erreur lors de la récupération"
+
+    def _get_political_info(self, country: str) -> str:
+        """Récupère le contexte politique via recherche d'actualités"""
+        try:
+            # Rechercher des actualités politiques récentes
+            political_keywords = f"{country} politics government election democracy"
+            political_data = self._search_political_news(political_keywords)
+            
+            if not political_data:
+                return f"🏛️ **Politique**: Situation stable pour {country}"
+            
+            result = f"🏛️ **Contexte Politique**\n"
+            
+            # Analyser les actualités politiques
+            for article in political_data[:3]:
+                title = article.get('title', '')
+                if title:
+                    result += f"• {title}\n"
+            
+            return result.rstrip()
+            
+        except Exception:
+            return "🏛️ **Politique**: Erreur lors de la récupération"
+
+    def _search_political_news(self, keywords: str) -> list:
+        """Recherche d'actualités politiques"""
+        try:
+            api_key = os.getenv('NEWSAPI_KEY')
+            if api_key:
+                url = "https://newsapi.org/v2/everything"
+                params = {
+                    'q': keywords,
+                    'sortBy': 'publishedAt',
+                    'pageSize': 5,
+                    'from': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
+                    'language': 'en',
+                    'apiKey': api_key
+                }
+                
+                response = requests.get(url, params=params, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                    return data.get('articles', [])
+            
+            return []
+            
+        except Exception:
+            return []
+
+    def _get_llm_final_recommendation(self, country: str, full_report: str) -> Optional[str]:
+        """Utilise Claude pour générer une recommandation finale intelligente"""
+        try:
+            if not self.claude_client:
+                return None
+                
+            prompt = f"""Analysez ce rapport complet sur {country} et donnez une recommandation finale concise pour un voyageur français :
+
+RAPPORT COMPLET :
+{full_report}
+
+Votre tâche :
+1. Synthétisez les informations les plus importantes
+2. Donnez une recommandation claire et actionnable
+3. Répondez en français, maximum 200 mots
+4. Utilisez un ton professionnel mais accessible
+5. Si des risques existent, soyez explicite sur les précautions
+
+Format de réponse souhaité :
+🎯 **RECOMMANDATION FINALE**
+[Votre analyse synthétique et recommandation]
+
+Si la destination est dangereuse, utilisez clairement "CHANGEZ DE DESTINATION" dans votre réponse."""
+
+            response = self.claude_client.messages.create(
+                model="claude-3-opus-20240229",
+                max_tokens=250,
+                temperature=0.2,
+                system="Vous êtes un conseiller en voyage expert. Donnez des recommandations claires et pratiques.",
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            return response.content[0].text.strip()
+            
+        except Exception:
+            return None 

tools/mood_to_need.py

@@ -1,7 +1,8 @@
-"""Tool to map a user's mood to a vacation need."""
-
 from smolagents.tools import Tool
-
+from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
+import os
+from dotenv import load_dotenv
+load_dotenv()  # Loads variables from .env into environment
 class MoodToNeedTool(Tool):
     """
     A tool that converts user mood descriptions into vacation needs using an LLM.
@@ -22,6 +23,7 @@ class MoodToNeedTool(Tool):
         Args:
             model: A callable language model with a __call__(str) -> str interface.
         """
+        super().__init__()
         self.model = model
 
     def forward(self, mood: str) -> str:
@@ -44,4 +46,17 @@ class MoodToNeedTool(Tool):
             f'Need:'
         )
         response = self.model(prompt)
-        return response.strip()
+        return response.strip()
+
+client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"))
+
+def claude_mood_to_need_model(prompt: str) -> str:
+    message = client.messages.create(
+        model="claude-3-opus-20240229",
+        max_tokens=1024,
+        temperature=0.7,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return message.content[0].text

tools/need_to_destination.py

@@ -1,5 +1,9 @@
 from smolagents.tools import Tool
+from anthropic import Anthropic
+import os
 import json
+from dotenv import load_dotenv
+load_dotenv()  # Loads variables from .env into environment
 
 class NeedToDestinationTool(Tool):
     name = "NeedToDestination"
@@ -16,32 +20,32 @@ class NeedToDestinationTool(Tool):
 
     def forward(self, need: str) -> list[dict]:
         prompt = f"""
-You are a travel agent AI.
+            You are a travel agent AI.
 
-Based on the user's need: "{need}",
-suggest 2-3 travel destinations with round-trip flight information.
+            Based on the user's need: "{need}",
+            suggest 2-3 travel destinations with round-trip flight information.
 
-Return the output as valid JSON in the following format:
+            Return the output as valid JSON in the following format:
 
-[
-  {{
-    "destination": "DestinationName",
-    "departure": {{
-      "date": "YYYY-MM-DD",
-      "from_airport": "{self.departure_airport}",
-      "to_airport": "XXX"
-    }},
-    "return": {{
-      "date": "YYYY-MM-DD",
-      "from_airport": "XXX",
-      "to_airport": "{self.departure_airport}"
-    }}
-  }},
-  ...
-]
+            [
+            {{
+                "destination": "DestinationName",
+                "departure": {{
+                "date": "YYYY-MM-DD",
+                "from_airport": "{self.departure_airport}",
+                "to_airport": "XXX"
+                }},
+                "return": {{
+                "date": "YYYY-MM-DD",
+                "from_airport": "XXX",
+                "to_airport": "{self.departure_airport}"
+                }}
+            }},
+            ...
+            ]
 
-DO NOT add explanations, only return raw JSON.
-"""
+            DO NOT add explanations, only return raw JSON.
+            """
         result = self.model(prompt)
         try:
             destinations = json.loads(result.strip())
@@ -50,42 +54,16 @@ DO NOT add explanations, only return raw JSON.
 
         return destinations
     
-def mock_model(prompt: str) -> str:
-    return """
-    [
-      {
-        "destination": "Nice",
-        "departure": {
-          "date": "2025-07-01",
-          "from_airport": "CDG",
-          "to_airport": "NCE"
-        },
-        "return": {
-          "date": "2025-07-07",
-          "from_airport": "NCE",
-          "to_airport": "CDG"
-        }
-      },
-      {
-        "destination": "Barcelona",
-        "departure": {
-          "date": "2025-07-02",
-          "from_airport": "CDG",
-          "to_airport": "BCN"
-        },
-        "return": {
-          "date": "2025-07-08",
-          "from_airport": "BCN",
-          "to_airport": "CDG"
-        }
-      }
-    ]
-    """
 
-if __name__ == "__main__":
-    tool = NeedToDestinationTool(model=mock_model)
-    test_need = "A relaxing beach holiday"
-    destinations = tool(need=test_need)
-    print("Destinations returned by the tool:")
-    for dest in destinations:
-        print(dest)
+client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"))
+
+def claude_need_to_destination_model(prompt: str) -> str:
+    message = client.messages.create(
+        model="claude-3-opus-20240229",
+        max_tokens=1024,
+        temperature=0.7,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return message.content[0].text

tools/test_mood_to_destination.py

@@ -0,0 +1,21 @@
+from tools.mood_to_need import MoodToNeedTool, claude_mood_to_need_model
+from tools.need_to_destination import NeedToDestinationTool, claude_need_to_destination_model
+import json
+
+mood_tool = MoodToNeedTool(model=claude_mood_to_need_model)
+mood = "I'm feeling stuck in a routine and need change"
+# mood = "I feel overwhelmed and burned out."
+# mood = "I just got out of a break up"
+
+need = mood_tool(mood=mood)
+print(f"Mood: {mood}")
+print("Need:", need)
+
+destination_tool = NeedToDestinationTool(model=claude_need_to_destination_model, departure_airport="CDG")
+try:
+    destinations = destination_tool(need=need)
+    print("\n→ Suggested Destinations:")
+    for dest in destinations:
+        print(json.dumps(dest, indent=2))
+except ValueError as e:
+    print(f"Error parsing Claude output: {e}")

tools/weather_example.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""
-Exemple d'utilisation de l'outil météo (API gratuite OpenWeatherMap)
-"""
-
-from weather_tool import WeatherTool
-from datetime import datetime, timedelta
-
-def main():
-    # Initialiser l'outil météo (charge automatiquement la clé API depuis .env)
-    weather_tool = WeatherTool()
-    
-    print("=== Exemples d'utilisation de l'outil météo ===\n")
-    
-    # Exemple 1: Météo actuelle
-    print("1. Météo actuelle à Paris:")
-    result = weather_tool.forward("Paris")
-    print(result)
-    print("\n" + "="*50 + "\n")
-    
-    # Exemple 2: Météo pour une date spécifique
-    print("2. Météo à Londres pour demain:")
-    tomorrow = (datetime.now() + timedelta(days=1)).strftime("%Y-%m-%d")
-    result = weather_tool.forward("London", date=tomorrow)
-    print(result)
-    print("\n" + "="*50 + "\n")
-    
-    # Exemple 3: Météo pour un pays
-    print("3. Météo à Tokyo dans 3 jours:")
-    future_date = (datetime.now() + timedelta(days=3)).strftime("%Y-%m-%d")
-    result = weather_tool.forward("Tokyo", date=future_date)
-    print(result)
-    print("\n" + "="*50 + "\n")
-    
-    # Exemple 4: Météo avec une clé API spécifique
-    print("4. Météo à Berlin (avec clé API personnalisée):")
-    # result = weather_tool.forward("Berlin", api_key="votre_cle_api_ici")
-    result = weather_tool.forward("Berlin")  # Utilise la clé du .env
-    print(result)
-
-if __name__ == "__main__":
-    main() 

tools/weather_tool.py

@@ -5,13 +5,15 @@ from datetime import datetime, timedelta
 import json
 import os
 from dotenv import load_dotenv
+import anthropic
 
 class WeatherTool(Tool):
     name = "weather_forecast"
-    description = "Obtient les prévisions météorologiques pour un pays/ville spécifique à une date donnée. Utilise l'API gratuite OpenWeatherMap 2.5."
+    description = "Obtient les prévisions météorologiques intelligentes pour un pays/ville avec recommandations basées sur le type de destination et les activités prévues."
     inputs = {
         'location': {'type': 'string', 'description': 'Le nom de la ville ou du pays pour lequel obtenir la météo (ex: "Paris", "London", "Tokyo")'},
         'date': {'type': 'string', 'description': 'La date pour laquelle obtenir la météo au format YYYY-MM-DD (optionnel, par défaut aujourd\'hui)', 'nullable': True},
+        'activity_type': {'type': 'string', 'description': 'Type d\'activité/destination: "plage", "ski", "ville", "randonnee", "camping", "festival" (optionnel)', 'nullable': True},
         'api_key': {'type': 'string', 'description': 'Clé API OpenWeatherMap (optionnel si définie dans les variables d\'environnement)', 'nullable': True}
     }
     output_type = "string"
@@ -24,8 +26,14 @@ class WeatherTool(Tool):
         # Utiliser la clé API fournie, sinon celle du .env
         self.api_key = api_key or os.getenv('OPENWEATHER_API_KEY')
         self.base_url = "http://api.openweathermap.org/data/2.5"
+        
+        # Initialiser le client Claude pour les recommandations intelligentes
+        try:
+            self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
+        except:
+            self.claude_client = None
 
-    def forward(self, location: str, date: Optional[str] = None, api_key: Optional[str] = None) -> str:
+    def forward(self, location: str, date: Optional[str] = None, activity_type: Optional[str] = None, api_key: Optional[str] = None) -> str:
         try:
             # Utiliser la clé API fournie ou celle par défaut
             used_api_key = api_key or self.api_key
@@ -62,7 +70,21 @@ class WeatherTool(Tool):
             city_name = geo_data[0]['name']
 
             # Utiliser l'API gratuite
-            return self._get_weather(lat, lon, city_name, country, target_date, used_api_key)
+            weather_data = self._get_weather(lat, lon, city_name, country, target_date, used_api_key)
+            
+            # Ajouter des recommandations intelligentes si Claude est disponible
+            if self.claude_client:
+                # Utiliser le type d'activité fourni ou essayer de le détecter automatiquement
+                detected_activity = activity_type or self._detect_activity_from_location(location)
+                
+                if detected_activity:
+                    recommendation = self._get_intelligent_recommendation(weather_data, detected_activity, location, target_date)
+                    if recommendation:
+                        if not activity_type:  # Si détecté automatiquement, l'indiquer
+                            weather_data += f"\n\n💡 *Activité détectée: {detected_activity}*"
+                        weather_data += f"\n\n{recommendation}"
+            
+            return weather_data
 
         except requests.exceptions.Timeout:
             return "Erreur: Délai d'attente dépassé. Veuillez réessayer."
@@ -186,11 +208,78 @@ class WeatherTool(Tool):
         except KeyError as e:
             return f"Erreur lors du formatage des prévisions: {str(e)}"
 
-
-
     def _wind_direction(self, degrees: float) -> str:
         """Convertit les degrés en direction du vent"""
         directions = ["N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
                      "S", "SSO", "SO", "OSO", "O", "ONO", "NO", "NNO"]
         index = round(degrees / 22.5) % 16
-        return directions[index] 
+        return directions[index]
+
+    def _get_intelligent_recommendation(self, weather_data: str, activity_type: str, location: str, target_date: Optional[datetime]) -> Optional[str]:
+        """Utilise Claude pour générer des recommandations intelligentes basées sur la météo et l'activité"""
+        try:
+            if not self.claude_client:
+                return None
+            
+            date_str = target_date.strftime('%d/%m/%Y') if target_date else "aujourd'hui"
+            
+            prompt = f"""Analysez ces données météorologiques pour {location} le {date_str} et donnez une recommandation pour une activité de type "{activity_type}" :
+
+DONNÉES MÉTÉO :
+{weather_data}
+
+TYPE D'ACTIVITÉ : {activity_type}
+
+Votre tâche :
+1. Analysez si les conditions météo sont adaptées à cette activité
+2. Donnez une recommandation claire : IDÉAL / ACCEPTABLE / DÉCONSEILLÉ / CHANGEZ DE DESTINATION
+3. Proposez des alternatives si nécessaire
+4. Répondez en français, maximum 150 mots
+5. Utilisez un ton pratique et bienveillant
+
+Exemples de logique :
+- Plage + pluie = CHANGEZ DE DESTINATION ou reportez
+- Ski + température > 5°C = DÉCONSEILLÉ
+- Randonnée + orage = CHANGEZ DE DESTINATION
+- Ville + pluie légère = ACCEPTABLE avec parapluie
+- Festival en extérieur + pluie forte = DÉCONSEILLÉ
+
+Format de réponse :
+🎯 **RECOMMANDATION VOYAGE**
+[Votre analyse et conseil]"""
+
+            response = self.claude_client.messages.create(
+                model="claude-3-opus-20240229",
+                max_tokens=200,
+                temperature=0.2,
+                system="Vous êtes un conseiller météo expert. Donnez des recommandations pratiques et claires pour les activités de voyage.",
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            return response.content[0].text.strip()
+            
+        except Exception:
+            return None
+
+    def _detect_activity_from_location(self, location: str) -> Optional[str]:
+        """Détecte automatiquement le type d'activité probable basé sur la localisation"""
+        location_lower = location.lower()
+        
+        # Stations balnéaires et plages
+        beach_keywords = ['nice', 'cannes', 'saint-tropez', 'biarritz', 'deauville', 'miami', 'maldives', 'ibiza', 'mykonos', 'cancun', 'phuket', 'bali']
+        if any(keyword in location_lower for keyword in beach_keywords):
+            return "plage"
+        
+        # Stations de ski
+        ski_keywords = ['chamonix', 'val d\'isère', 'courchevel', 'méribel', 'aspen', 'zermatt', 'st moritz', 'verbier']
+        if any(keyword in location_lower for keyword in ski_keywords):
+            return "ski"
+        
+        # Destinations de randonnée
+        hiking_keywords = ['mont blanc', 'everest', 'kilimanjaro', 'patagonie', 'himalaya', 'alpes', 'pyrénées']
+        if any(keyword in location_lower for keyword in hiking_keywords):
+            return "randonnee"
+        
+        return None