Update app.py

app.py

@@ -1,440 +1,304 @@
-from flask import Flask, render_template, request, jsonify, session
-import google.generativeai as genai
 import os
-from dotenv import load_dotenv
-import http.client
 import json
+from flask import Flask, render_template, request, session, redirect, url_for, flash
+from dotenv import load_dotenv
+import google.generativeai as genai
+import requests # Pour Serper API
 from werkzeug.utils import secure_filename
-import uuid
-from PIL import Image # Required for checking image files if needed, or directly by genai
-import traceback # For detailed error logging
-
-# --- Configuration ---
-load_dotenv() # Charge les variables depuis le fichier .env
+import mimetypes # Pour vérifier le type de fichier
 
-# Check for essential environment variables
-GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
-SERPER_API_KEY = "9b90a274d9e704ff5b21c0367f9ae1161779b573" # Clé pour la recherche web (optionnelle)
-FLASK_SECRET_KEY = os.getenv("FLASK_SECRET_KEY") 
-# Validation critique des clés au démarrage
+load_dotenv()
 
-# Configure Flask App
 app = Flask(__name__)
-app.secret_key = FLASK_SECRET_KEY
-app.config['UPLOAD_FOLDER'] = 'temp_uploads' # Dossier pour les uploads temporaires
-app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # Limite la taille des uploads à 100 Mo
+# Très important pour utiliser les sessions Flask !
+app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-clé-secrète-par-défaut-pour-dev')
+# Configuration pour les uploads
+UPLOAD_FOLDER = 'temp'
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'} # Extensions autorisées
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # Limite de taille (ex: 16MB)
+
+# Créer le dossier temp s'il n'existe pas
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# Configuration de l'API Gemini
+try:
+    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-# Assurer l'existence du dossier d'upload
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+    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"},
+    ]
 
-# Configure Google AI
-try:
-    genai.configure(api_key=GEMINI_API_KEY)
-except Exception as e:
-    raise RuntimeError(f"Échec de la configuration de l'API Google AI: {e}. Vérifiez votre GEMINI_API_KEY.")
-
-
-# Paramètres de Sécurité Gemini (Ajustez si nécessaire)
-safety_settings = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-]
-
-# Configuration de la Génération Gemini
-generation_config = {
-    "temperature": 0.7,
-    "top_p": 0.95,
-    "top_k": 64,
-    "max_output_tokens": 8192,
-    "response_mime_type": "text/plain", # Demande une réponse texte simple
-}
-
-# Prompt Système (Instructions pour l'IA)
-SYSTEM_PROMPT = """
-Vous êtes Mariam, une assistante IA conversationnelle polyvalente conçue par Youssouf.
-Votre objectif est d'aider les utilisateurs de manière informative, créative et engageante.
-Répondez en français. Soyez concise mais complète.
-Si l'utilisateur télécharge des fichiers, prenez-les en compte dans votre réponse si pertinent pour la question posée.
-Si la recherche web est activée et que des résultats sont fournis via le prompt, utilisez-les pour enrichir votre réponse en citant brièvement les points clés trouvés.
-Formattez vos réponses en Markdown lorsque cela améliore la lisibilité (listes, blocs de code, gras, italique, etc.).
-Ne mentionnez pas explicitement les "Résultats de recherche web" dans votre réponse finale à moins que ce ne soit naturel dans le contexte. Intégrez l'information trouvée.
-"""
-
-# Initialisation du Modèle Gemini
-try:
     model = genai.GenerativeModel(
-        model_name="gemini-1.5-flash-latest", # Utilisation de la dernière version flash
+        'gemini-1.5-flash', # Utiliser un modèle stable recommandé si 'gemini-2.0-flash-exp' cause problème
+        # 'gemini-1.5-pro-latest', # Alternative plus puissante
         safety_settings=safety_settings,
-        generation_config=generation_config,
-        system_instruction=SYSTEM_PROMPT
+        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"
+        # Note: 'tools' n'est pas directement utilisé ici comme dans Streamlit,
+        # la logique de recherche web est gérée manuellement.
     )
-    print("Modèle Gemini initialisé avec succès.")
+    print("Modèle Gemini chargé.")
 except Exception as e:
