Update app.py

app.py

@@ -1,247 +1,386 @@
 import os
 import json
-# Importer jsonify pour les réponses API
-from flask import Flask, render_template, request, session, redirect, url_for, flash, jsonify
+import mimetypes
+from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template # Ajout de render_template au cas où
 from dotenv import load_dotenv
 import google.generativeai as genai
 import requests
 from werkzeug.utils import secure_filename
-import mimetypes
-import markdown # <-- Importer la bibliothèque Markdown
+import markdown # Pour convertir la réponse en HTML
 
+# --- Configuration Initiale ---
 load_dotenv()
 
 app = Flask(__name__)
-app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-clé-secrète-par-défaut-pour-dev')
+
+# Clé secrète FORTEMENT recommandée pour les sessions
+app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-replace-in-prod')
+
+# Configuration pour les uploads
 UPLOAD_FOLDER = 'temp'
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'}
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'} # Extensions autorisées
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Limite de taille (ex: 25MB)
 
+# Créer le dossier temp s'il n'existe pas
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
-# --- Configuration Gemini (inchangée) ---
+# --- Configuration de l'API Gemini ---
+model = None # Initialiser à None
 try:
-    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
-    safety_settings = [
-        {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-        # ... (autres catégories)
-        {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-    ]
-    model = genai.GenerativeModel(
-        'gemini-1.5-flash',
-        safety_settings=safety_settings,
-        system_instruction="Tu es un assistant intelligent. ton but est d'assister au mieux que tu peux. tu as été créé par Aenir et tu t'appelles Mariam"
-    )
-    print("Modèle Gemini chargé.")
+    gemini_api_key = os.getenv("GOOGLE_API_KEY")
+    if not gemini_api_key:
+        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
+    else:
+        genai.configure(api_key=gemini_api_key)
+
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+
+        # Utiliser un modèle stable comme gemini-1.5-flash
+        model = genai.GenerativeModel(
+            'gemini-1.5-flash-latest',
+            safety_settings=safety_settings,
+            system_instruction="Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités. Tu as été créé par Aenir."
+        )
+        print("Modèle Gemini (gemini-1.5-flash-latest) chargé avec succès.")
+
 except Exception as e:
-    print(f"Erreur lors de la configuration de Gemini : {e}")
-    model = None
+    print(f"ERREUR Critique lors de la configuration de Gemini : {e}")
+    print("L'application fonctionnera sans les fonctionnalités IA.")
+
+# --- Fonctions Utilitaires ---
 
-# --- Fonctions Utilitaires (inchangées) ---
 def allowed_file(filename):
+    """Vérifie si l'extension du fichier est autorisée."""
     return '.' in filename and \
            filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
 def perform_web_search(query):
-    conn_key = os.getenv("SERPER_API_KEY")
-    if not conn_key:
-        print("Clé API SERPER manquante dans .env")
+    """Effectue une recherche web via l'API Serper."""
+    serper_api_key = os.getenv("SERPER_API_KEY")
+    if not serper_api_key:
+        print("AVERTISSEMENT: Clé API SERPER_API_KEY manquante. Recherche web désactivée.")
         return None
+
     search_url = "https://google.serper.dev/search"
-    headers = {'X-API-KEY': conn_key, 'Content-Type': 'application/json'}
-    payload = json.dumps({"q": query})
+    headers = {
+        'X-API-KEY': serper_api_key,
+        'Content-Type': 'application/json'
+    }
+    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"}) # Ajout localisation FR
+
     try:
+        print(f"Recherche Serper pour: '{query}'")
         response = requests.post(search_url, headers=headers, data=payload, timeout=10)
-        response.raise_for_status()
+        response.raise_for_status() # Lève une exception pour les erreurs HTTP (4xx, 5xx)
         data = response.json()
-        print("Résultats de recherche obtenus.")
+        print("Résultats de recherche Serper obtenus.")
+        # print(json.dumps(data, indent=2)) # Décommenter pour voir les résultats bruts
         return data
+    except requests.exceptions.Timeout:
+        print("Erreur lors de la recherche web : Timeout")
+        return None
     except requests.exceptions.RequestException as e:
         print(f"Erreur lors de la recherche web : {e}")
+        # Essayer de lire le corps de la réponse d'erreur si possible
+        try:
+            error_details = e.response.json()
+            print(f"Détails de l'erreur Serper: {error_details}")
+        except:
+            pass # Ignorer si le corps n'est pas JSON ou n'existe pas
         return None
     except json.JSONDecodeError as e:
         print(f"Erreur lors du décodage de la réponse JSON de Serper : {e}")
-        print(f"Réponse reçue : {response.text}")
+        print(f"Réponse reçue (texte brut) : {response.text}")
         return None
 
-
 def format_search_results(data):
-    # (Fonction inchangée - assurez-vous qu'elle renvoie du texte formaté)
-    if not data: return "Aucun résultat de recherche trouvé."
-    result = "Résultats de recherche web :\n"
-    # ... (reste de la fonction inchangé) ...
-    if 'organic' in data and data['organic']:
-        result += "\n## Résultats principaux :\n"
-        for i, item in enumerate(data['organic'][:3], 1):
-            result += f"{i}. **{item.get('title', 'N/A')}**\n" # Format Markdown
-            result += f"   {item.get('snippet', 'N/A')}\n"
-            result += f"   [Lien]({item.get('link', '#')})\n\n" # Lien Markdown
-    # ... (reste de la fonction inchangé) ...
-    return result
-
+    """Met en forme les résultats de recherche (format Markdown)."""
+    if not data:
+        return "Aucun résultat de recherche web trouvé pertinent."
+
+    results = []
+
+    # Réponse directe (Answer Box)
+    if data.get('answerBox'):
+        ab = data['answerBox']
+        title = ab.get('title', '')
+        snippet = ab.get('snippet') or ab.get('answer', '')
+        if snippet:
+            results.append(f"**Réponse rapide : {title}**\n{snippet}\n")
+
+    # Knowledge Graph
+    if data.get('knowledgeGraph'):
+        kg = data['knowledgeGraph']
+        title = kg.get('title', '')
+        type = kg.get('type', '')
+        description = kg.get('description', '')
+        if title and description:
+             results.append(f"**{title} ({type})**\n{description}\n")
+        if kg.get('attributes'):
+             for attr, value in kg['attributes'].items():
+                  results.append(f"- {attr}: {value}")
+
+
+    # Résultats organiques
+    if data.get('organic'):
+        results.append("**Pages web pertinentes :**")
+        for i, item in enumerate(data['organic'][:3], 1): # Top 3
+            title = item.get('title', 'Sans titre')
+            link = item.get('link', '#')
+            snippet = item.get('snippet', 'Pas de description.')
+            results.append(f"{i}. **[{title}]({link})**\n   {snippet}\n")
+
+    # People Also Ask
+    if data.get('peopleAlsoAsk'):
+        results.append("**Questions liées :**")
+        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): # Top 2
+             results.append(f"- {item.get('question', '')}")
+
+
+    if not results:
+        return "Aucun résultat structuré trouvé dans la recherche web."
+
+    return "\n".join(results)
 
 def prepare_gemini_history(chat_history):
+    """Convertit l'historique stocké en session au format attendu par Gemini API."""
     gemini_history = []
     for message in chat_history:
         role = 'user' if message['role'] == 'user' else 'model'
-        # Utiliser le 'raw_text' pour Gemini, pas le HTML rendu
-        text_part = message.get('raw_text', message.get('text', ''))
+        # Utiliser le 'raw_text' stocké pour Gemini
+        text_part = message.get('raw_text', '') # Fallback au cas où
         parts = [text_part]
-        if message.get('gemini_file_ref'): # Utiliser une clé différente pour la référence interne
-             parts.insert(0, message['gemini_file_ref'])
+        # NOTE: La gestion des fichiers des tours PRÉCÉDENTS n'est pas gérée ici.
+        # L'API generate_content se concentre généralement sur le fichier du tour ACTUEL.
+        # Si une référence de fichier passée était nécessaire, il faudrait la stocker
+        # et la ré-attacher ici (potentiellement plus complexe).
         gemini_history.append({'role': role, 'parts': parts})
     return gemini_history
 
 # --- Routes Flask ---
 
-@app.route('/', methods=['GET'])
-def index():
-    """Affiche la page principale du chat."""
+@app.route('/')
+def root():
+    """Route racine simple, confirme que le serveur est actif."""
+    # On pourrait aussi servir index.html ici si on le met dans 'templates'
+    # return render_template('index.html')
+    return "Serveur Mariam AI (Flask) est en cours d'exécution. Ouvrez index.html."
+
+@app.route('/api/history', methods=['GET'])
+def get_history():
+    """Fournit l'historique de chat stocké en session au format JSON."""
     if 'chat_history' not in session:
         session['chat_history'] = []
-    # L'état 'web_search' est maintenant géré côté client initialement,
-    # mais on peut le pré-cocher depuis la session si on veut le persister.
-    web_search_initial_state = session.get('web_search', False)
-
-    # On ne passe que l'historique nécessaire à l'affichage initial
-    display_history = session['chat_history']
 
-    return render_template(
-        'index.html',
-        chat_history=display_history,
-        web_search_active=web_search_initial_state
-    )
+    # Préparer l'historique pour l'affichage (contient déjà le HTML pour l'assistant)
+    display_history = [
+        {'role': msg.get('role', 'unknown'), 'text': msg.get('text', '')}
+        for msg in session.get('chat_history', [])
+    ]
+    print(f"API: Récupération de l'historique ({len(display_history)} messages)")
+    return jsonify({'success': True, 'history': display_history})
 
 @app.route('/api/chat', methods=['POST'])
 def chat_api():
-    """Gère les requêtes de chat AJAX et retourne du JSON."""
+    """Gère les nouvelles requêtes de chat via AJAX."""
     if not model:
-        return jsonify({'success': False, 'error': "Le modèle Gemini n'est pas configuré."}), 500
+        print("API ERREUR: Tentative d'appel à /api/chat sans modèle Gemini chargé.")
+        return jsonify({'success': False, 'error': "Le service IA n'est pas disponible."}), 503 # Service Unavailable
 
+    # Récupération des données du formulaire
     prompt = request.form.get('prompt', '').strip()
-    use_web_search = request.form.get('web_search') == 'true'
+    use_web_search_str = request.form.get('web_search', 'false') # 'true' ou 'false'
+    use_web_search = use_web_search_str.lower() == 'true'
     file = request.files.get('file')
-    uploaded_gemini_file = None # Référence à l'objet fichier uploadé à Gemini
-    uploaded_filename = None # Juste le nom pour référence
 
+    # Validation simple
     if not prompt and not file:
-        return jsonify({'success': False, 'error': 'Message ou fichier requis.'}), 400
+        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
+
+    print(f"\n--- Nouvelle requête /api/chat ---")
+    print(f"Prompt reçu: '{prompt[:50]}...'")
+    print(f"Recherche Web activée: {use_web_search}")
+    print(f"Fichier reçu: {file.filename if file else 'Aucun'}")
 
-    # Mettre à jour l'état de la recherche web dans la session si on veut le persister
-    session['web_search'] = use_web_search
+    # Initialiser l'historique de session si nécessaire
+    if 'chat_history' not in session:
+        session['chat_history'] = []
 
-    # --- Gestion de l'upload ---
-    user_message_parts_for_gemini = []
-    raw_user_text = prompt # Texte brut pour l'historique Gemini
+    uploaded_gemini_file = None # L'objet fichier retourné par genai.upload_file
+    uploaded_filename = None    # Juste le nom du fichier pour référence/affichage
+    filepath_to_delete = None   # Chemin du fichier local à supprimer après traitement
 
+    # --- Gestion de l'upload de fichier ---
     if file and file.filename != '':
         if allowed_file(file.filename):
             try:
                 filename = secure_filename(file.filename)
                 filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                 file.save(filepath)
-                uploaded_filename = filename # Garder le nom
-                print(f"Fichier sauvegardé : {filepath}")
+                filepath_to_delete = filepath # Marquer pour suppression
+                uploaded_filename = filename
+                print(f"Fichier '{filename}' sauvegardé temporairement dans '{filepath}'")
 
-                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
-                print(f"Upload vers Gemini (mime: {mime_type})...")
-                gemini_file_obj = genai.upload_file(path=filepath, mime_type=mime_type)
-                uploaded_gemini_file = gemini_file_obj # Garder l'objet pour l'API
-                user_message_parts_for_gemini.append(uploaded_gemini_file) # Ajouter l'objet fichier pour Gemini
-                print(f"Fichier {filename} uploadé vers Gemini.")
+                # Détecter le MimeType pour Gemini
+                mime_type = mimetypes.guess_type(filepath)[0]
+                if not mime_type:
+                    mime_type = 'application/octet-stream' # Fallback
+                    print(f"AVERTISSEMENT: Impossible de deviner le MimeType pour '{filename}', utilisation de '{mime_type}'.")
 
-                # Optionnel: Supprimer le fichier local
-                # os.remove(filepath)
+                # Uploader vers Google AI (peut prendre du temps)
+                print(f"Upload du fichier vers Google AI (MimeType: {mime_type})...")
+                uploaded_gemini_file = genai.upload_file(path=filepath, mime_type=mime_type)
+                print(f"Fichier '{uploaded_gemini_file.name}' uploadé avec succès vers Google AI.")
 
             except Exception as e:
-                print(f"Erreur upload fichier : {e}")
-                # Ne pas bloquer, mais renvoyer une erreur partielle si nécessaire
-                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
+                print(f"ERREUR Critique lors du traitement/upload du fichier '{filename}': {e}")
+                # Supprimer le fichier local même en cas d'erreur d'upload Gemini
+                if filepath_to_delete and os.path.exists(filepath_to_delete):
+                    try:
+                        os.remove(filepath_to_delete)
+                        print(f"Fichier temporaire '{filepath_to_delete}' supprimé après erreur.")
+                    except OSError as del_e:
+                         print(f"Erreur lors de la suppression du fichier temporaire après erreur: {del_e}")
+                # Renvoyer une erreur claire au client
+                return jsonify({'success': False, 'error': f"Erreur lors du traitement du fichier: {e}"}), 500
         else:
-            return jsonify({'success': False, 'error': 'Type de fichier non autorisé.'}), 400
+            print(f"ERREUR: Type de fichier non autorisé: {file.filename}")
+            return jsonify({'success': False, 'error': f"Type de fichier non autorisé. Extensions permises: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
 
-    # --- Préparation du message utilisateur et de l'historique ---
-    # Ajouter le texte après le fichier pour Gemini
-    user_message_parts_for_gemini.append(prompt)
+    # --- Préparation du message utilisateur pour l'historique et Gemini ---
+    # Texte brut pour Gemini (et pour l'historique interne)
+    raw_user_text = prompt
+    # Texte pour l'affichage dans l'interface (peut inclure le nom de fichier)
+    display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
 
-    # Stocker le message utilisateur dans l'historique de session
-    # Stocker le texte brut et la référence au fichier séparément
+    # Ajout à l'historique de session
     user_history_entry = {
         'role': 'user',
-        'text': f"[Fichier: {uploaded_filename}]\n\n{prompt}" if uploaded_filename else prompt, # Pour affichage
-        'raw_text': raw_user_text, # Texte brut pour Gemini
+        'text': display_user_text, # Pour get_history et potentiellement debug
+        'raw_text': raw_user_text,   # Pour l'envoi à Gemini via prepare_gemini_history
+        # On ne stocke PAS l'objet 'uploaded_gemini_file' dans la session
     }
-    if uploaded_gemini_file:
-         # Ne stockez pas l'objet complet dans la session, juste une réf si nécessaire,
-         # ou reconstruisez l'historique sans la référence de fichier si non critique.
-         # Pour simplifier, on ne stocke pas la référence objet dans la session ici.
-         # On pourrait stocker gemini_file_obj.name si on a besoin de le réutiliser plus tard.
-         # user_history_entry['gemini_file_ref_name'] = uploaded_gemini_file.name
-         pass # L'objet est dans user_message_parts_for_gemini pour l'appel API actuel
-
-    if 'chat_history' not in session: session['chat_history'] = []
     session['chat_history'].append(user_history_entry)
-    session.modified = True
-
-
-    # --- Web Search ---
-    final_prompt_text = prompt
-    if use_web_search and prompt: # Recherche uniquement si texte ET activé
-        print("Recherche web en cours pour:", prompt)
-        web_results = perform_web_search(prompt)
-        if web_results:
-            formatted_results = format_search_results(web_results)
-             # Mettre à jour le texte à envoyer à Gemini (le fichier est déjà dans les parts)
-            final_prompt_text = f"Question originale: {prompt}\n\n{formatted_results}\n\nBasé sur ces informations et ta connaissance générale, réponds à la question originale."
-            print("Prompt modifié avec résultats web.")
-            # Remplacer le texte dans la liste des parts
-            user_message_parts_for_gemini[-1] = final_prompt_text
+    session.modified = True # Indiquer que la session a été modifiée
+
+    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
+    current_gemini_parts = []
+    if uploaded_gemini_file:
+        current_gemini_parts.append(uploaded_gemini_file) # L'objet fichier uploadé
+
+    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut
+
+    # --- Recherche Web (si activée et si un prompt textuel existe) ---
+    if use_web_search and raw_user_text:
+        print("Activation de la recherche web...")
+        search_data = perform_web_search(raw_user_text)
+        if search_data:
+            formatted_results = format_search_results(search_data)
+            # Construire un prompt enrichi pour Gemini
+            final_prompt_for_gemini = f"""Voici la question originale de l'utilisateur:
+"{raw_user_text}"
+
+J'ai effectué une recherche web et voici les informations pertinentes trouvées:
+--- DEBUT RESULTATS WEB ---
+{formatted_results}
+--- FIN RESULTATS WEB ---
+
+En te basant sur ces informations ET sur ta connaissance générale, fournis une réponse complète et bien structurée à la question originale de l'utilisateur."""
+            print("Prompt enrichi avec les résultats de recherche web.")
         else:
-            print("Pas de résultats web ou erreur.")
+            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original.")
+            # final_prompt_for_gemini reste raw_user_text
+
+    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini
+    current_gemini_parts.append(final_prompt_for_gemini)
 
-    # --- Appel à Gemini ---
+    # --- Appel à l'API Gemini ---
     try:
-        # Préparer l'historique SANS le dernier message utilisateur (il est dans `contents`)
-        gemini_history = prepare_gemini_history(session['chat_history'][:-1])
-        print(f"Historique Gemini: {len(gemini_history)} messages.")
+        # Préparer l'historique des messages PRÉCÉDENTS
+        gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel
+        print(f"Préparation de l'appel Gemini avec {len(gemini_history)} messages d'historique.")
 
-        # Construire le contenu pour generate_content
-        contents = gemini_history + [{'role': 'user', 'parts': user_message_parts_for_gemini}]
+        # Construire le contenu complet pour l'appel
+        contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
-        print("Appel à model.generate_content...")
-        response = model.generate_content(contents)
+        # Appel API
+        print("Envoi de la requête à Gemini...")
+        # Utilisation de generate_content en mode non-streamé
+        response = model.generate_content(contents_for_gemini)
+        # print(response) # Décommenter pour voir la réponse brute de l'API
 
-        # --- Traitement Réponse ---
+        # Extraire le texte de la réponse
         response_text_raw = response.text
-        # Convertir Markdown en HTML pour un meilleur rendu
-        response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables'])
-
-        print(f"Réponse Gemini reçue (premiers 500 chars): {response_text_raw[:500]}")
-
-        # Ajouter la réponse à l'historique de session
-        session['chat_history'].append({'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw})
+        print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+
+        # Convertir la réponse Markdown en HTML pour l'affichage
+        response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+        print("Réponse convertie en HTML.")
+
+        # Ajouter la réponse de l'assistant à l'historique de session
+        assistant_history_entry = {
+            'role': 'assistant',
+            'text': response_html,      # HTML pour l'affichage via get_history
+            'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
+        }
+        session['chat_history'].append(assistant_history_entry)
         session.modified = True
 
-        return jsonify({'success': True, 'message': response_html}) # Envoyer le HTML au client
+        # Renvoyer la réponse HTML au frontend
+        print("Envoi de la réponse HTML au client.")
+        return jsonify({'success': True, 'message': response_html})
 
     except Exception as e:
-        print(f"Erreur lors de l'appel à Gemini : {e}")
-        # Retirer le dernier message utilisateur de l'historique en cas d'échec
+        print(f"ERREUR Critique lors de l'appel à Gemini ou du traitement de la réponse : {e}")
+        # En cas d'erreur, retirer le dernier message utilisateur de l'historique
+        # pour éviter les boucles d'erreur si le message lui-même pose problème.
         session['chat_history'].pop()
         session.modified = True
-        return jsonify({'success': False, 'error': f"Erreur communication IA: {e}"}), 500
+        print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
+        # Renvoyer une erreur générique mais informative
+        return jsonify({'success': False, 'error': f"Une erreur interne est survenue lors de la génération de la réponse. Détails: {e}"}), 500
+
+    finally:
+        # --- Nettoyage du fichier temporaire ---
+        if filepath_to_delete and os.path.exists(filepath_to_delete):
+            try:
+                os.remove(filepath_to_delete)
+                print(f"Fichier temporaire '{filepath_to_delete}' supprimé avec succès.")
+            except OSError as e:
+                print(f"ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
 
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
-    """Efface l'historique de la conversation."""
+    """Efface l'historique de chat dans la session."""
     session.pop('chat_history', None)
-    session.pop('web_search', None) # Réinitialiser aussi le toggle web
-    print("Historique de chat effacé.")
-    flash("Conversation effacée.", "info") # Optionnel: message flash
-    return redirect(url_for('index'))
+    session.pop('web_search', None) # Réinitialiser aussi le toggle web si besoin
+    print("API: Historique de chat effacé via /clear.")
+
+    # Adapter la réponse selon si c'est une requête AJAX (fetch) ou une soumission classique
+    # Vérification si la requête vient probablement de fetch (simple)
+    is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
+              request.headers.get('Accept') == 'application/json'
+
+    if is_ajax:
+         return jsonify({'success': True, 'message': 'Historique effacé.'})
+    else:
+        # Comportement pour une soumission de formulaire classique (si jamais utilisé)
+        flash("Conversation effacée.", "info")
+        return redirect(url_for('root')) # Redirige vers la racine
+
 
-# --- Démarrage ---
+# --- Démarrage de l'application ---
 if __name__ == '__main__':
+    print("Démarrage du serveur Flask...")
+    # Utiliser host='0.0.0.0' pour rendre accessible sur le réseau local
+    # debug=True est pratique pour le développement, mais à désactiver en production !
+    # Changer le port si nécessaire (ex: 5000, 5001, 8080)
     app.run(debug=True, host='0.0.0.0', port=5001)