-     raise RuntimeError(f"Échec de l'initialisation du modèle Gemini: {e}")
-
+    print(f"Erreur lors de la configuration de Gemini : {e}")
+    model = None # Empêche l'app de crasher si l'API key est mauvaise
 
-# Stockage en mémoire des sessions de chat (Pour la production, envisagez une solution persistante comme Redis ou une base de données)
-chat_sessions = {}
-
-# Extensions de fichiers autorisées pour l'upload
-ALLOWED_EXTENSIONS = {
-    'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif', 'webp', # Texte et Images
-    'heic', 'heif', # Formats d'image Apple
-    'mp3', 'wav', 'ogg', 'flac', # Audio
-    'mp4', 'mov', 'avi', 'mkv', 'webm' # Vidéo
-}
+# --- Fonctions Utilitaires ---
 
 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
 
-# --- Fonctions Utilitaires ---
-
-def get_chat_session(session_id):
-    """Récupère ou crée une session de chat Gemini pour l'ID de session Flask donné."""
-    if session_id not in chat_sessions:
-        print(f"Création d'une nouvelle session de chat Gemini pour Flask session ID: {session_id}")
-        # L'historique est géré dynamiquement lors de l'envoi des messages
-        chat_sessions[session_id] = model.start_chat(history=[])
-    return chat_sessions[session_id]
-
 def perform_web_search(query):
-    """Effectue une recherche web via l'API Serper.dev."""
-    if not SERPER_API_KEY:
-        print("Recherche web ignorée : SERPER_API_KEY non configurée.")
-        return None # Retourne None si la clé n'est pas dispo
-
-    conn = http.client.HTTPSConnection("google.serper.dev")
-    # Payload pour la recherche en français
-    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"})
+    """Effectue une recherche web via l'API Serper."""
+    conn_key = "9b90a274d9e704ff5b21c0367f9ae1161779b573"
+    if not conn_key:
+        print("Clé API SERPER manquante dans .env")
+        return None
+    search_url = "https://google.serper.dev/search"
     headers = {
-        'X-API-KEY': SERPER_API_KEY,
+        'X-API-KEY': conn_key,
         'Content-Type': 'application/json'
     }
+    payload = json.dumps({"q": query})
     try:
-        print(f"Serper: Envoi de la requête pour '{query}'...")
-        conn.request("POST", "/search", payload, headers)
-        res = conn.getresponse()
-        data_bytes = res.read()
-        data_str = data_bytes.decode("utf-8")
-        print(f"Serper: Réponse reçue - Statut: {res.status}")
-
-        if res.status == 200:
-            print("Serper: Recherche réussie.")
-            return json.loads(data_str)
-        else:
-            print(f"Serper: Erreur API - Statut {res.status}, Réponse: {data_str}")
-            return {"error": f"L'API de recherche a échoué avec le statut {res.status}"}
-    except http.client.HTTPException as http_err:
-        print(f"Erreur HTTP lors de la recherche web: {http_err}")
-        return {"error": f"Erreur de connexion HTTP: {str(http_err)}"}
-    except json.JSONDecodeError as json_err:
-         print(f"Erreur de décodage JSON de la réponse Serper: {json_err}")
-         print(f"Réponse brute reçue: {data_str}")
-         return {"error": "Impossible de lire la réponse de l'API de recherche."}
-    except Exception as e:
-        print(f"Erreur inattendue lors de la recherche web: {e}")
-        traceback.print_exc()
-        return {"error": f"Exception lors de la recherche web: {str(e)}"}
-    finally:
-        conn.close()
-
-def format_search_results_for_prompt(data):
-    """Formate les résultats de recherche de manière concise pour les injecter dans le prompt de l'IA."""
-    if not data or data.get("searchParameters", {}).get("q") is None:
-         # Si data est vide ou ne semble pas être une réponse valide
-        print("Formatage recherche: Données invalides ou vides reçues.")
-        return "La recherche web n'a pas retourné de résultats exploitables."
-    if "error" in data:
-        print(f"Formatage recherche: Erreur détectée dans les données - {data['error']}")
-        return f"Note : La recherche web a rencontré une erreur ({data['error']})."
-
-    results = []
-    query = data.get("searchParameters", {}).get("q", "Terme inconnu")
-    results.append(f"Résultats de recherche web pour '{query}':")
-
-    # Boîte de réponse / Knowledge Graph (si présents)
-    if 'answerBox' in data:
-        ab = data['answerBox']
-        answer = ab.get('answer') or ab.get('snippet') or ab.get('title')
-        if answer:
-             results.append(f"- Réponse directe trouvée : {answer}")
-    elif 'knowledgeGraph' in data:
+        response = requests.post(search_url, headers=headers, data=payload, timeout=10)
+        response.raise_for_status() # Lève une exception pour les codes d'erreur HTTP
+        data = response.json()
+        print("Résultats de recherche obtenus.")
+        return data
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur lors de la recherche web : {e}")
+        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}")
+        return None
+
+def format_search_results(data):
+    """Met en forme les résultats de recherche pour le prompt Gemini."""
+    if not data:
+        return "Aucun résultat de recherche trouvé."
+
+    result = "Résultats de recherche web :\n"
+
+    if 'knowledgeGraph' in data:
         kg = data['knowledgeGraph']
-        description = kg.get('description')
-        if description:
-            results.append(f"- Info (Knowledge Graph) : {kg.get('title', '')} - {description}")
-
-    # Résultats Organiques (naturels)
-    if 'organic' in data and data['organic']:
-        results.append("- Résultats principaux :")
-        for i, item in enumerate(data['organic'][:3], 1): # Limite aux 3 premiers
-            title = item.get('title', 'Sans titre')
-            snippet = item.get('snippet', 'Pas de description')
-            link = item.get('link', '#')
-            results.append(f"  {i}. {title}: {snippet} (Source: {link})")
-    elif not results: # Si ni answerbox/KG ni organic n'ont donné qqch
-        return f"Aucun résultat de recherche web pertinent trouvé pour '{query}'."
+        result += f"\n## Graphe de connaissances :\n"
+        result += f"### {kg.get('title', '')} ({kg.get('type', '')})\n"
+        result += f"{kg.get('description', '')}\n"
+        if 'attributes' in kg:
+            for attr, value in kg['attributes'].items():
+                 result += f"- {attr}: {value}\n"
 
+    if 'answerBox' in data:
+         ab = data['answerBox']
+         result += f"\n## Réponse directe :\n"
+         result += f"{ab.get('title','')}\n{ab.get('snippet') or ab.get('answer','')}\n"
 
-    print(f"Formatage recherche: {len(results)-1} éléments formatés pour le prompt.")
-    return "\n".join(results)
 
+    if 'organic' in data and data['organic']:
+        result += "\n## Résultats principaux :\n"
+        for i, item in enumerate(data['organic'][:3], 1): # Limite aux 3 premiers
+            result += f"{i}. **{item.get('title', 'N/A')}**\n"
+            result += f"   {item.get('snippet', 'N/A')}\n"
+            result += f"   Lien : {item.get('link', '#')}\n\n"
+
+    if 'peopleAlsoAsk' in data and data['peopleAlsoAsk']:
+        result += "## Questions fréquentes :\n"
+        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): # Limite aux 2 premières
+            result += f"{i}. **{item.get('question', 'N/A')}**\n"
+            # result += f"   {item.get('snippet', 'N/A')}\n\n" # Le snippet est souvent redondant
+
+    return result
+
+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'
+        parts = [message['text']]
+        if message.get('gemini_file'): # Ajoute la référence au fichier si présente
+             parts.insert(0, message['gemini_file']) # Met le fichier avant le texte
+        gemini_history.append({'role': role, 'parts': parts})
+    return gemini_history
 
 # --- Routes Flask ---
 
-@app.route('/')
-def home():
-    """Affiche l'interface de chat principale."""
-    # Initialise la session Flask si elle n'existe pas
-    if 'session_id' not in session:
-        session_id = str(uuid.uuid4())
-        session['session_id'] = session_id
-        session['messages'] = [] # Historique pour l'affichage client
-        session['uploaded_files_gemini'] = [] # Stocke les objets File retournés par genai.upload_file
-        session.modified = True # Marque la session comme modifiée
-        print(f"Nouvelle session Flask créée: {session_id}")
-    else:
-        # Assure que les clés nécessaires existent même si la session existe déjà
-        if 'messages' not in session: session['messages'] = []
-        if 'uploaded_files_gemini' not in session: session['uploaded_files_gemini'] = []
-
-
-    # Récupère les messages de la session pour les passer au template
-    messages_for_template = session.get('messages', [])
-    return render_template('index.html', messages=messages_for_template)
-
-@app.route('/send_message', methods=['POST'])
-def send_message():
-    """Gère l'envoi d'un message à l'IA et retourne sa réponse."""
-    # Vérifie si la session utilisateur est valide
-    if 'session_id' not in session:
-        print("Erreur send_message: ID de session manquant.")
-        return jsonify({'error': 'Session expirée ou invalide. Veuillez rafraîchir la page.'}), 400
-
-    session_id = session['session_id']
-    print(f"\n--- Requête /send_message reçue (Session: {session_id}) ---")
+@app.route('/', methods=['GET'])
+def index():
+    """Affiche la page principale du chat."""
+    if 'chat_history' not in session:
+        session['chat_history'] = [] # Initialise l'historique
+    if 'web_search' not in session:
+        session['web_search'] = False # Initialise l'état de la recherche web
+
+    return render_template(
+        'index.html',
+        chat_history=session['chat_history'],
+        web_search_active=session['web_search'],
+        error=session.pop('error', None), # Récupère et supprime l'erreur s'il y en a une
+        processing_message=session.pop('processing', False) # Indicateur de traitement
+    )
 
+@app.route('/chat', methods=['POST'])
+def chat():
+    """Gère la soumission du formulaire de chat."""
+    if not model:
+        session['error'] = "Le modèle Gemini n'a pas pu être chargé. Vérifiez la clé API et la configuration."
+        return redirect(url_for('index'))
+
+    prompt = request.form.get('prompt', '').strip()
+    # Met à jour l'état de la recherche web depuis la checkbox
+    session['web_search'] = 'web_search' in request.form
+    file = request.files.get('file')
+    uploaded_gemini_file = None
+    user_message_content = {'role': 'user', 'text': prompt}
+
+    if not prompt and not file:
+        session['error'] = "Veuillez entrer un message ou uploader un fichier."
+        return redirect(url_for('index'))
+
+    # --- Gestion de l'upload de fichier ---
+    if file and file.filename != '':
+        if allowed_file(file.filename):
+            try:
+                # Sécurise le nom du fichier et détermine le chemin complet
+                filename = secure_filename(file.filename)
+                filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+                file.save(filepath)
+                print(f"Fichier sauvegardé temporairement : {filepath}")
+
+                # Essayer d'uploader vers Gemini
+                print("Upload vers Gemini en cours...")
+                # Détecter le mime type pour l'upload Gemini
+                mime_type = mimetypes.guess_type(filepath)[0]
+                if not mime_type:
+                    # Fallback si la détection échoue
+                     mime_type = 'application/octet-stream'
+                     print(f"Impossible de deviner le mime_type pour {filename}, utilisation de {mime_type}")
+
+                gemini_file_obj = genai.upload_file(path=filepath, mime_type=mime_type)
+                uploaded_gemini_file = gemini_file_obj # Garder l'objet fichier pour l'API
+                user_message_content['gemini_file'] = uploaded_gemini_file # Stocke la référence pour l'historique Gemini
+                user_message_content['text'] = f"[Fichier: {filename}]\n\n{prompt}" # Modifie le texte affiché
+                print(f"Fichier {filename} uploadé avec succès vers Gemini. MimeType: {mime_type}")
+
+                # Optionnel: Supprimer le fichier local après upload vers Gemini
+                # try:
+                #    os.remove(filepath)
+                #    print(f"Fichier temporaire {filepath} supprimé.")
+                # except OSError as e:
+                #    print(f"Erreur lors de la suppression du fichier temporaire {filepath}: {e}")
+
+
+            except Exception as e:
+                print(f"Erreur lors du traitement ou de l'upload du fichier : {e}")
+                session['error'] = f"Erreur lors du traitement du fichier : {e}"
+                # Ne pas bloquer si l'upload échoue, on peut continuer sans le fichier
+                # return redirect(url_for('index')) # Décommentez si l'upload doit être bloquant
+        else:
+            session['error'] = "Type de fichier non autorisé."
+            return redirect(url_for('index'))
+    elif file and file.filename == '':
+         # Si un champ fichier existe mais est vide, on l'ignore simplement
+         pass
+
+    # --- Ajout du message utilisateur à l'historique de session ---
+    if prompt or uploaded_gemini_file: # N'ajoute que s'il y a du contenu
+        # Version simplifiée pour l'affichage HTML (sans l'objet gemini_file)
+        display_history_message = {'role': 'user', 'text': user_message_content['text']}
+        session['chat_history'].append(display_history_message)
+        session.modified = True # Important car on modifie une liste dans la session
+
+    # --- Préparation et Envoi à Gemini ---
     try:
-        data = request.json
-        user_message_text = data.get('message', '').strip()
-        web_search_enabled = data.get('web_search', False)
-
-        # Vérifie si le message est vide (sauf si des fichiers sont attachés)
-        uploaded_files = session.get('uploaded_files_gemini', [])
-        if not user_message_text and not uploaded_files:
-            print("Avertissement send_message: Message vide et aucun fichier attaché.")
-            return jsonify({'error': 'Veuillez entrer un message ou joindre un fichier.'}), 400
-
-        # Récupère ou crée la session de chat Gemini associée
-        chat_gemini = get_chat_session(session_id)
-
-        # --- Préparation du contenu pour Gemini ---
-        prompt_parts = [] # Liste pour contenir texte, fichiers, résultats web
-
-        # 1. Ajouter les fichiers uploadés (depuis la session)
-        #    On utilise directement les objets File retournés par genai.upload_file
-        if uploaded_files:
-            prompt_parts.extend(uploaded_files) # Ajoute les objets File à la liste
-            file_names = [f.display_name for f in uploaded_files] # Noms pour log
-            print(f"Ajout au prompt des fichiers Gemini: {', '.join(file_names)}")
-            # Vider la liste des fichiers après les avoir ajoutés au prompt de CE message
-            # Permet d'associer les fichiers au message en cours uniquement
-            session['uploaded_files_gemini'] = []
-            session.modified = True
-            print("Liste des fichiers uploadés vidée pour le prochain message.")
-
-
-        # 2. Ajouter les résultats de recherche web (si activé et clé API dispo)
-        search_prompt_text = "" # Texte à ajouter au prompt textuel
-        if web_search_enabled and SERPER_API_KEY:
-            print(f"Recherche web activée pour: '{user_message_text}'")
-            web_results_data = perform_web_search(user_message_text)
-            if web_results_data:
-                formatted_results = format_search_results_for_prompt(web_results_data)
-                search_prompt_text = f"\n\n--- Informations issues de la recherche web ---\n{formatted_results}\n--- Fin des informations de recherche ---\n"
-                print("Résultats de recherche formatés ajoutés au contexte.")
-            else:
-                 search_prompt_text = "\n\n(Note: La recherche web a été tentée mais n'a pas retourné de résultats ou a échoué.)\n"
-                 print("Aucun résultat de recherche web ou échec.")
-
-
-        # 3. Ajouter le message texte de l'utilisateur (incluant le contexte de recherche si existant)
-        final_user_text = user_message_text + search_prompt_text
-        prompt_parts.append(final_user_text) # Ajoute le texte (potentiellement enrichi)
-        print(f"Texte final envoyé à Gemini:\n{final_user_text[:500]}...") # Log tronqué
-
-        # --- Envoi à l'API Gemini ---
-        print(f"Envoi de {len(prompt_parts)} partie(s) à l'API Gemini...")
-        ai_response_text = ""
-        try:
-            # Envoie la liste complète des parties (fichiers + texte)
-            response = chat_gemini.send_message(prompt_parts)
-            ai_response_text = response.text # Récupère le texte de la réponse
-            print("Réponse reçue de Gemini.")
-
-            # Vérifier si la réponse a été bloquée par les filtres de sécurité
-            if response.prompt_feedback.block_reason:
-                 block_reason = response.prompt_feedback.block_reason
-                 print(f"AVERTISSEMENT: Réponse bloquée par Gemini. Raison: {block_reason}")
-                 ai_response_text = f"⚠️ Ma réponse a été bloquée en raison des filtres de sécurité (Raison: {block_reason}). Veuillez reformuler votre demande."
-
-        except Exception as e:
-            print(f"ERREUR lors de l'appel à Gemini API: {e}")
-            traceback.print_exc() # Log détaillé de l'erreur serveur
-            # Essaye de donner une erreur plus spécifique si possible
-            error_details = str(e)
-            ai_response_text = f"❌ Désolé, une erreur est survenue lors de la communication avec l'IA. Détails techniques: {error_details}"
-
-
-        # --- Mise à jour de l'historique de session Flask (pour l'affichage) ---
-        # Stocke le message *original* de l'utilisateur et la réponse de l'IA
-        current_messages = session.get('messages', [])
-        # !! Ne pas stocker le prompt enrichi dans l'historique affiché !!
-        current_messages.append({'role': 'user', 'content': user_message_text}) # Message original
-        current_messages.append({'role': 'assistant', 'content': ai_response_text}) # Réponse IA
-        session['messages'] = current_messages
+        # Indiquer qu'un traitement est en cours
+        session['processing'] = True
         session.modified = True
-        print("Historique de session Flask mis à jour.")
 
-        # --- Retourner la réponse de l'IA au client ---
-        print(f"--- Fin Requête /send_message (Session: {session_id}) ---")
-        return jsonify({'response': ai_response_text})
+        # Construire le prompt final (avec recherche web si activée)
+        final_prompt_parts = []
+        if uploaded_gemini_file:
+            final_prompt_parts.append(uploaded_gemini_file)
+
+        current_prompt_text = prompt
+
+        # Effectuer la recherche web si activée ET si un prompt textuel existe
+        if session['web_search'] and prompt:
+             print("Recherche web activée pour le prompt:", prompt)
+             # Afficher l'indicateur de recherche
+             # Note: dans Flask simple, l'indicateur ne sera visible qu'APRES le rechargement.
+             # Pour un affichage dynamique, il faudrait JS/AJAX.
+             # On peut passer une variable au template pour l'afficher avant la réponse.
+             session['processing_web_search'] = True # Indicateur spécifique
+             session.modified = True
+
+             web_results = perform_web_search(prompt)
+             if web_results:
+                 formatted_results = format_search_results(web_results)
+                 current_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 les résultats de recherche.")
+             else:
+                 print("Aucun résultat de recherche web obtenu ou erreur.")
+                 # On continue avec le prompt original
+
+        final_prompt_parts.append(current_prompt_text)
+
+        # Préparer l'historique complet pour Gemini
+        gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le dernier message utilisateur (qui est dans final_prompt_parts)
+
+        print(f"\n--- Envoi à Gemini ---")
+        print(f"Historique envoyé: {len(gemini_history)} messages")
+        print(f"Parties du prompt actuel: {len(final_prompt_parts)}")
+        # print(f"Prompt textuel final: {current_prompt_text[:200]}...") # Afficher début du prompt
+        # print("----------------------\n")
+
+        # Appel à Gemini API
+        # Utiliser generate_content qui prend l'historique + le nouveau message
+        full_conversation = gemini_history + [{'role': 'user', 'parts': final_prompt_parts}]
+        response = model.generate_content(full_conversation)
+
+        # --- Traitement de la réponse ---
+        response_text = response.text
+        print(f"\n--- Réponse de Gemini ---")
+        print(response_text[:500] + ('...' if len(response_text) > 500 else ''))
+        # print("-------------------------\n")
+
+        # Ajout de la réponse à l'historique de session
+        session['chat_history'].append({'role': 'assistant', 'text': response_text})
+        session.modified = True
 
     except Exception as e:
-        print(f"ERREUR Inattendue dans /send_message: {e}")
-        traceback.print_exc()
-        return jsonify({'error': f'Erreur interne du serveur: {str(e)}'}), 500
-
-
-@app.route('/upload', methods=['POST'])
-def upload_file():
-    """Gère l'upload de fichiers, les enregistre temporairement et les prépare pour Gemini."""
-    if 'session_id' not in session:
-        print("Erreur upload: ID de session manquant.")
-        return jsonify({'error': 'Session expirée ou invalide. Veuillez rafraîchir la page.'}), 400
-
-    session_id = session['session_id']
-    print(f"\n--- Requête /upload reçue (Session: {session_id}) ---")
-
-    if 'file' not in request.files:
-        print("Erreur upload: 'file' manquant dans request.files.")
-        return jsonify({'error': 'Aucun fichier trouvé dans la requête.'}), 400
-
-    file = request.files['file']
-    if file.filename == '':
-        print("Erreur upload: Nom de fichier vide.")
-        return jsonify({'error': 'Aucun fichier sélectionné.'}), 400
-
-    if file and allowed_file(file.filename):
-        filename = secure_filename(file.filename)
-        # Crée un chemin de sauvegarde temporaire unique (évite écrasement si même nom)
-        temp_filename = f"{session_id}_{uuid.uuid4().hex}_{filename}"
-        save_path = os.path.join(app.config['UPLOAD_FOLDER'], temp_filename)
-
-        try:
-            print(f"Sauvegarde du fichier '{filename}' vers '{save_path}'...")
-            file.save(save_path)
-            print(f"Fichier sauvegardé localement.")
-
-            # Uploader le fichier vers Google AI Studio (API Gemini)
-            print(f"Upload de '{filename}' vers Google AI Studio...")
-            # display_name est optionnel mais utile pour le débogage ou l'affichage
-            gemini_file_object = genai.upload_file(path=save_path, display_name=filename)
-            print(f"Fichier uploadé vers Gemini. Référence obtenue: {gemini_file_object.name}") # L'objet a un attribut 'name'
-
-            # Stocker l'objet File retourné par Gemini dans la session Flask
-            # C'est cet objet qui sera utilisé directement dans send_message
-            current_uploads = session.get('uploaded_files_gemini', [])
-            current_uploads.append(gemini_file_object)
-            session['uploaded_files_gemini'] = current_uploads
-            session.modified = True
-            print(f"Objet Fichier Gemini ajouté à la session Flask (Total: {len(current_uploads)}).")
-
-            # Supprimer le fichier local temporaire après l'upload réussi vers Gemini
-            try:
-                os.remove(save_path)
-                print(f"Fichier local temporaire '{save_path}' supprimé.")
-            except OSError as e:
-                print(f"AVERTISSEMENT: Échec de la suppression du fichier local '{save_path}': {e}")
-
-            print(f"--- Fin Requête /upload (Session: {session_id}) - Succès ---")
-            return jsonify({'success': True, 'filename': filename}) # Renvoie le nom original pour l'UI
-
-        except Exception as e:
-            print(f"ERREUR lors de l'upload ou du traitement Gemini: {e}")
-            traceback.print_exc()
-            # Nettoyer le fichier local s'il existe encore en cas d'erreur
-            if os.path.exists(save_path):
-                try:
-                    os.remove(save_path)
-                    print(f"Nettoyage: Fichier local '{save_path}' supprimé après erreur.")
-                except OSError as rm_err:
-                    print(f"Erreur lors du nettoyage du fichier '{save_path}': {rm_err}")
-            print(f"--- Fin Requête /upload (Session: {session_id}) - Échec ---")
-            return jsonify({'error': f'Échec de l\'upload ou du traitement du fichier: {str(e)}'}), 500
-    else:
-        print(f"Erreur upload: Type de fichier non autorisé - '{file.filename}'")
-        return jsonify({'error': 'Type de fichier non autorisé.'}), 400
-
-@app.route('/clear_chat', methods=['POST'])
+        print(f"Erreur lors de l'appel à Gemini : {e}")
+        session['error'] = f"Une erreur s'est produite lors de la communication avec l'IA : {e}"
+        # Si une erreur survient, on retire le message utilisateur qui a causé l'erreur
+        # pour éviter de le renvoyer indéfiniment.
+        if session['chat_history'] and session['chat_history'][-1]['role'] == 'user':
+             session['chat_history'].pop()
+             session.modified = True
+
+    finally:
+        # Indiquer que le traitement est terminé
+        session['processing'] = False
+        session.pop('processing_web_search', None) # Nettoyer l'indicateur de recherche
+        session.modified = True
+
+
+    return redirect(url_for('index')) # Redirige vers la page principale pour afficher le nouvel état
+
+@app.route('/clear', methods=['POST'])
 def clear_chat():
-    """Efface l'historique de chat et les fichiers uploadés pour la session en cours."""
-    if 'session_id' not in session:
-        print("Avertissement clear_chat: Pas de session à effacer.")
-        return jsonify({'success': True}) # Pas d'erreur si pas de session
-
-    session_id = session['session_id']
-    print(f"\n--- Requête /clear_chat reçue (Session: {session_id}) ---")
-
-    # 1. Effacer la session de chat Gemini en mémoire (si elle existe)
-    if session_id in chat_sessions:
-        del chat_sessions[session_id]
-        print(f"Session de chat Gemini pour {session_id} effacée de la mémoire.")
-
-    # 2. Effacer les données pertinentes de la session Flask
-    session['messages'] = []
-    files_to_delete = session.get('uploaded_files_gemini', [])
-    session['uploaded_files_gemini'] = []
-    session.modified = True
-    print("Historique des messages et références de fichiers effacés de la session Flask.")
-
-    # 3. (Optionnel mais recommandé) Supprimer les fichiers uploadés correspondants depuis Google AI Studio
-    #    Cela nécessite de stocker les 'name' (IDs) des fichiers Gemini et d'appeler genai.delete_file()
-    #    Pour l'instant, on efface juste la référence dans la session Flask.
-    #    L'API delete_file est importante pour gérer l'espace de stockage Gemini.
-    if files_to_delete:
-         print(f"Tentative de suppression de {len(files_to_delete)} fichier(s) sur Google AI Studio...")
-         for file_obj in files_to_delete:
-             try:
-                 print(f"  Suppression de {file_obj.display_name} (ID: {file_obj.name})...")
-                 genai.delete_file(file_obj.name)
-                 print(f"  Fichier {file_obj.name} supprimé de Google AI.")
-             except Exception as e:
-                 print(f"  ERREUR lors de la suppression du fichier {file_obj.name} de Google AI: {e}")
-                 # Continuer même si un fichier ne peut être supprimé
-
-
-    print(f"--- Fin Requête /clear_chat (Session: {session_id}) ---")
-    return jsonify({'success': True})
-
-
-# --- Démarrage de l'Application ---
+    """Efface l'historique de la conversation."""
+    session.pop('chat_history', None) # Supprime l'historique de la session
+    session.pop('web_search', None)   # Réinitialise aussi le toggle web
+    print("Historique de chat effacé.")
+    return redirect(url_for('index')) # Redirige vers la page d'accueil
+
+# --- Démarrage de l'application ---
 if __name__ == '__main__':
-    # Rappel des dépendances:
-    # pip install Flask python-dotenv google-generativeai Pillow werkzeug requests gunicorn
-    print("\n" + "="*40)
-    print(" Démarrage du serveur Flask Assistant IA ")
-    print("="*40)
-    print("Vérifiez que votre fichier .env contient :")
-    print("  - GEMINI_API_KEY=VOTRE_CLE_GEMINI")
-    print("  - FLASK_SECRET_KEY=VOTRE_CLE_SECRET_FLASK")
-    print("  - SERPER_API_KEY=VOTRE_CLE_SERPER (Optionnel, pour recherche web)")
-    print("-"*40)
-    # Utiliser host='0.0.0.0' pour rendre accessible sur le réseau local
-    # debug=True active le rechargement automatique et le débogueur (NE PAS UTILISER EN PRODUCTION)
-    # Utiliser Gunicorn ou un autre serveur WSGI pour la production
-    app.run(debug=True, host='0.0.0.0', port=5000)
+    # Utiliser host='0.0.0.0' pour rendre l'app accessible sur le réseau local
+    # Debug=True est utile pour le développement, mais à désactiver en production
+    app.run(debug=True, host='0.0.0.0', port=5001)