initial clean push for Hugging Face

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+models/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,13 @@
+# Python virtual environment
+seatech_chatbot/
+*.pyc
+__pycache__/
+*.pyd
+*.whl
+*.zip
+*.env
+
+# Data / cache / models
+models/
+cache/
+database/

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . /app
+
+CMD ["python", "LesChatsDeSeatech.py"]

LesChatsDeSeatech.py

@@ -0,0 +1,1059 @@
+import os
+import re
+import json
+import pickle
+import time
+import uuid
+import vosk
+import io
+import wave
+import logging
+from datetime import datetime
+from flask import Flask, request, render_template, jsonify, send_from_directory, session
+from dotenv import load_dotenv
+load_dotenv() #Charge les données de l'environnement de développement dnas le fichier main.
+
+
+import urllib.request
+import zipfile
+
+model_url = "https://alphacephei.com/vosk/models/vosk-model-small-fr-0.22.zip"
+model_path = "models/vosk-model-small-fr-0.22"
+
+if not os.path.exists(model_path):
+    print("Downloading speech model...")
+    os.makedirs("models", exist_ok=True)
+    urllib.request.urlretrieve(model_url, "model.zip")
+
+    with zipfile.ZipFile("model.zip", 'r') as zip_ref:
+        zip_ref.extractall("models")
+
+    os.remove("model.zip")
+
+# Importations ML et API
+try:
+    import torch
+    import numpy as np
+    import faiss
+    from sentence_transformers import SentenceTransformer
+    from sklearn.metrics.pairwise import cosine_similarity
+    ML_IMPORTS_SUCCESS = True
+except ImportError:
+    ML_IMPORTS_SUCCESS = False
+    
+
+try:
+    from groq import Groq
+    GROQ_IMPORT_SUCCESS = True
+except ImportError:
+    GROQ_IMPORT_SUCCESS = False
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("seatech_chatbot")
+
+# Répertoires et fichiers
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+USER_DB_DIR = os.path.join(BASE_DIR, "database", "user_database")
+CACHE_DIR = os.path.join(BASE_DIR, "cache")
+for directory in [DATA_DIR, USER_DB_DIR, CACHE_DIR]:
+    os.makedirs(directory, exist_ok=True)
+EMBEDDINGS_CACHE = os.path.join(CACHE_DIR, "chunk_embeddings.pkl")
+CHUNKS_CACHE = os.path.join(CACHE_DIR, "chunks_with_sources.pkl")
+QA_STORAGE = os.path.join(CACHE_DIR, "user_qa_memory.json")
+
+# ===== CONFIGURATION =====
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+
+LLM_MODEL = "llama-3.3-70b-versatile"
+CONFIDENCE_THRESHOLD = 0.93
+
+# Acronymes utilisés
+ACRONYMS = {
+    "SN": "Systèmes Numériques",
+    "MTX": "Matériaux",
+    "APP": "Apprentissage",
+    "FISE": "Formation Initiale Sous Statut d'Étudiant",
+    "FISA": "Formation Initiale Sous Statut d'Apprenti",
+    "UTLN": "Université de Toulon"
+}
+
+# Mapping des profils avec leurs descriptions et mots-clés de priorisation
+profile_mapping = {
+    "Étudiant": {
+        "description": "Fournis des informations utiles aux étudiants actuels de SeaTech : cours, emplois du temps, projets, vie associative, stages.",
+        "keywords": ["cours", "emploi du temps", "projet", "stage", "vie associative", "examen", "planning", "td", "tp", "association", "événement étudiant", "logement", "bourse"],
+        "priority_topics": ["cours", "planning", "examens", "stages", "projets"]
+    },
+    "Enseignant": {
+        "description": "Fournis des informations utiles aux enseignants de SeaTech : ressources pédagogiques, contacts administratifs, organisation des cours.",
+        "keywords": ["ressources pédagogiques", "contact administratif", "organisation", "enseignement", "programme", "évaluation", "moodle", "scolarité", "administration"],
+        "priority_topics": ["ressources", "administration", "organisation", "programmes"]
+    },
+    "Candidat": {
+        "description": "Fournis des informations utiles aux candidats intéressés par SeaTech : admissions, concours, dossiers, procédures, spécialités disponibles.",
+        "keywords": ["admission", "concours", "dossier", "procédure", "candidature", "inscription", "formation", "spécialité", "parcours", "prérequis", "sélection"],
+        "priority_topics": ["admissions", "formations", "candidature", "spécialités"]
+    },
+    "Alumni": {
+        "description": "Fournis des informations utiles aux anciens étudiants de SeaTech : réseau alumni, partenariats, événements, relations entreprises.",
+        "keywords": ["alumni", "réseau", "partenariat", "entreprise", "carrière", "emploi", "contact professionnel", "événement alumni", "relation entreprise"],
+        "priority_topics": ["réseau", "carrière", "partenariats", "emploi"]
+    }
+}
+
+# Pour l'exemple, nous définissons CONTACTS vide (à compléter selon vos besoins)
+CONTACTS = {}
+
+# ===== INITIALISATION DES CLIENTS =====
+if GROQ_IMPORT_SUCCESS:
+    try:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+        logger.info("Client GROQ initialisé")
+    except Exception as e:
+        logger.error(f"Erreur initialisation client GROQ: {e}")
+        groq_client = None
+else:
+    groq_client = None
+    logger.warning("GROQ non disponible - vérifiez l'installation")
+
+if ML_IMPORTS_SUCCESS:
+    try:
+        device = "cuda" if torch.cuda.is_available() else "cpu" 
+        #embedding_model = SentenceTransformer('intfloat/e5-large-v2', device='cpu')
+        embedding_model = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')
+        embedding_model.max_seq_length = 256  # Réduire la longueur max
+        logger.info(f"Modèle d'embedding chargé sur {device}")
+    except Exception as e:
+        logger.error(f"Erreur chargement modèle d'embedding: {e}")
+        embedding_model = None
+else:
+    embedding_model = None
+    logger.warning("Bibliothèques ML non disponibles")
+
+
+def handle_role_selection(session_id, selected_role=None):
+    """Gère la sélection de rôle utilisateur et initialise la conversation."""
+    if session_id not in conversation_history_global:
+        conversation_history_global[session_id] = []
+    
+    # Si un rôle est sélectionné, l'enregistrer dans la session
+    if selected_role and selected_role in profile_mapping:
+        if 'user_profile' not in session:
+            session['user_profile'] = {}
+        session['user_profile']['role'] = selected_role
+        session['user_profile']['confirmed'] = True
+        
+        # Message de bienvenue personnalisé selon le rôle
+        role_config = profile_mapping[selected_role]
+        welcome_message = f"""
+        <p>Parfait ! Je vais adapter mes réponses pour un profil <strong>{selected_role}</strong>.</p>
+        <p>{role_config['description']}</p>
+        <p>Vous pouvez maintenant me poser vos questions sur SeaTech !</p>
+        """
+        
+        conversation_history_global[session_id].append({
+            "role": "assistant",
+            "content": welcome_message,
+            "is_system_message": True
+        })
+        
+        return selected_role
+    
+    return None
+# ===== FONCTIONS UTILITAIRES =====
+def detect_user_role(query, conversation_history=None):
+    """
+    Détecte automatiquement le rôle de l'utilisateur basé sur sa question et l'historique.
+    Retourne le rôle détecté et un score de confiance.
+    """
+    query_lower = query.lower()
+    role_scores = {}
+    
+    # Analyse basée sur les mots-clés
+    for role, config in profile_mapping.items():
+        score = 0
+        keywords = config["keywords"]
+        
+        # Score basé sur la présence de mots-clés
+        for keyword in keywords:
+            if keyword in query_lower:
+                score += 2
+        
+        # Score basé sur les sujets prioritaires (poids plus élevé)
+        for priority in config["priority_topics"]:
+            if priority in query_lower:
+                score += 3
+                
+        role_scores[role] = score
+    
+    # Analyse de l'historique de conversation si disponible
+    if conversation_history:
+        for entry in conversation_history[-3:]:  # Dernières 3 interactions
+            if entry['role'] == 'user':
+                content_lower = entry['content'].lower()
+                for role, config in profile_mapping.items():
+                    for keyword in config["keywords"]:
+                        if keyword in content_lower:
+                            role_scores[role] += 1
+    
+    # Détection de phrases spécifiques
+    role_patterns = {
+        "Candidat": [r"comment (postuler|candidater|s'inscrire)", r"quelles sont les conditions", r"admission", r"je veux intégrer"],
+        "Étudiant": [r"mes cours", r"mon emploi du temps", r"quand est l'examen", r"projet de fin d'étude"],
+        "Enseignant": [r"ressources pour", r"contact administration", r"organisation des cours"],
+        "Alumni": [r"réseau", r"ancien élève", r"après diplôme", r"carrière"]
+    }
+    
+    for role, patterns in role_patterns.items():
+        for pattern in patterns:
+            if re.search(pattern, query_lower):
+                role_scores[role] += 4
+    
+    # Retourner le rôle avec le score le plus élevé
+    if role_scores:
+        best_role = max(role_scores, key=role_scores.get)
+        confidence = role_scores[best_role]
+        
+        # Si aucun score significatif, retourner "Candidat" par défaut (plus général)
+        if confidence == 0:
+            return "Candidat", 0.1
+        
+        return best_role, min(confidence / 10, 1.0)  # Normaliser entre 0 et 1
+    
+    return "Candidat", 0.1
+
+def filter_chunks_by_role(chunks_results, detected_role, role_confidence):
+    """
+    Filtre et réordonne les chunks en fonction du rôle détecté de l'utilisateur.
+    """
+    if role_confidence < 0.3:  # Si la confiance est faible, ne pas filtrer
+        return chunks_results
+    
+    role_config = profile_mapping.get(detected_role, profile_mapping["Candidat"])
+    keywords = role_config["keywords"]
+    priority_topics = role_config["priority_topics"]
+    
+    filtered_results = []
+    
+    for chunk_text, source, original_score in chunks_results:
+        chunk_lower = chunk_text.lower()
+        role_relevance_score = 0
+        
+        # Score basé sur les mots-clés du rôle
+        for keyword in keywords:
+            if keyword in chunk_lower:
+                role_relevance_score += 0.1
+        
+        # Score bonus pour les sujets prioritaires
+        for priority in priority_topics:
+            if priority in chunk_lower:
+                role_relevance_score += 0.2
+        
+        # Score combiné (original + pertinence rôle)
+        combined_score = original_score + (role_relevance_score * role_confidence)
+        
+        filtered_results.append((chunk_text, source, combined_score, role_relevance_score))
+    
+    # Trier par score combiné
+    filtered_results = sorted(filtered_results, key=lambda x: x[2], reverse=True)
+    
+    # Reconvertir au format original en gardant le score combiné
+    return [(text, source, combined_score) for text, source, combined_score, _ in filtered_results]
+
+def expand_acronyms_in_query(query):
+    """Étend les acronymes dans la requête avec une meilleure détection."""
+    expanded_query = query
+    for acronym, expansion in ACRONYMS.items():
+        # Détection plus précise avec une expression régulière
+        pattern = r'\b' + re.escape(acronym) + r'\b'
+        if re.search(pattern, query, re.IGNORECASE):
+            expanded_query = re.sub(pattern, f"{acronym} ({expansion})", expanded_query, flags=re.IGNORECASE)
+            logger.info(f"Acronyme détecté et étendu: {acronym} -> {expansion}")
+    
+    # Si des acronymes ont été étendus, on ajoute une note
+    if expanded_query != query:
+        expanded_query += " " + " ".join([expansion for acronym, expansion in ACRONYMS.items() 
+                                         if re.search(r'\b' + re.escape(acronym) + r'\b', query, re.IGNORECASE)])
+    
+    return expanded_query
+
+def convert_markdown_to_html(text):
+    """
+    Conversion améliorée du Markdown vers HTML avec prise en charge de plus de formats.
+    """
+    # Gestion des titres (#, ##, etc.)
+    def replace_heading(match):
+        hashes = match.group(1)
+        level = len(hashes)
+        title = match.group(2).strip()
+        return f"<h{level}>{title}</h{level}>"
+    
+    text = re.sub(r'^(#{1,6})\s+(.*)$', replace_heading, text, flags=re.MULTILINE)
+    
+    # Conversion des formats gras et italique
+    text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', text)
+    text = re.sub(r'\*(.*?)\*', r'<em>\1</em>', text)
+    text = re.sub(r'__(.*?)__', r'<strong>\1</strong>', text)  # Alternative pour le gras
+    text = re.sub(r'_(.*?)_', r'<em>\1</em>', text)  # Alternative pour l'italique
+    
+    # Gestion des liens [texte](url)
+    text = re.sub(r'\[(.*?)\]\((.*?)\)', r'<a href="\2" target="_blank">\1</a>', text)
+    
+    # Traitement des listes à puces et numérotées
+    lines = text.splitlines()
+    html_lines = []
+    in_ul = False
+    in_ol = False
+    
+    for line in lines:
+        # Liste à puces
+        if line.strip().startswith("* ") or line.strip().startswith("- "):
+            if not in_ul:
+                if in_ol:
+                    html_lines.append("</ol>")
+                    in_ol = False
+                html_lines.append("<ul>")
+                in_ul = True
+            content = re.sub(r'^\s*[\*\-]\s+(.*)', r'\1', line)
+            html_lines.append(f"<li>{content}</li>")
+        
+        # Liste numérotée
+        elif re.match(r'^\s*\d+\.\s+', line):
+            if not in_ol:
+                if in_ul:
+                    html_lines.append("</ul>")
+                    in_ul = False
+                html_lines.append("<ol>")
+                in_ol = True
+            content = re.sub(r'^\s*\d+\.\s+(.*)', r'\1', line)
+            html_lines.append(f"<li>{content}</li>")
+        
+        # Ligne normale
+        else:
+            if in_ul:
+                html_lines.append("</ul>")
+                in_ul = False
+            if in_ol:
+                html_lines.append("</ol>")
+                in_ol = False
+            html_lines.append(line)
+    
+    # Fermer les listes si nécessaire
+    if in_ul:
+        html_lines.append("</ul>")
+    if in_ol:
+        html_lines.append("</ol>")
+    
+    text = "\n".join(html_lines)
+    
+    # Découpage en paragraphes pour les blocs de texte non déjà formatés
+    paragraphs = []
+    for block in re.split(r'\n\s*\n', text):
+        block = block.strip()
+        # Vérifier si le bloc contient déjà des balises HTML
+        if not re.match(r'^<\/?(h\d|ul|ol|li|blockquote|pre|table)', block):
+            if block:  # Ne pas ajouter de paragraphe vide
+                block = f"<p>{block}</p>"
+        paragraphs.append(block)
+    
+    return "\n".join(paragraphs)
+
+def generate_basic_answer(query, context, found_info):
+    """Fallback basique en l'absence du client GROQ."""
+    answer = "<p>Désolé, le service de génération de réponse n'est pas disponible actuellement. Veuillez réessayer plus tard ou contacter l'administrateur.</p>"
+    return answer
+
+# ===== GESTION DES DONNÉES =====
+def create_default_data():
+    """Crée des fichiers de données par défaut si DATA_DIR est vide."""
+    if not os.listdir(DATA_DIR):
+        # Création d'un fichier d'acronymes
+        with open(os.path.join(DATA_DIR, "acronymes.txt"), "w", encoding="utf-8") as f:
+            f.write("# Acronymes utilisés à SeaTech\n\n")
+            for acronym, meaning in ACRONYMS.items():
+                f.write(f"{acronym}: {meaning}\n")
+        # Fichier de contacts (seulement si CONTACTS est renseigné)
+        with open(os.path.join(DATA_DIR, "contacts.txt"), "w", encoding="utf-8") as f:
+            f.write("# Contacts importants à SeaTech\n\n")
+            if CONTACTS:
+                for name, info in CONTACTS.items():
+                    f.write(f"{name}: {info.get('role', 'N/A')} - {info.get('email', 'N/A')}\n")
+            else:
+                f.write("Aucun contact défini.\n")
+        # Fichier d'information générale
+        with open(os.path.join(DATA_DIR, "info_generale.json"), "w", encoding="utf-8") as f:
+            f.write("# SeaTech - École d'ingénieurs\n\n")
+            f.write("SeaTech est une école d'ingénieurs de l'Université de Toulon (UTLN). ")
+            f.write("Elle propose plusieurs formations d'ingénieur dont les spécialités SN (Systèmes Numériques) ")
+            f.write("et MTX (Matériaux). Les formations peuvent être suivies en statut étudiant (FISE) ou en apprentissage (FISA).\n")
+
+def load_data():
+    """Charge les fichiers dans DATA_DIR et découpe le contenu en chunks avec timestamp de dernière modification."""
+    create_default_data()
+    chunks_with_sources = []
+    valid_extensions = ['.txt', '.md', '.html', '.csv','.json']
+    
+    # Charger un cache des timestamps si disponible
+    timestamp_cache_path = os.path.join(CACHE_DIR, "file_timestamps.json")
+    file_timestamps = {}
+    reload_all = False
+    
+    if os.path.exists(timestamp_cache_path):
+        try:
+            with open(timestamp_cache_path, "r", encoding="utf-8") as f:
+                file_timestamps = json.load(f)
+        except Exception as e:
+            logger.error(f"Erreur chargement cache timestamps: {e}")
+            reload_all = True
+    
+    # Vérifier et charger les fichiers
+    for filename in os.listdir(DATA_DIR):
+        file_path = os.path.join(DATA_DIR, filename)
+        if os.path.isfile(file_path) and any(filename.endswith(ext) for ext in valid_extensions):
+            # Vérifier si le fichier a été modifié
+            mtime = os.path.getmtime(file_path)
+            
+            if reload_all or filename not in file_timestamps or file_timestamps[filename] < mtime:
+                try:
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                    # Découpage en chunks selon les paragraphes
+                    raw_chunks = [chunk.strip() for chunk in re.split(r"\n\s*\n", content) if chunk.strip()]
+                    for chunk in raw_chunks:
+                        chunks_with_sources.append((chunk, filename))
+                    logger.info(f"Fichier {filename} chargé : {len(raw_chunks)} chunks")
+                    file_timestamps[filename] = mtime
+                except Exception as e:
+                    logger.error(f"Erreur chargement {filename}: {e}")
+    
+    # Sauvegarder les timestamps mis à jour
+    try:
+        with open(timestamp_cache_path, "w", encoding="utf-8") as f:
+            json.dump(file_timestamps, f)
+    except Exception as e:
+        logger.error(f"Erreur sauvegarde cache timestamps: {e}")
+    
+    return chunks_with_sources
+
+def compute_embeddings(chunks_with_sources):
+    """Calcule ou charge les embeddings pour les chunks."""
+    if not embedding_model:
+        logger.warning("Modèle d'embedding non disponible")
+        dummy_embeddings = np.zeros((len(chunks_with_sources), 384))
+        return dummy_embeddings, chunks_with_sources
+    if os.path.exists(EMBEDDINGS_CACHE) and os.path.exists(CHUNKS_CACHE):
+        try:
+            with open(EMBEDDINGS_CACHE, "rb") as f:
+                cached_embeddings = pickle.load(f)
+            with open(CHUNKS_CACHE, "rb") as f:
+                cached_chunks = pickle.load(f)
+            if len(cached_embeddings) == len(cached_chunks):
+                logger.info(f"Cache chargé : {len(cached_embeddings)} embeddings")
+                return cached_embeddings, cached_chunks
+        except Exception as e:
+            logger.error(f"Erreur chargement cache: {e}")
+    try:
+        chunk_texts = [chunk[0] for chunk in chunks_with_sources]
+        embeddings = embedding_model.encode(chunk_texts, batch_size=8, convert_to_tensor=True)
+        chunk_embeddings = embeddings.cpu().numpy() if torch.is_tensor(embeddings) else np.array(embeddings)
+        with open(EMBEDDINGS_CACHE, "wb") as f:
+            pickle.dump(chunk_embeddings, f)
+        with open(CHUNKS_CACHE, "wb") as f:
+            pickle.dump(chunks_with_sources, f)
+        logger.info(f"Embeddings calculés et sauvegardés : {len(chunk_embeddings)}")
+        return chunk_embeddings, chunks_with_sources
+    except Exception as e:
+        logger.error(f"Erreur calcul embeddings: {e}")
+        dummy_embeddings = np.zeros((len(chunks_with_sources), 384))
+        return dummy_embeddings, chunks_with_sources
+
+# ===== INDEXATION AVEC FAISS =====
+def setup_search_index(embeddings):
+    """
+    Configure l'index FAISS.
+    Utilise IndexIVFFlat pour un grand nombre d'embeddings, sinon IndexFlatL2.
+    """
+    if not ML_IMPORTS_SUCCESS or embeddings.size == 0:
+        logger.warning("Index de recherche non disponible")
+        return None, False
+    try:
+        d = embeddings.shape[1]
+        if embeddings.shape[0] > 1000:
+            quantizer = faiss.IndexFlatL2(d)
+            index = faiss.IndexIVFFlat(quantizer, d, 100, faiss.METRIC_L2)
+            index.train(embeddings)
+            index.add(embeddings)
+            logger.info(f"Index FAISS IVFFlat créé avec {index.ntotal} vecteurs")
+            return index, True
+        else:
+            index = faiss.IndexFlatL2(d)
+            index.add(embeddings)
+            logger.info(f"Index FAISS FlatL2 créé avec {index.ntotal} vecteurs")
+            return index, True
+    except Exception as e:
+        logger.error(f"Erreur initialisation index: {e}")
+        return None, False
+
+def search_similar_chunks_with_confirmed_role(query, index, is_faiss, embeddings, chunks_data, conversation_history=None, confirmed_role=None, top_n=5):
+    """Recherche avec rôle confirmé par l'utilisateur."""
+    
+    # Recherche de base (identique à l'ancienne fonction)
+    if not embedding_model or not index:
+        results = keyword_search(query, chunks_data, top_n)
+    else:
+        try:
+            query_expanded = expand_acronyms_in_query(query)
+            query_embedding = embedding_model.encode(query_expanded, convert_to_tensor=False)
+            query_embedding = np.array(query_embedding, dtype=np.float32).reshape(1, -1)
+            
+            if is_faiss:
+                distances, indices = index.search(query_embedding, min(top_n * 2, len(chunks_data)))
+                distances, indices = distances[0], indices[0]
+                results = []
+                for i, idx in enumerate(indices):
+                    if 0 <= idx < len(chunks_data):
+                        score = 1 / (1 + distances[i])
+                        results.append((chunks_data[idx][0], chunks_data[idx][1], score))
+            else:
+                similarities = cosine_similarity(query_embedding, embeddings)[0]
+                top_indices = np.argsort(similarities)[-top_n*2:][::-1]
+                results = [(chunks_data[idx][0], chunks_data[idx][1], similarities[idx])
+                           for idx in top_indices if similarities[idx] > 0.1]
+            
+            results = sorted(results, key=lambda x: x[2], reverse=True)[:top_n*2]
+        except Exception as e:
+            logger.error(f"Erreur de recherche: {e}")
+            results = keyword_search(query, chunks_data, top_n)
+    
+    # Utiliser le rôle confirmé ou détecter automatiquement
+    if confirmed_role:
+        detected_role = confirmed_role
+        role_confidence = 1.0  # Confiance maximale car confirmé par l'utilisateur
+    else:
+        detected_role, role_confidence = detect_user_role(query, conversation_history)
+    
+    # Filtrer et réorganiser les résultats selon le rôle
+    filtered_results = filter_chunks_by_role(results, detected_role, role_confidence)
+    
+    return filtered_results[:top_n], detected_role, role_confidence
+# 3. Fonction pour vérifier si l'utilisateur a confirmé son rôle
+def is_role_confirmed(session_id):
+    """Vérifie si l'utilisateur a confirmé son rôle."""
+    user_profile = session.get('user_profile', {})
+    return user_profile.get('confirmed', False)
+
+def get_confirmed_role(session_id):
+    """Récupère le rôle confirmé de l'utilisateur."""
+    user_profile = session.get('user_profile', {})
+    return user_profile.get('role', None)
+def keyword_search(query, chunks_data, top_n=5):
+    """Recherche par mots-clés en fallback."""
+    query_terms = query.lower().split()
+    results = []
+    # Recherche d'acronymes
+    for acronym in ACRONYMS:
+        if acronym.lower() in query.lower():
+            for chunk, source in chunks_data:
+                if acronym in chunk:
+                    results.append((chunk, source, 0.85))
+    for chunk, source in chunks_data:
+        score = sum(0.1 for term in query_terms if term in chunk.lower())
+        if score > 0:
+            results.append((chunk, source, score))
+    if not results:
+        results.append(("Aucune information spécifique trouvée.", "fallback.txt", 0.1))
+    return sorted(results, key=lambda x: x[2], reverse=True)[:top_n]
+
+# ===== FORMATAGE DES SOURCES ET LOGS =====
+def format_sources(results, for_freddy=False, detected_role=None):
+    """Formate les résultats en HTML pour l'affichage des sources."""
+    html = '<div class="sources-container">'
+    
+    if detected_role:
+        role_info = profile_mapping.get(detected_role, {})
+        html += f'<div class="role-detection-info"><strong>Profil détecté:</strong> {detected_role}</div>'
+    
+    for text, source, score in results:
+        relevance_class = "high-relevance" if score > 0.8 else "medium-relevance" if score > 0.6 else "low-relevance"
+        if for_freddy:
+            preview = text[:200] + ("..." if len(text) > 200 else "")
+            html += f'''
+            <div class="freddy-source-block" onclick="this.classList.toggle('expanded')">
+                <div class="freddy-source-header">
+                    <span class="source-name">{source}</span>
+                    <span class="{relevance_class}">{score:.2f}</span>
+                </div>
+                <div class="freddy-source-content">{preview}</div>
+            </div>
+            '''
+        else:
+            html += f'''
+            <div class="source-block">
+                <div class="source-header">
+                    <span class="source-name">{source}</span>
+                    <span class="relevance-score">{score:.2f}</span>
+                </div>
+                <div class="source-content">{text}</div>
+            </div>
+            '''
+    html += '</div>'
+    return html
+
+def create_freddy_logs(query, results, detected_role=None, role_confidence=None):
+    """Crée des logs HTML détaillés pour le module Freddy."""
+    current_time = datetime.now().strftime("%H:%M:%S")
+    high_relevance = sum(1 for _, _, score in results if score > 0.8)
+    medium_relevance = sum(1 for _, _, score in results if 0.6 < score <= 0.8)
+    low_relevance = sum(1 for _, _, score in results if score <= 0.6)
+    
+    html = f'''
+    <div class="freddy-logs">
+        <div class="freddy-log-entry">
+            <span class="log-time">{current_time}</span>
+            <span class="log-action">Analyse de la question</span>
+        </div>
+        <div class="freddy-log-entry">
+            <span class="log-detail">Recherche pour : <strong>"{query}"</strong></span>
+        </div>
+    '''
+    
+    if detected_role and role_confidence:
+        html += f'''
+        <div class="freddy-log-entry">
+            <span class="log-time">{current_time}</span>
+            <span class="log-action">Détection de profil</span>
+        </div>
+        <div class="freddy-log-entry">
+            <span class="log-detail">Profil détecté : <strong>{detected_role}</strong> (confiance: {role_confidence:.2f})</span>
+        </div>
+        '''
+    
+    html += f'''
+        <div class="freddy-log-entry">
+            <span class="log-time">{current_time}</span>
+            <span class="log-action">Résultats filtrés par profil</span>
+        </div>
+        <div class="freddy-log-entry">
+            <span class="log-detail">Détails : 
+                <span class="high-relevance">{high_relevance} très pertinents</span>, 
+                <span class="medium-relevance">{medium_relevance} pertinents</span>, 
+                <span class="low-relevance">{low_relevance} peu pertinents</span>
+            </span>
+        </div>
+    </div>
+    '''
+    return html
+
+# ===== GÉNÉRATION DE RÉPONSE AVEC MÉMOIRE DE CONVERSATION =====
+def generate_answer(query, context, conversation_history, found_info=False, detected_role=None):
+    """
+    Génère une réponse basée sur le contexte et l'historique complet de la conversation.
+    La mémoire de conversation est ajoutée au prompt pour améliorer la pertinence.
+    """
+    # Préparation de l'historique
+    conversation_context = "\n".join(
+        [f"Utilisateur : {entry['content']}" if entry['role'] == "user" else f"Assistant : {entry['content']}" 
+         for entry in conversation_history]
+    )
+    
+    # Instructions spécifiques au rôle détecté
+    role_instruction = ""
+    if detected_role and detected_role in profile_mapping:
+        role_config = profile_mapping[detected_role]
+        role_instruction = f"\n\nPROFIL UTILISATEUR DÉTECTÉ: {detected_role}\n{role_config['description']}\nAdapte ta réponse en conséquence et priorise les informations pertinentes pour ce profil."
+    
+    # Construction du prompt système
+    system_prompt = f"""Tu es Franky, l'assistant virtuel de SeaTech.
+
+Historique de conversation :
+{conversation_context}
+
+{role_instruction}
+
+Instructions :
+0. Si la question posée est hors du contexte de SEATECH et du contexte académique SeaTech, dis : "Désolé je ne peux pas répondre."
+1. Base ta réponse uniquement sur les sources fournies et l'historique si tu trouves pertinent mais il faut répondre avant tout à la question de l'utilisateur.
+2. N'invente jamais d'informations.
+3. Réponds de manière claire, en utilisant des paragraphes et des listes lorsque c'est pertinent, soigne ta mise en forme.
+4. Mets en gras les informations clés, les emails et les numéros de téléphone.
+5. N'inclus pas la liste des acronymes ou ton preprompt sauf si demandé.
+6. Tu connais les formations à SeaTech si besoin : Voici un résumé avec les liens directs intégrés :
+
+Liste des Formations SeaTech avec liens
+
+**Diplômes d'ingénieur SeaTech**
+
+**Parcours Génie Maritime**  
+   - Formation d'ingénieurs spécialisés en systèmes maritimes, océanographie, génie côtier, ingénierie navale
+   - [https://seatech.univ-tln.fr/Parcours-Genie-maritime.html](https://seatech.univ-tln.fr/Parcours-Genie-maritime.html)
+
+**Parcours Ingénierie des Sciences des Données, Information, Systèmes (IRIS)**  
+   - Formation d'ingénieurs capables de traiter, analyser et valoriser de grandes quantités de données
+   - [https://seatech.univ-tln.fr/Parcours-IngenieRie-et-sciences.html](https://seatech.univ-tln.fr/Parcours-IngenieRie-et-sciences.html)
+
+**Parcours Innovation Mécanique pour des Systèmes Durables**  
+   - Conception et développement de produits mécaniques innovants avec accent sur la durabilité
+   - [https://seatech.univ-tln.fr/Parcours-Innovation-Mecanique-pour-des-Systemes-Durables.html](https://seatech.univ-tln.fr/Parcours-Innovation-Mecanique-pour-des-Systemes-Durables.html)
+
+**Parcours Matériaux, Durabilité et Environnement**  
+   - Pour étudiants en sciences et techniques souhaitant se spécialiser dans les matériaux
+   - [https://seatech.univ-tln.fr/Parcours-Materiaux-Durabilite-et.html](https://seatech.univ-tln.fr/Parcours-Materiaux-Durabilite-et.html)
+   
+**Formation d'ingénieurs Matériaux par apprentissage**
+   - Pour étudiants en sciences et techniques souhaitant se spécialiser dans les matériaux
+   - Admission sur dossier avec contrat d'apprentissage
+   - **RNCP : 39062 - Certificateur : Université de Toulon**
+   - [https://seatech.univ-tln.fr/Formation-d-ingenieurs-Materiaux-par-apprentissage.html](https://seatech.univ-tln.fr/Formation-d-ingenieurs-Materiaux-par-apprentissage.html)
+
+**Parcours Modélisation et Calculs Fluides et Structures**  
+   - Simulation numérique et modélisation des comportements physiques
+   - [https://seatech.univ-tln.fr/Parcours-Modelisation-et-Calculs.html](https://seatech.univ-tln.fr/Parcours-Modelisation-et-Calculs.html)
+
+**Parcours Systèmes Mécatroniques et Robotiques**  
+   - Conception et développement de systèmes intégrant mécanique, électronique et informatique
+   - [https://seatech.univ-tln.fr/Parcours-Systemes-mecatroniques-et.html](https://seatech.univ-tln.fr/Parcours-Systemes-mecatroniques-et.html)
+
+**Formation d'ingénieurs en Systèmes Numériques par apprentissage**  
+   - Pour étudiants en sciences et techniques
+   - Admission sur dossier avec contrat d'apprentissage
+   - **RNCP : 37901 - Certificateur : Université de Toulon**
+   - [https://seatech.univ-tln.fr/Formation-d-ingenieurs-en-systemes-numeriques-par-apprentissage.html](https://seatech.univ-tln.fr/Formation-d-ingenieurs-en-systemes-numeriques-par-apprentissage.html)
+
+**Informations générales**
+
+- **Formations complètes** : [https://seatech.univ-tln.fr/Formations.html](https://seatech.univ-tln.fr/Formations.html)
+- **Déroulement des études** : [https://seatech.univ-tln.fr/Deroulement-des-etudes.html](https://seatech.univ-tln.fr/Deroulement-des-etudes.html)
+- **Admissions** : [https://seatech.univ-tln.fr/admission.html](https://seatech.univ-tln.fr/admission.html)
+- **Doubles diplômes** : [https://seatech.univ-tln.fr/doubles-diplomes.html](https://seatech.univ-tln.fr/doubles-diplomes.html)
+- **Page d'accueil** : [https://seatech.univ-tln.fr/](https://seatech.univ-tln.fr/)
+
+Données d'aide pour répondre :
+{context}
+"""
+    try:
+        if groq_client:
+            response = groq_client.chat.completions.create(
+                model=LLM_MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": query}
+                ],
+                temperature=0.95,
+                max_tokens=28500,
+                # Ajout d'un timeout pour éviter les attentes trop longues
+                timeout=40
+            )
+            answer = response.choices[0].message.content
+            answer = convert_markdown_to_html(answer)
+            # Détection d'hallucinations simples
+            if any(x in answer.lower() for x in ["@freddy", "freddy@"]):
+                logger.warning("Hallucination détectée - correction appliquée")
+                answer = "<p>⚠️ Je ne peux pas inventer de contacts inexistants.</p>"
+            return answer
+        else:
+            # Amélioration du message de fallback
+            return "<p>Désolé, le service de génération de réponse n'est pas disponible actuellement. Veuillez réessayer plus tard ou contacter l'administrateur.</p>"
+    except Exception as e:
+        logger.error(f"Erreur génération réponse: {e}")
+        # Message d'erreur plus informatif
+        error_message = "<p>Désolé, une erreur est survenue lors de la génération de la réponse. Détails techniques:</p>"
+        error_message += f"<p><code>{str(e)[:100]}...</code></p>"
+        error_message += "<p>Veuillez réessayer avec une question différente ou plus tard.</p>"
+        return error_message
+
+# ===== INITIALISATION DES DONNÉES =====
+chunks_with_sources = load_data()
+chunk_embeddings, chunks_with_sources = compute_embeddings(chunks_with_sources)
+search_index, use_faiss = setup_search_index(chunk_embeddings)
+
+# ===== APPLICATION FLASK =====
+app = Flask(__name__)
+app.secret_key = 'seatech_chat_secret_key'
+conversation_history_global = {}
+# ajout Daly
+
+# Charger modèle Vosk une seule fois au démarrage
+# vosk_model = vosk.Model("models/vosk-model-fr-0.6-linto-2.2.0") 
+vosk_model = vosk.Model("models/vosk-model-small-fr-0.22")
+
+#fin ajout
+
+@app.route("/", methods=["GET", "POST"])
+def index():
+    """Page d'accueil du chatbot avec gestion de la sélection de rôle."""
+    if 'session_id' not in session:
+        session['session_id'] = str(uuid.uuid4())
+    session_id = session['session_id']
+    
+    if session_id not in conversation_history_global:
+        conversation_history_global[session_id] = []
+    
+    # Gérer la sélection de rôle si fournie
+    selected_role = request.form.get("role_selection") if request.method == "POST" else None
+    if selected_role:
+        handle_role_selection(session_id, selected_role)
+    
+    if request.method == "POST":
+        user_query = request.form.get("query", "").strip()
+        if user_query:
+            # Vérifier si le rôle est confirmé
+            if not is_role_confirmed(session_id):
+                # Rediriger vers la sélection de rôle
+                error_message = {
+                    "role": "assistant",
+                    "content": "<p>Veuillez d'abord sélectionner votre profil ci-dessus pour que je puisse mieux vous aider.</p>",
+                    "is_system_message": True
+                }
+                conversation_history_global[session_id].append(error_message)
+            else:
+                conversation_history_global[session_id].append({"role": "user", "content": user_query})
+                start_time = time.time()
+                
+                confirmed_role = get_confirmed_role(session_id)
+                
+                # Recherche avec rôle confirmé
+                results, detected_role, role_confidence = search_similar_chunks_with_confirmed_role(
+                    user_query, search_index, use_faiss, chunk_embeddings, chunks_with_sources, 
+                    conversation_history_global[session_id], confirmed_role
+                )
+                
+                # Contexte des chunks trouvés
+                context_chunks = "\n\n".join([text for text, _, _ in results])
+                found_info = any(score > CONFIDENCE_THRESHOLD for _, _, score in results)
+                
+                # Génération de réponse avec le rôle confirmé
+                answer = generate_answer(user_query, context_chunks, conversation_history_global[session_id], found_info, detected_role)
+                processing_time = time.time() - start_time
+                
+                # Formatage des sources avec information de rôle
+                sources_html = format_sources(results, detected_role=detected_role)
+                freddy_html = create_freddy_logs(user_query, results, detected_role, role_confidence) + format_sources(results, for_freddy=True, detected_role=detected_role)
+                
+                conversation_history_global[session_id].append({
+                    "role": "assistant", 
+                    "content": answer,
+                    "sources": sources_html,
+                    "freddy_logs": freddy_html,
+                    "processing_time": f"{processing_time:.2f}s",
+                    "detected_role": detected_role,
+                    "role_confidence": role_confidence
+                })
+    
+    conv = conversation_history_global.get(session_id, [])
+    current_datetime = datetime.now()
+    user_profile = session.get('user_profile', {})
+    
+    return render_template("index.html", 
+                         conversation=conv, 
+                         query="", 
+                         current_datetime=current_datetime,
+                         user_profile=user_profile,
+                         profile_mapping=profile_mapping)
+
+
+@app.route("/api/ask", methods=["POST"])
+def api_ask():
+    """Endpoint API pour la recherche avec gestion de rôle."""
+    start_time = time.time()
+    try:
+        data = request.get_json()
+        user_query = data.get("query", "").strip()
+        role_selection = data.get("role_selection", None)
+        
+        # AJOUT  Daly
+        if data.get("mode") == "conversation":
+            prompt = "Réponds de façon brève, 1 à 2 phrases maximum, pour être lue à voix haute."
+        else:
+            prompt = "Réponse normale"
+        #  Fin ajout
+        
+        if not user_query and not role_selection:
+            return jsonify({"error": "Question vide"}), 400
+        
+        # Gestion de la session
+        if 'session_id' not in session:
+            session['session_id'] = str(uuid.uuid4())
+        session_id = session['session_id']
+        if session_id not in conversation_history_global:
+            conversation_history_global[session_id] = []
+        
+        # Gérer la sélection de rôle
+        if role_selection:
+            handle_role_selection(session_id, role_selection)
+            return jsonify({
+                "response": f"<p>Rôle <strong>{role_selection}</strong> sélectionné avec succès ! Vous pouvez maintenant poser vos questions.</p>",
+                "role_confirmed": True,
+                "selected_role": role_selection,
+                "status": "role_selected"
+            })
+        
+        # Vérifier si le rôle est confirmé
+        if not is_role_confirmed(session_id):
+            return jsonify({
+                "response": "<p>Veuillez d'abord sélectionner votre profil pour que je puisse mieux vous aider.</p>",
+                "role_confirmed": False,
+                "status": "role_required"
+            })
+            
+        # Ajout à l'historique de conversation
+        conversation_history_global[session_id].append({"role": "user", "content": user_query})
+        
+        confirmed_role = get_confirmed_role(session_id)
+        
+        # Recherche d'informations avec rôle confirmé
+        try:
+            results, detected_role, role_confidence = search_similar_chunks_with_confirmed_role(
+                user_query, search_index, use_faiss, chunk_embeddings, chunks_with_sources,
+                conversation_history_global[session_id], confirmed_role
+            )
+            context_chunks = "\n\n".join([text for text, _, _ in results])
+            found_info = any(score > CONFIDENCE_THRESHOLD for _, _, score in results)
+        except Exception as search_error:
+            logger.error(f"Erreur de recherche: {search_error}")
+            results = [("Une erreur s'est produite lors de la recherche.", "error.txt", 0.1)]
+            context_chunks = "Informations non disponibles en raison d'une erreur."
+            found_info = False
+            detected_role = confirmed_role or "Candidat"
+            role_confidence = 1.0 if confirmed_role else 0.1
+        
+        # Génération de réponse avec le rôle confirmé
+        answer = generate_answer(user_query, context_chunks, conversation_history_global[session_id], found_info, detected_role)
+        
+        # Formatage des sources et logs avec information de rôle
+        sources_html = format_sources(results, detected_role=detected_role)
+        freddy_html = create_freddy_logs(user_query, results, detected_role, role_confidence) + format_sources(results, for_freddy=True, detected_role=detected_role)
+        
+        # Calcul du temps de traitement
+        processing_time = time.time() - start_time
+        
+        # Mise à jour de l'historique de conversation
+        conversation_history_global[session_id].append({
+            "role": "assistant", 
+            "content": answer,
+            "sources": sources_html,
+            "freddy_logs": freddy_html,
+            "processing_time": f"{processing_time:.2f}s",
+            "detected_role": detected_role,
+            "role_confidence": role_confidence
+        })
+        
+        # Réponse de l'API
+        return jsonify({
+            "response": answer,
+            "freddy_logs": freddy_html,
+            "sources": sources_html,
+            "sources_found": found_info,
+            "processing_time": f"{processing_time:.2f}s",
+            "detected_role": detected_role,
+            "confirmed_role": confirmed_role,
+            "role_confidence": f"{role_confidence:.2f}",
+            "role_confirmed": True,
+            "status": "success"
+        })
+        
+    except Exception as e:
+        logger.error(f"Erreur API globale: {e}")
+        processing_time = time.time() - start_time
+        
+        return jsonify({
+            "response": f"<p>Désolé, une erreur s'est produite: {str(e)[:50]}...</p><p>Veuillez réessayer.</p>",
+            "freddy_logs": f"<div class='freddy-logs'><div class='freddy-log-entry'><span class='log-action'>Erreur</span><span class='log-detail'>{str(e)[:100]}...</span></div></div>",
+            "sources_found": False,
+            "processing_time": f"{processing_time:.2f}s",
+            "detected_role": "Candidat",
+            "role_confidence": "0.00",
+            "status": "error",
+            "error_type": str(type(e).__name__)
+        }), 500
+
+@app.route("/api/role-info", methods=["GET"])
+def api_role_info():
+    """Endpoint pour récupérer les informations sur les rôles disponibles."""
+    return jsonify({
+        "roles": {role: config["description"] for role, config in profile_mapping.items()},
+        "status": "success"
+    })
+@app.route("/api/reset-role", methods=["POST"])
+def api_reset_role():
+    """Permet de réinitialiser le rôle sélectionné."""
+    if 'user_profile' in session:
+        session.pop('user_profile')
+    
+    if 'session_id' in session:
+        session_id = session['session_id']
+        if session_id in conversation_history_global:
+            conversation_history_global[session_id] = []
+    
+    return jsonify({
+        "response": "<p>Rôle réinitialisé. Veuillez sélectionner votre nouveau profil.</p>",
+        "role_confirmed": False,
+        "status": "role_reset"
+    })
+@app.route('/static/<path:path>')
+def send_static(path):
+    """Fournit les fichiers statiques."""
+    return send_from_directory('static', path)
+
+@app.route('/api/ask-audio', methods=['POST'])
+def ask_audio():
+    if 'audio' not in request.files:
+        return jsonify({"error": "Aucun fichier audio reçu"}), 400
+
+    audio_file = request.files['audio']
+    wf = wave.open(io.BytesIO(audio_file.read()), "rb")
+
+    if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getframerate() not in [8000, 16000]:
+        return jsonify({"error": "Format audio non supporté. Utilise WAV PCM mono 16kHz."}), 400
+
+    rec = vosk.KaldiRecognizer(vosk_model, wf.getframerate())
+    text = ""
+
+    while True:
+        data = wf.readframes(4000)
+        if len(data) == 0:
+            break
+        if rec.AcceptWaveform(data):
+            res = json.loads(rec.Result())
+            text += " " + res.get("text", "")
+
+    final_res = json.loads(rec.FinalResult())
+    text += " " + final_res.get("text", "")
+
+    text = text.strip()
+    if not text:
+        return jsonify({"response": "Désolé, je n’ai pas compris l’audio."})
+
+    # Réutiliser ton pipeline existant
+    session_id = request.cookies.get("session_id", "default")
+    search_results, freddy_logs = search_similar_chunks_with_confirmed_role(text, session_id)
+    answer, sources, processing_time = generate_answer(text, search_results, session_id, user_profile)
+
+    return jsonify({
+        "response": answer,
+        "sources": sources,
+        "freddy_logs": freddy_logs,
+        "processing_time": processing_time,
+        "query": text
+    })
+
+if __name__ == "__main__":
+    # Création des répertoires statiques si nécessaires
+    if not os.path.exists("static"):
+        os.makedirs("static", exist_ok=True)
+        os.makedirs("static/css", exist_ok=True)
+        os.makedirs("static/img", exist_ok=True)
+    templates_dir = os.path.join(BASE_DIR, "templates")
+    os.makedirs(templates_dir, exist_ok=True)
+    
+    # IMPORTANT : Récupérer le port depuis les variables d'environnement
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)  # debug=False en production
+
+
+
+    
+    # Charger modèle Vosk une fois au démarrage
+#vosk_model = vosk.Model("model-fr")
+

README.md

@@ -0,0 +1,11 @@
+---
+title: Les Chats De SeaTech
+emoji: 🦀
+colorFrom: red
+colorTo: purple
+sdk: docker
+pinned: false
+short_description: Chatbot-Seatech
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

data/acronymes.txt

@@ -0,0 +1,35 @@
+=== Acronymes SeaTech ===
+
+SN     : Systèmes Numériques
+APP    : Apprentissage
+FISE   : Formation Initiale Sous Statut d'Étudiant
+FISA   : Formation Initiale Sous Statut d'Apprenti
+MTX    : Matériaux
+GM     : Génie Maritime
+MI     : Mécanique et Innovation
+IR     : Informatique et Réseaux
+MS     : Modélisation et Simulation
+MR     : Mécatronique et Robotique
+MAPIEM : Matériaux Polymères-Interfaces-Environnement Marin
+IMATH  : Institut de Mathématiques de Toulon
+LSIS   : Laboratoire des Sciences de l’Information et des Systèmes
+MIO    : Institut Méditerranéen d’Océanographie
+CTI    : Commission des Titres d’Ingénieur
+CFA    : Centre de Formation d’Apprentis
+UTLN   : Université de Toulon
+
+=== Formations et Parcours SeaTech ===
+
+- Diplôme SeaTech (formation d’ingénieur généraliste avec 6 parcours)
+- Diplôme SeaTech spécialité Matériaux (en apprentissage)
+- Diplôme SeaTech spécialité Systèmes numériques (en apprentissage ou formation continue)
+
+Parcours de formation proposés :
+• Génie Maritime
+• Ingénierie et Sciences des Données, Information, Systèmes (IRIS)
+• Innovation Mécanique pour des Systèmes Durables
+• Matériaux, Durabilité et Environnement
+• Modélisation et Calculs Fluides-Structures (MOCA)
+• Systèmes Mécatroniques et Robotiques (SYSMER)
+
+Ce fichier est basé sur la base de données SeaTech disponible (​:contentReference[oaicite:0]{index=0}) et vise à aider le chatbot à comprendre et à associer les acronymes ainsi que les formations et parcours proposés par SeaTech.

data/contacts.txt

@@ -0,0 +1,79 @@
+=== Contacts SeaTech - Informations Complètes ===
+
+1. Contact Général de SeaTech
+--------------------------------
+École d’Ingénieurs SeaTech - Université de Toulon  
+Adresse      : Avenue de l’Université, 83130 LA GARDE, France  
+Téléphone    : 04 94 14 26 40  
+Email        : info.seatech@univ-tln.fr  
+Site Web     : https://seatech.univ-tln.fr/  
+(Source général – :contentReference[oaicite:0]{index=0})
+
+2. Pôle Relations École/Entreprises
+--------------------------------------
+- Email général : ecole-entreprise@seatech.fr  
+- Responsable du pôle :  
+  • Nom   : Christiane Morlet  
+  • Email : christiane.morlet@univ-tln.fr  
+- Secrétariat :  
+  • Nom   : Sabine Ségal  
+  • Email : sabine.segal@univ-tln.fr  
+(Source – :contentReference[oaicite:1]{index=1})
+
+3. Contacts Formation et Responsables Pédagogiques
+-----------------------------------------------------
+A. Formation d’ingénieurs en systèmes numériques par apprentissage  
+   - Responsable de la formation apprentissage :  
+     • Nom   : Nadège THIRION-MOREAU  
+     • Email : nadege.thirion-moreau@univ-tln.fr  
+   - Assistante de la formation :  
+     • Nom   : Laura CHARPENTIER  
+     • Téléphone : 04 83 16 66 60 (du lundi au vendredi de 08h00 à 12h00 et de 14h00 à 17h00)  
+     • Email : laura.charpentier@univ-tln.fr  
+(Source – :contentReference[oaicite:2]{index=2})
+   
+B. Formation d’ingénieurs en matériaux par apprentissage  
+   (Les informations spécifiques pour cette formation ne sont pas explicitement détaillées dans la base, à compléter selon les mises à jour disponibles sur le site officiel.)
+
+C. Autres formations et responsables  
+   - Pour les formations en mode classique (diplôme SeaTech généraliste et spécialités), les coordonnées de contact se font via le formulaire en ligne et le standard de l’école :  
+     • Email : info.seatech@univ-tln.fr  
+     • Téléphone : 04 94 14 26 40  
+   - Les responsables pédagogiques et secrétaires des formations sont généralement accessibles via la plateforme eCandidat ou par le biais du secrétariat administratif central de SeaTech.
+   (Pour plus de précisions, consulter la rubrique « Formation d’ingénieurs » sur le site officiel de SeaTech.)
+
+4. Pôle Career Center – Offres de Stage et d’Emploi
+------------------------------------------------------
+- Plateforme en partenariat avec JobTeaser :  
+  https://univ-tln.jobteaser.com/fr/recruiter_account/sign_in  
+- Contact général pour les offres : info.seatech@univ-tln.fr  
+(Source – :contentReference[oaicite:3]{index=3})
+
+5. Réseau des Anciens (Alumni)
+--------------------------------
+- Association Alumni SeaTech  
+  • Présidente : Marine FLORES  
+    - Email : association@alumni-seatech.fr  
+  • Liens :  
+    - Facebook : https://www.facebook.com/SeaTech.alumni  
+    - LinkedIn : https://www.linkedin.com/company/seatech-alumni/  
+(Source – :contentReference[oaicite:4]{index=4})
+
+6. Contacts pour les Événements et Séminaires
+------------------------------------------------
+- Directrice des Études (pour les séminaires et événements académiques) :  
+  • Nom   : Lyudmyla YUSHCHENKO  
+  • Téléphone : 04 83 16 66 06  
+  • Email : lyudmyla.yushchenko@univ-tln.fr  
+(Source – :contentReference[oaicite:5]{index=5})
+
+7. Autres Contacts Spécifiques et Informations Complémentaires
+----------------------------------------------------------------
+- Pour les questions relatives à la Semaine du Développement Soutenable :  
+  • Contact : Audrey Minghelli  
+    - Email : audrey.minghelli@univ-tln.fr  
+- Pour déposer une offre de stage ou d’emploi, utiliser le formulaire en ligne accessible via le Career Center.  
+- Pour toutes autres demandes, veuillez utiliser le formulaire de contact disponible sur le site officiel.
+(Source – :contentReference[oaicite:6]{index=6})
+
+=== Fin des Contacts SeaTech ===

data/info_generale.txt

@@ -0,0 +1,58 @@
+=== SeaTech - Informations Générales Complètes ===
+
+I. Présentation Générale
+SeaTech est une école d'ingénieurs rattachée à l'Université de Toulon, implantée sur le littoral méditerranéen en région Sud Provence-Alpes-Côte d'Azur. Reconnue pour son excellence académique, son approche pluridisciplinaire et sa forte implication dans l'innovation, SeaTech prépare ses étudiants aux défis technologiques et environnementaux actuels et futurs.
+
+II. Historique et Évolution
+Créée pour répondre aux besoins croissants en ingénierie maritime et technologique, SeaTech s’est imposée comme une référence régionale et nationale dans la formation d’ingénieurs :
+- **Origines et Création** : Fondée [insérer année de création], l'école a débuté avec une vocation d’excellence pour former des ingénieurs aptes à innover dans le secteur maritime.
+- **Intégration et Développement** : Intégrée à l'Université de Toulon, SeaTech a progressivement élargi son offre pédagogique, en développant des partenariats avec des laboratoires de recherche et des entreprises innovantes.
+- **Jalons Historiques** : 
+   • Lancement des premiers diplômes d’ingénieur.  
+   • Évolution vers une approche intégrée mêlant théorie, pratique et recherche.  
+   • Mise en place de programmes d’échanges internationaux et de partenariats stratégiques.
+
+III. Formations et Parcours Proposés
+SeaTech offre plusieurs diplômes d'ingénieur adaptés aux exigences du marché :
+- **Diplôme SeaTech Généraliste** : Une formation d’ingénieur articulée autour de six parcours spécialisés.
+- **Spécialités** :
+   • **Systèmes Numériques (SN)**  
+   • **Matériaux (MTX)**  
+   • **Génie Maritime (GM)**  
+   • **Mécanique et Innovation (MI)**  
+   • **Informatique et Réseaux (IR)**  
+   • Autres parcours complémentaires en fonction des besoins industriels.
+- **Modalités d'Admission** :
+   • **Concours Commun INP (CCINP)** pour les étudiants issus des classes préparatoires.
+   • **Admissions sur titres** pour les candidats issus d’études universitaires.
+   • **Formations en apprentissage** avec des statuts spécifiques (FISE pour étudiants et FISA pour apprentis).
+
+IV. Infrastructure et Environnement
+Le campus de SeaTech se distingue par :
+- Des installations modernes et des laboratoires de pointe, favorisant la recherche appliquée.
+- Un environnement d'apprentissage dynamique et un cadre de vie étudiante propice à l'innovation.
+- Un accès direct aux ressources technologiques et industrielles de la région.
+
+V. Partenariats et Rayonnement International
+SeaTech entretient des collaborations étroites avec :
+- Des entreprises locales et internationales qui facilitent l’insertion professionnelle des diplômés.
+- Des laboratoires de recherche et institutions académiques, contribuant à des projets innovants.
+- Des programmes d’échanges et des doubles diplômes, renforçant son rayonnement à l’international.
+
+VI. Mission et Vision
+La mission de SeaTech est de former des ingénieurs compétents, innovants et responsables, capables de relever les défis du futur. L'école s'engage à promouvoir une approche interdisciplinaire, mêlant recherche appliquée, enseignement théorique et expérience pratique, afin de garantir une insertion professionnelle réussie.
+
+VII. Coordonnées et Informations de Contact
+- **Site officiel**      : https://seatech.univ-tln.fr/
+- **Adresse**            : École d'ingénieurs SeaTech, Avenue de l'Université, CS 60584, 83041 Toulon Cedex 9, France.
+- **Téléphone**          : 04 94 14 26 40
+- **Email**              : info.seatech@univ-tln.fr
+- **Réseaux Sociaux**    : [Ajouter les liens officiels vers les pages Facebook, Twitter, LinkedIn, etc.]
+
+VIII. Ressources et Liens Utiles
+- Brochures et présentations téléchargeables.
+- Informations sur les modalités d’admission et les concours.
+- Actualités, événements et journées portes ouvertes.
+- Plateformes d'échanges et partenariats internationaux.
+
+=== Fin des Informations Générales Complètes ===

static/css/style.css

@@ -0,0 +1,1276 @@
+/* Variables de couleurs SeaTech */
+:root {
+    --primary-color: #1E3A6E;
+    --primary-hover: #2c4d8c;
+    --secondary-color: #1CA0E1;
+    --secondary-hover: #35b5f5;
+    --accent-color: #FF9800;
+    --accent-hover: #ffad33;
+    --text-color: #333333;
+    --text-light: #666666;
+    --background-color: #f5f7fa;
+    --card-bg: #FFFFFF;
+    --hover-color: #F0F4F8;
+    --border-color: #E1E7EF;
+    --shadow-color: rgba(0, 0, 0, 0.08);
+    --shadow-hover: rgba(0, 0, 0, 0.15);
+    --freddy-bg: #FFF8E1;
+    --freddy-border: #FFE0B2;
+    --high-relevance: #4CAF50;
+    --medium-relevance: #2196F3;
+    --low-relevance: #9E9E9E;
+    
+    /* Transitions */
+    --transition-fast: 0.2s ease;
+    --transition-normal: 0.3s ease;
+    --transition-slow: 0.5s ease;
+    
+    /* Animations */
+    --scale-hover: scale(1.02);
+    --translate-up: translateY(-3px);
+}
+
+/* RESET ET BASE */
+*, *::before, *::after {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    background-color: var(--background-color);
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+    -webkit-font-smoothing: antialiased;
+}
+
+/* LAYOUT PRINCIPAL */
+.main-container {
+    display: grid;
+    grid-template-columns: 250px 1fr 300px;
+    gap: 1.5rem;
+    padding: 1rem;
+    width: 100%;
+    flex: 1;
+}
+
+/* COMPOSANTS COMMUNS - CARDS */
+.card {
+    background-color: var(--card-bg);
+    border-radius: 16px;
+    box-shadow: 0 4px 12px var(--shadow-color);
+    transition: transform var(--transition-normal), box-shadow var(--transition-normal);
+}
+
+.card:hover {
+    box-shadow: 0 6px 18px var(--shadow-hover);
+}
+
+/* SIDEBAR */
+.sidebar {
+    background-color: var(--card-bg);
+    border-radius: 16px;
+    padding: 1.5rem;
+    box-shadow: 0 4px 12px var(--shadow-color);
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+    height: fit-content;
+    position: sticky;
+    top: 1rem;
+    transition: transform var(--transition-normal), box-shadow var(--transition-normal);
+}
+
+.sidebar:hover {
+    box-shadow: 0 6px 18px var(--shadow-hover);
+}
+
+.sidebar-header {
+    text-align: center;
+    padding-bottom: 1rem;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sidebar h2 {
+    color: var(--primary-color);
+    font-size: 1.3rem;
+    margin-bottom: 1rem;
+}
+
+.cats-logo {
+    display: flex;
+    justify-content: center;
+    gap: 1rem;
+}
+
+.cat-avatar {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    border: 3px solid var(--secondary-color);
+    transition: transform var(--transition-fast);
+    cursor: pointer;
+}
+
+.cat-avatar:hover {
+    transform: scale(1.1) rotate(5deg);
+    border-color: var(--secondary-hover);
+}
+
+.sidebar-section h3 {
+    color: var(--secondary-color);
+    font-size: 1.1rem;
+    margin-bottom: 0.8rem;
+    position: relative;
+    padding-left: 1.3rem;
+    transition: color var(--transition-fast);
+}
+
+.sidebar-section:hover h3 {
+    color: var(--secondary-hover);
+}
+
+.sidebar-section h3::before {
+    content: "🐾";
+    position: absolute;
+    left: 0;
+    top: 0;
+    font-size: 0.9rem;
+}
+
+.sidebar ul {
+    list-style: none;
+    padding-left: 1.2rem;
+}
+
+.sidebar li {
+    margin-bottom: 0.7rem;
+    position: relative;
+}
+
+.sidebar li::before {
+    content: "•";
+    position: absolute;
+    left: -1rem;
+    color: var(--secondary-color);
+    transition: transform var(--transition-fast), color var(--transition-fast);
+}
+
+.sidebar li:hover::before {
+    transform: scale(1.3);
+    color: var(--accent-color);
+}
+
+.sidebar a {
+    color: var(--text-color);
+    text-decoration: none;
+    transition: color var(--transition-fast), transform var(--transition-fast);
+    display: inline-block;
+}
+
+.sidebar a:hover {
+    color: var(--secondary-hover);
+    transform: translateX(3px);
+}
+
+.sidebar-footer {
+    margin-top: auto;
+    text-align: center;
+    font-style: italic;
+    color: var(--text-light);
+    font-size: 0.9rem;
+    border-top: 1px solid var(--border-color);
+    padding-top: 1rem;
+}
+
+/* CONTENU CENTRAL */
+.container {
+    display: flex;
+    flex-direction: column;
+}
+
+.header {
+    text-align: center;
+    margin-bottom: 2rem;
+    animation: fadeIn 0.8s ease-out;
+}
+
+.logo-container {
+    width: 250px;
+    margin: 0 auto 0.8rem;
+    transition: transform var(--transition-normal);
+}
+
+.logo-container:hover {
+    transform: var(--scale-hover);
+}
+
+.logo {
+    width: 100%;
+    height: auto;
+}
+
+h1 {
+    color: var(--primary-color);
+    font-weight: 600;
+    font-size: 1.8rem;
+    margin-bottom: 0.5rem;
+}
+
+.subtitle {
+    color: var(--text-light);
+    font-weight: 400;
+    font-size: 1.1rem;
+    max-width: 600px;
+    margin: 0 auto;
+}
+
+/* CHAT CONTAINER */
+.chat-container {
+    background-color: var(--card-bg);
+    border-radius: 16px;
+    box-shadow: 0 4px 20px var(--shadow-color);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    flex-grow: 1;
+    transition: box-shadow var(--transition-normal);
+}
+
+.chat-container:hover {
+    box-shadow: 0 8px 24px var(--shadow-hover);
+}
+
+.chat-history {
+    padding: 1.8rem;
+    flex-grow: 1;
+    max-height: calc(100vh - 280px);
+    overflow-y: auto;
+    scroll-behavior: smooth;
+}
+
+.chat-history::-webkit-scrollbar {
+    width: 6px;
+}
+
+.chat-history::-webkit-scrollbar-thumb {
+    background-color: rgba(0, 0, 0, 0.1);
+    border-radius: 10px;
+    transition: background-color var(--transition-fast);
+}
+
+.chat-history::-webkit-scrollbar-thumb:hover {
+    background-color: rgba(0, 0, 0, 0.2);
+}
+
+.no-messages {
+    text-align: center;
+    color: var(--text-light);
+    margin-top: 2rem;
+    font-size: 0.9rem;
+    font-style: italic;
+}
+
+/* MESSAGES */
+.message {
+    margin-bottom: 2rem;
+    display: flex;
+    gap: 12px;
+    position: relative;
+    animation: fadeIn 0.3s ease-out forwards;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.user-message {
+    flex-direction: row-reverse;
+}
+
+.message-avatar {
+    flex: 0 0 40px;
+    height: 40px;
+    border-radius: 50%;
+    overflow: hidden;
+    align-self: flex-start;
+    transition: transform var(--transition-fast);
+}
+
+.message-avatar:hover {
+    transform: scale(1.1);
+}
+
+.bot-message .message-avatar {
+    border: 3px solid var(--primary-color);
+}
+
+.user-message .message-avatar {
+    border: 3px solid var(--secondary-color);
+}
+
+.avatar {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+    border-radius: 50%;
+}
+
+.message-content {
+    max-width: calc(100% - 60px);
+    padding: 1rem 1.2rem;
+    border-radius: 18px;
+    box-shadow: 0 1px 2px var(--shadow-color);
+    position: relative;
+    transition: transform var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.message-content:hover {
+    box-shadow: 0 3px 6px var(--shadow-hover);
+}
+
+.bot-message .message-content {
+    background-color: var(--hover-color);
+    color: var(--text-color);
+    border-top-left-radius: 4px;
+}
+
+.bot-message .message-content:hover {
+    transform: translateX(2px);
+}
+
+.user-message .message-content {
+    background-color: var(--secondary-color);
+    color: white;
+    border-top-right-radius: 4px;
+}
+
+.user-message .message-content:hover {
+    transform: translateX(-2px);
+    background-color: var(--secondary-hover);
+}
+
+.message-header {
+    margin-bottom: 0.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.message-header strong {
+    color: var(--primary-color);
+}
+
+.message-actions {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+.show-sources-btn {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 12px;
+    padding: 3px 8px;
+    font-size: 0.75rem;
+    cursor: pointer;
+    transition: all var(--transition-fast);
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.show-sources-btn:hover {
+    background-color: var(--secondary-hover);
+    transform: var(--translate-up);
+    box-shadow: 0 3px 8px rgba(28, 160, 225, 0.3);
+}
+
+.processing-time {
+    font-size: 0.7rem;
+    color: var(--text-light);
+    padding: 2px 4px;
+    border-radius: 4px;
+    background: rgba(0,0,0,0.05);
+    transition: background var(--transition-fast);
+}
+
+.processing-time:hover {
+    background: rgba(0,0,0,0.1);
+}
+
+.message-content strong {
+    color: var(--primary-color);
+    font-weight: 600;
+    transition: color var(--transition-fast);
+}
+
+.message-content strong:hover {
+    color: var(--primary-hover);
+}
+
+.user-message .message-content strong {
+    color: white;
+}
+
+.message-content ul, 
+.message-content ol {
+    padding-left: 1.5rem;
+    margin: 0.8rem 0;
+}
+
+.message-content li {
+    margin-bottom: 0.5rem;
+    transition: transform var(--transition-fast);
+}
+
+.message-content li:hover {
+    transform: translateX(3px);
+}
+
+.message-content a {
+    color: var(--secondary-color);
+    text-decoration: none;
+    font-weight: 500;
+    transition: all var(--transition-fast);
+    position: relative;
+}
+
+.message-content a:hover {
+    color: var(--secondary-hover);
+}
+
+.message-content a::after {
+    content: '';
+    position: absolute;
+    width: 0;
+    height: 1px;
+    bottom: 0;
+    left: 0;
+    background-color: var(--secondary-hover);
+    transition: width var(--transition-normal);
+}
+
+.message-content a:hover::after {
+    width: 100%;
+}
+
+/* PANNEAU DES SOURCES */
+.sources-panel {
+    position: fixed;
+    top: 0;
+    right: -400px;
+    width: 380px;
+    height: 100vh;
+    background-color: white;
+    box-shadow: -4px 0 15px rgba(0, 0, 0, 0.1);
+    z-index: 1000;
+    transition: right var(--transition-normal);
+    display: flex;
+    flex-direction: column;
+}
+
+.sources-panel.active {
+    right: 0;
+}
+
+.sources-header {
+    background-color: var(--primary-color);
+    color: white;
+    padding: 1rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.sources-header h3 {
+    font-size: 1.1rem;
+    font-weight: 500;
+}
+
+.close-btn {
+    background: none;
+    border: none;
+    color: white;
+    font-size: 1.5rem;
+    cursor: pointer;
+    transition: transform var(--transition-fast);
+}
+
+.close-btn:hover {
+    transform: scale(1.2);
+}
+
+.sources-content {
+    padding: 1rem;
+    overflow-y: auto;
+    flex: 1;
+}
+
+.sources-container {
+    display: flex;
+    flex-direction: column;
+    gap: 0.8rem;
+}
+
+.source-block {
+    margin-bottom: 0.8rem;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    transition: transform var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.source-block:hover {
+    transform: var(--scale-hover);
+    box-shadow: 0 4px 8px var(--shadow-color);
+}
+
+.source-header {
+    background-color: var(--hover-color);
+    padding: 0.8rem;
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.9rem;
+}
+
+.source-name {
+    font-weight: bold;
+    color: var(--primary-color);
+}
+
+.source-content {
+    padding: 1rem;
+    font-size: 0.9rem;
+}
+
+/* PANNEAU FREDDY */
+.freddy-panel {
+    background-color: var(--freddy-bg);
+    border-radius: 16px;
+    overflow: hidden;
+    box-shadow: 0 4px 12px var(--shadow-color);
+    display: flex;
+    flex-direction: column;
+    height: fit-content;
+    position: sticky;
+    top: 1rem;
+    transition: transform var(--transition-normal), box-shadow var(--transition-normal);
+}
+
+.freddy-panel:hover {
+    transform: var(--scale-hover);
+    box-shadow: 0 6px 18px var(--shadow-hover);
+}
+
+.freddy-header {
+    background-color: var(--accent-color);
+    color: white;
+    padding: 1rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    transition: background-color var(--transition-fast);
+}
+
+.freddy-panel:hover .freddy-header {
+    background-color: var(--accent-hover);
+}
+
+.freddy-header h3 {
+    font-size: 1.1rem;
+    font-weight: 500;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.freddy-header h3 img {
+    width: 28px;
+    height: 28px;
+    border-radius: 50%;
+    border: 2px solid white;
+    transition: transform var(--transition-fast);
+}
+
+.freddy-header h3 img:hover {
+    transform: scale(1.2) rotate(10deg);
+}
+
+.freddy-content {
+    padding: 1rem;
+    overflow-y: auto;
+    max-height: calc(100vh - 150px);
+}
+
+.freddy-content::-webkit-scrollbar {
+    width: 4px;
+}
+
+.freddy-content::-webkit-scrollbar-thumb {
+    background-color: var(--accent-color);
+    border-radius: 10px;
+}
+
+.freddy-content::-webkit-scrollbar-thumb:hover {
+    background-color: var(--accent-hover);
+}
+
+.freddy-intro {
+    margin-bottom: 1.5rem;
+    padding: 1rem;
+    background-color: white;
+    border-radius: 12px;
+    border-left: 4px solid var(--accent-color);
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    transition: transform var(--transition-normal), box-shadow var(--transition-normal);
+}
+
+.freddy-intro:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 4px 10px rgba(255, 152, 0, 0.2);
+}
+
+.freddy-intro img {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    border: 2px solid var(--accent-color);
+    transition: transform var(--transition-fast);
+}
+
+.freddy-intro img:hover {
+    transform: scale(1.1) rotate(10deg);
+}
+
+.freddy-intro p {
+    font-size: 0.9rem;
+    margin-bottom: 0.3rem;
+}
+
+.freddy-logs-title, 
+.freddy-sources-title {
+    margin: 1.5rem 0 0.5rem;
+    color: var(--accent-color);
+    font-weight: bold;
+    font-size: 1.1rem;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    transition: transform var(--transition-fast);
+}
+
+.freddy-logs-title:hover, 
+.freddy-sources-title:hover {
+    transform: translateX(5px);
+}
+
+.freddy-logs {
+    padding: 0.8rem;
+    background-color: rgba(255, 255, 255, 0.7);
+    border-radius: 10px;
+    border: 1px solid var(--freddy-border);
+    transition: background-color var(--transition-normal);
+}
+
+.freddy-logs:hover {
+    background-color: rgba(255, 255, 255, 0.9);
+}
+
+.freddy-log-entry {
+    margin-bottom: 0.5rem;
+    padding: 0.3rem 0;
+    border-bottom: 1px dotted rgba(255, 152, 0, 0.2);
+    font-size: 0.9rem;
+    transition: padding-left var(--transition-fast);
+}
+
+.freddy-log-entry:hover {
+    padding-left: 5px;
+    background-color: rgba(255, 152, 0, 0.05);
+    border-radius: 5px;
+}
+
+.freddy-log-entry:last-child {
+    border-bottom: none;
+}
+
+.log-time {
+    display: inline-block;
+    min-width: 70px;
+    font-family: monospace;
+    font-size: 0.8rem;
+    color: var(--text-light);
+}
+
+.log-action {
+    font-weight: bold;
+    color: var(--accent-color);
+    transition: color var(--transition-fast);
+}
+
+.freddy-log-entry:hover .log-action {
+    color: var(--accent-hover);
+}
+
+.log-detail {
+    display: block;
+    padding: 0.2rem 0;
+    margin-left: 70px;
+    color: var(--text-color);
+    font-size: 0.85rem;
+}
+
+.freddy-sources-container {
+    display: flex;
+    flex-direction: column;
+    gap: 0.8rem;
+}
+
+.freddy-source-block {
+    background-color: white;
+    border-radius: 10px;
+    overflow: hidden;
+    border: 1px solid var(--freddy-border);
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+    transition: transform var(--transition-normal), box-shadow var(--transition-normal);
+}
+
+.freddy-source-block:hover {
+    transform: var(--scale-hover);
+    box-shadow: 0 4px 10px rgba(255, 152, 0, 0.15);
+}
+
+.freddy-source-header {
+    padding: 0.8rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.9rem;
+    background-color: rgba(255, 152, 0, 0.1);
+    border-bottom: 1px solid var(--freddy-border);
+    transition: background-color var(--transition-fast);
+}
+
+.freddy-source-block:hover .freddy-source-header {
+    background-color: rgba(255, 152, 0, 0.2);
+}
+
+.freddy-source-content {
+    padding: 0.8rem;
+    font-size: 0.9rem;
+    max-height: 120px;
+    overflow-y: hidden;
+    position: relative;
+    color: var(--text-color);
+    line-height: 1.5;
+}
+
+.freddy-source-content::after {
+    content: "";
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    width: 100%;
+    height: 40px;
+    background: linear-gradient(transparent, white);
+}
+
+.high-relevance, 
+.medium-relevance, 
+.low-relevance {
+    display: inline-block;
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-size: 0.8rem;
+    transition: transform var(--transition-fast);
+}
+
+.high-relevance:hover, 
+.medium-relevance:hover, 
+.low-relevance:hover {
+    transform: scale(1.1);
+}
+
+.high-relevance {
+    background-color: rgba(76, 175, 80, 0.2);
+    color: var(--high-relevance);
+    font-weight: bold;
+}
+
+.medium-relevance {
+    background-color: rgba(33, 150, 243, 0.2);
+    color: var(--medium-relevance);
+}
+
+.low-relevance {
+    background-color: rgba(158, 158, 158, 0.2);
+    color: var(--low-relevance);
+}
+
+/* LOADING INDICATOR */
+.loading {
+    display: none;
+    padding: 1rem 1.8rem;
+}
+
+.loading-container {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    background-color: var(--hover-color);
+    padding: 0.8rem 1.2rem;
+    border-radius: 18px;
+    max-width: 85%;
+    box-shadow: 0 1px 2px var(--shadow-color);
+    transition: transform var(--transition-normal);
+}
+
+.loading-container:hover {
+    transform: var(--scale-hover);
+}
+
+.searching-cat {
+    width: 50px;
+    height: 50px;
+    border-radius: 50%;
+    object-fit: cover;
+    transition: transform var(--transition-slow);
+    animation: searchingCat 3s infinite alternate;
+}
+
+@keyframes searchingCat {
+    0% { transform: rotate(-5deg); }
+    100% { transform: rotate(5deg); }
+}
+
+#loadingText {
+    color: var(--text-color);
+    font-size: 0.95rem;
+}
+
+.loading-dots {
+    display: inline-block;
+}
+
+.loading-dots::after {
+    content: '...';
+    animation: dots 1.5s steps(4, end) infinite;
+}
+
+@keyframes dots {
+    0%, 20% { content: '.'; }
+    40% { content: '..'; }
+    60% { content: '...'; }
+    80%, 100% { content: ''; }
+}
+
+/* CHAT FORM */
+.chat-form {
+    display: flex;
+    align-items: center;
+    padding: 1.2rem;
+    border-top: 1px solid var(--border-color);
+    background-color: var(--card-bg);
+}
+
+.chat-input-container {
+    flex: 1;
+    position: relative;
+}
+
+.chat-input {
+    width: 100%;
+    padding: 0.9rem 1.2rem 0.9rem 4rem;
+    border: 1px solid var(--border-color);
+    border-radius: 24px;
+    font-size: 1rem;
+    outline: none;
+    background-color: var(--hover-color);
+    transition: all var(--transition-normal);
+}
+
+.chat-input:focus {
+    border-color: var(--secondary-color);
+    box-shadow: 0 0 0 4px rgba(28, 160, 225, 0.1);
+    background-color: white;
+}
+
+.cat-walking {
+    position: absolute;
+    top: 50%;
+    left: 15px;
+    transform: translateY(-50%);
+    width: 34px;
+    height: 34px;
+    z-index: 2;
+    transition: transform var(--transition-normal);
+}
+
+.chat-input:focus + .cat-walking,
+.chat-input-container:hover .cat-walking {
+    animation: catWalking 2s infinite alternate;
+}
+
+@keyframes catWalking {
+    0% { transform: translateY(-50%) translateX(-5px); }
+    100% { transform: translateY(-50%) translateX(5px); }
+}
+
+.send-button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 24px;
+    padding: 0.8rem 1.2rem;
+    margin-left: 0.8rem;
+    cursor: pointer;
+    font-weight: 500;
+    transition: all var(--transition-normal);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: relative;
+    overflow: hidden;
+}
+
+.send-button::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(255,255,255,0.2), transparent);
+    transition: left 0.8s;
+}
+
+.send-button:hover {
+    background-color: var(--secondary-color);
+    transform: var(--translate-up);
+    box-shadow: 0 4px 12px rgba(28, 160, 225, 0.3);
+}
+
+.send-button:hover::before {
+    left: 100%;
+}
+
+.send-button:active {
+    transform: scale(0.98);
+}
+
+.cat-icon {
+    width: 20px;
+    height: 20px;
+    margin-left: 8px;
+    transition: transform var(--transition-fast);
+}
+
+.send-button:hover .cat-icon {
+    animation: catJump 0.5s ease;
+}
+
+@keyframes catJump {
+    0%, 100% { transform: translateY(0); }
+    50% { transform: translateY(-5px); }
+}
+
+/* FOOTER */
+.footer {
+    text-align: center;
+    padding: 1.2rem;
+    font-size: 0.875rem;
+    color: var(--text-light);
+    background-color: var(--card-bg);
+    margin-top: 2rem;
+    border-top: 1px solid var(--border-color);
+    transition: background-color var(--transition-normal);
+}
+
+.footer:hover {
+    background-color: var(--hover-color);
+}
+
+/* MEDIA QUERIES */
+@media (max-width: 1200px) {
+    .main-container {
+        grid-template-columns: 220px 1fr 250px;
+        gap: 1rem;
+    }
+}
+
+@media (max-width: 1024px) {
+    .main-container {
+        grid-template-columns: 1fr;
+        gap: 1.5rem;
+    }
+    .sidebar, .freddy-panel {
+        position: static;
+    }
+    .freddy-panel {
+        order: 3;
+    }
+}
+
+@media (max-width: 768px) {
+    .main-container {
+        padding: 0.5rem;
+    }
+    .header {
+        margin-bottom: 1rem;
+    }
+    .logo-container {
+        width: 140px;
+    }
+    h1 {
+        font-size: 1.4rem;
+    }
+    .chat-history {
+        padding: 1rem;
+    }
+    .message-content {
+        padding: 0.8rem 1rem;
+    }
+    .sources-panel {
+        width: 280px;
+    }
+}
+
+@media (max-width: 480px) {
+    .message {
+        flex-direction: column;
+        gap: 8px;
+    }
+    .user-message {
+        align-items: flex-end;
+    }
+    .bot-message {
+        align-items: flex-start;
+    }
+    .message-content {
+        max-width: 90%;
+    }
+    .chat-form {
+        padding: 0.8rem;
+    }
+    .send-button {
+        padding: 0.6rem 1rem;
+    }
+    .sources-panel {
+        width: 100%;
+    }
+}
+
+
+
+.role-selection-container {
+            background: rgb(98, 98, 237);
+            border-radius: 15px;
+            padding: 25px;
+            margin: 20px 0;
+            box-shadow: 0 10px 25px rgba(0,0,0,0.15);
+            border: none;
+        }
+        
+        .role-selection-header {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        
+        .role-selection-header h3 {
+            color: white;
+            font-size: 1.4em;
+            margin-bottom: 10px;
+            text-shadow: 0 2px 4px rgba(0,0,0,0.3);
+        }
+        
+        .role-selection-header p {
+            color: rgba(255,255,255,0.9);
+            font-size: 1em;
+            margin: 0;
+        }
+        
+        .role-buttons-grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 15px;
+            margin-bottom: 20px;
+        }
+        
+        @media (max-width: 768px) {
+            .role-buttons-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+        
+        .role-button {
+            background: rgba(255,255,255,0.1);
+            border: 2px solid rgba(255,255,255,0.2);
+            border-radius: 12px;
+            padding: 20px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            color: white;
+            text-align: left;
+            backdrop-filter: blur(10px);
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .role-button::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: -100%;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(90deg, transparent, rgba(255,255,255,0.1), transparent);
+            transition: left 0.5s ease;
+        }
+        
+        .role-button:hover::before {
+            left: 100%;
+        }
+        
+        .role-button:hover {
+            transform: translateY(-5px);
+            border-color: rgba(255,255,255,0.4);
+            box-shadow: 0 15px 30px rgba(0,0,0,0.2);
+            background: rgba(255,255,255,0.15);
+        }
+        
+        .role-button.selected {
+            background: rgba(255,255,255,0.25);
+            border-color: #ffd700;
+            box-shadow: 0 0 20px rgba(255, 215, 0, 0.4);
+        }
+        
+        .role-button-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+        
+        .role-icon {
+            font-size: 1.5em;
+            margin-right: 10px;
+            opacity: 0.8;
+        }
+        
+        .role-title {
+            font-weight: bold;
+            font-size: 1.1em;
+        }
+        
+        .role-description {
+            font-size: 0.9em;
+            opacity: 0.85;
+            line-height: 1.4;
+        }
+        
+        .confirm-role-section {
+            display: none;
+            text-align: center;
+            margin-top: 15px;
+        }
+        
+        .confirm-role-section.active {
+            display: block;
+        }
+        
+        .confirm-button, .reset-button {
+            background: linear-gradient(135deg, #28a745, #20c997);
+            border: none;
+            color: white;
+            padding: 12px 25px;
+            border-radius: 25px;
+            cursor: pointer;
+            font-weight: bold;
+            font-size: 1em;
+            margin: 0 10px;
+            transition: all 0.3s ease;
+            box-shadow: 0 4px 15px rgba(40, 167, 69, 0.3);
+        }
+        
+        .confirm-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 20px rgba(40, 167, 69, 0.4);
+        }
+        
+        .reset-button {
+            background: linear-gradient(135deg, #dc3545, #c82333);
+            box-shadow: 0 4px 15px rgba(220, 53, 69, 0.3);
+        }
+        
+        .reset-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 20px rgba(220, 53, 69, 0.4);
+        }
+        
+        .current-role-display {
+            background: rgba(40, 167, 69, 0.1);
+            border: 2px solid rgba(40, 167, 69, 0.3);
+            border-radius: 10px;
+            padding: 15px;
+            margin: 15px 0;
+            color: #155724;
+            text-align: center;
+        }
+        
+        .current-role-display .role-name {
+            font-weight: bold;
+            font-size: 1.1em;
+            color: #28a745;
+        }
+        
+        .chat-form.disabled {
+            opacity: 0.6;
+            pointer-events: none;
+        }
+        
+        .role-required-notice {
+            background: #fff3cd;
+            border: 1px solid #ffeaa7;
+            border-radius: 8px;
+            padding: 12px;
+            margin: 15px 0;
+            color: #856404;
+            text-align: center;
+        }
+        .mic-button {
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-size: 1.5rem;
+    margin-left: 8px;
+    color: #444;
+}
+.mic-button:disabled {
+    color: #aaa;
+    cursor: not-allowed;
+}
+
+/* décale légèrement le bouton conversation vers la droite */
+.chat-form .conversation-button {
+    margin-left: 12px; /* augmente si tu veux plus d'espace */
+    padding: 8px 12px;
+    border-radius: 6px;
+    border: 1px solid #ccc;
+    background: #fff;
+    cursor: pointer;
+}
+
+/* style quand actif */
+.chat-form .conversation-button.active {
+    background: red;
+    color: #fff;
+    border-color: #27ae60;
+}

templates/index.html

@@ -0,0 +1,737 @@
+<!DOCTYPE html>
+<html lang="fr">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description"
+        content="Les Chats De SeaTech - Votre guide félin pour l'école d'ingénieurs de l'Université de Toulon">
+    <title>Les Chats De SeaTech</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="icon" href="{{ url_for('static', filename='img/seatech_logo.png') }}" type="image/png">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+
+</head>
+
+<body>
+    <div class="main-container">
+        <!-- Sidebar -->
+        <aside class="sidebar card">
+            <div class="sidebar-header">
+                <h2>Les Chats De SeaTech</h2>
+                <div class="cats-logo">
+                    <img src="{{ url_for('static', filename='img/franky.png') }}" alt="Franky" class="cat-avatar"
+                        loading="lazy">
+                    <img src="{{ url_for('static', filename='img/freddy.png') }}" alt="Freddy" class="cat-avatar"
+                        loading="lazy">
+                </div>
+            </div>
+            <nav>
+                <div class="sidebar-section">
+                    <h3>Liens SeaTech</h3>
+                    <ul>
+                        <li><a href="https://seatech.univ-tln.fr/" target="_blank" rel="noopener">SeaTech Officiel</a>
+                        </li>
+                        <li><a href="https://www.univ-tln.fr/" target="_blank" rel="noopener">Université de Toulon</a>
+                        </li>
+                    </ul>
+                </div>
+                <div class="sidebar-section">
+                    <h3>Formations</h3>
+                    <ul>
+                        <li><a href="https://seatech.univ-tln.fr/devenir-ingenieur" target="_blank"
+                                rel="noopener">Devenir Ingénieur</a></li>
+                        <li><a href="https://seatech.univ-tln.fr/Formation-d-ingenieurs-Materiaux-par-apprentissage.html"
+                                target="_blank" rel="noopener">Matériaux (Apprentissage)</a></li>
+                        <li><a href="https://seatech.univ-tln.fr/Formation-d-ingenieurs-en-systemes-numeriques-par-apprentissage.html"
+                                target="_blank" rel="noopener">Systèmes Numériques (Apprentissage)</a></li>
+                    </ul>
+                </div>
+                <div class="sidebar-section">
+                    <h3>Informations</h3>
+                    <ul>
+                        <li><a href="https://seatech.univ-tln.fr/recherche" target="_blank" rel="noopener">Recherche</a>
+                        </li>
+                        <li><a href="https://seatech.univ-tln.fr/international" target="_blank"
+                                rel="noopener">International</a></li>
+                        <li><a href="https://seatech.univ-tln.fr/Contacts.html" target="_blank"
+                                rel="noopener">Contacts</a></li>
+                    </ul>
+                </div>
+            </nav>
+            <div class="sidebar-footer">
+                <p>Posez-moi vos questions sur SeaTech!</p>
+            </div>
+        </aside>
+
+        <!-- Contenu principal -->
+        <main class="container">
+            <header class="header">
+                <div class="logo-container">
+                    <img src="{{ url_for('static', filename='img/seatech_logo.png') }}" alt="Logo SeaTech" class="logo"
+                        width="250" height="auto">
+                </div>
+                <h1>Les Chats De SeaTech</h1>
+                <p class="subtitle">Votre guide félin pour l'école d'ingénieurs de l'Université de Toulon</p>
+            </header>
+
+            <!-- Section de sélection de rôle -->
+            {% if not user_profile.get('confirmed') %}
+            <section class="role-selection-container">
+                <div class="role-selection-header">
+                    <h3><i class="fas fa-user-circle"></i> Choisissez votre profil</h3>
+                    <p>Pour mieux vous aider, veuillez sélectionner votre profil :</p>
+                </div>
+
+                <div class="role-buttons-grid">
+                    <div class="role-button" data-role="Étudiant">
+                        <div class="role-button-header">
+                            <div class="role-icon"><i class="fas fa-graduation-cap"></i></div>
+                            <div class="role-title">Étudiant</div>
+                        </div>
+                        <div class="role-description">
+                            Étudiant actuel de SeaTech cherchant des informations sur les cours, emplois du temps,
+                            projets, vie associative...
+                        </div>
+                    </div>
+
+                    <div class="role-button" data-role="Candidat">
+                        <div class="role-button-header">
+                            <div class="role-icon"><i class="fas fa-user-plus"></i></div>
+                            <div class="role-title">Candidat</div>
+                        </div>
+                        <div class="role-description">
+                            Candidat intéressé par SeaTech : admissions, concours, formations, spécialités
+                            disponibles...
+                        </div>
+                    </div>
+
+                    <div class="role-button" data-role="Enseignant">
+                        <div class="role-button-header">
+                            <div class="role-icon"><i class="fas fa-chalkboard-teacher"></i></div>
+                            <div class="role-title">Enseignant</div>
+                        </div>
+                        <div class="role-description">
+                            Enseignant cherchant des ressources pédagogiques, contacts administratifs, organisation des
+                            cours...
+                        </div>
+                    </div>
+
+                    <div class="role-button" data-role="Alumni">
+                        <div class="role-button-header">
+                            <div class="role-icon"><i class="fas fa-user-tie"></i></div>
+                            <div class="role-title">Alumni</div>
+                        </div>
+                        <div class="role-description">
+                            Ancien étudiant de SeaTech intéressé par le réseau alumni, partenariats, événements...
+                        </div>
+                    </div>
+                </div>
+
+                <div class="confirm-role-section">
+                    <p>Rôle sélectionné : <strong id="selectedRoleName"></strong></p>
+                    <button class="confirm-button" id="confirmRoleBtn">
+                        <i class="fas fa-check"></i> Confirmer mon profil
+                    </button>
+                </div>
+            </section>
+            {% else %}
+            <!-- Affichage du rôle actuel -->
+            <div class="current-role-display">
+                <p><i class="fas fa-user-check"></i> Profil actuel : <span class="role-name">{{ user_profile.role
+                        }}</span></p>
+                <button class="reset-button" id="resetRoleBtn">
+                    <i class="fas fa-redo"></i> Changer de profil
+                </button>
+            </div>
+            {% endif %}
+
+            <section class="chat-container">
+                <div class="chat-history" id="chatHistory">
+                    <article class="message bot-message">
+                        <div class="message-avatar">
+                            <img src="{{ url_for('static', filename='img/franky.png') }}" alt="Franky" class="avatar"
+                                loading="lazy">
+                        </div>
+                        <div class="message-content">
+                            <div class="message-header">
+                                <strong>Franky</strong>
+                            </div>
+                            <p>Miaaaou ! Je suis <strong>Franky</strong>, votre guide félin de SeaTech ! 🐱 Mon ami
+                                <strong>Freddy</strong> et moi sommes là pour vous aider.
+                                {% if not user_profile.get('confirmed') %}
+                                Commencez par sélectionner votre profil ci-dessus pour que je puisse adapter mes
+                                réponses à vos besoins.
+                                {% else %}
+                                Posez-moi n'importe quelle question sur l'école et je vous répondrai en tant
+                                qu'assistant spécialisé pour les {{ user_profile.role }}s.
+                                {% endif %}
+                            </p>
+                        </div>
+                    </article>
+
+                    {% if conversation %}
+                    {% for msg in conversation %}
+                    <article class="message {% if msg.role == 'user' %}user-message{% else %}bot-message{% endif %}">
+                        {% if msg.role != 'user' %}
+                        <div class="message-avatar">
+                            <img src="{{ url_for('static', filename='img/franky.png') }}" alt="Franky" class="avatar"
+                                loading="lazy">
+                        </div>
+                        {% endif %}
+                        <div class="message-content">
+                            {% if msg.role != 'user' %}
+                            <div class="message-header">
+                                <strong>Franky</strong>
+                                <div class="message-actions">
+                                    {% if not msg.get('is_system_message') %}
+                                    <button class="show-sources-btn" aria-label="Afficher les sources"><i
+                                            class="fas fa-file-alt"></i> Sources</button>
+                                    {% endif %}
+                                    {% if msg.processing_time %}
+                                    <span class="processing-time">{{ msg.processing_time }}</span>
+                                    {% endif %}
+                                </div>
+                            </div>
+                            {% endif %}
+                            {{ msg.content | safe }}
+                        </div>
+                        {% if msg.role == 'user' %}
+                        <div class="message-avatar">
+                            <img src="{{ url_for('static', filename='img/user.png') }}" alt="User" class="avatar"
+                                loading="lazy">
+                        </div>
+                        {% endif %}
+                    </article>
+                    {% endfor %}
+                    {% else %}
+                    {% if not user_profile.get('confirmed') %}
+                    <div class="role-required-notice">
+                        <i class="fas fa-info-circle"></i> Veuillez sélectionner votre profil ci-dessus pour commencer à
+                        poser vos questions.
+                    </div>
+                    {% else %}
+                    <div class="no-messages">Posez votre première question !</div>
+                    {% endif %}
+                    {% endif %}
+                </div>
+
+                <div class="loading" id="loadingIndicator">
+                    <div class="loading-container">
+                        <img src="{{ url_for('static', filename='img/searching-cat.gif') }}" alt="Chat qui cherche"
+                            class="searching-cat">
+                        <span id="loadingText">Je demande à Freddy<span class="loading-dots"></span></span>
+                    </div>
+                </div>
+
+                <form class="chat-form{% if not user_profile.get('confirmed') %} disabled{% endif %}" id="chatForm"
+                    method="POST" action="/">
+                    <div class="chat-input-container">
+                        <img src="{{ url_for('static', filename='img/cat_walking.png') }}" alt="Chat qui marche"
+                            class="cat-walking">
+                        <input type="text" name="query" id="queryInput" class="chat-input"
+                            placeholder="{% if user_profile.get('confirmed') %}Posez votre question sur SeaTech...{% else %}Sélectionnez d'abord votre profil ci-dessus{% endif %}"
+                            {% if not user_profile.get('confirmed') %}disabled{% endif %} required autocomplete="off"
+                            aria-label="Votre question">
+
+
+                    </div>
+                    <!-- Bouton micro -->
+                    <button type="button" id="micButton" class="mic-button" {% if not user_profile.get('confirmed')
+                        %}disabled{% endif %}>
+                        <i class="fas fa-microphone"></i>
+                    </button>
+
+                    <!-- Bouton : mode conversation-->
+                     <button type="button" id="conversationBtn" class="conversation-button">
+                        <i class="fas fa-comments"></i> Start conversation
+                    </button>
+
+                    <button type="submit" class="send-button" {% if not user_profile.get('confirmed') %}disabled{% endif
+                        %}>
+                        Envoyer
+                        <img src="{{ url_for('static', filename='img/cat-icon.png') }}" alt="Chat" class="cat-icon"
+                            width="20" height="20">
+                    </button>
+                </form>
+            </section>
+        </main>
+
+        <!-- Panneau des sources (caché par défaut) -->
+        <aside class="sources-panel" id="sourcesPanel" aria-hidden="true">
+            <div class="sources-header">
+                <h3>Sources consultées par Freddy</h3>
+                <button id="closeSourcesBtn" class="close-btn" aria-label="Fermer le panneau des sources">×</button>
+            </div>
+            <div class="sources-content" id="sourcesContent">
+                <!-- Sources insérées dynamiquement -->
+            </div>
+        </aside>
+
+        <!-- Panneau de Freddy (toujours visible) -->
+        <aside class="freddy-panel card">
+            <div class="freddy-header">
+                <h3>
+                    <img src="{{ url_for('static', filename='img/freddy.png') }}" alt="Freddy" loading="lazy">
+                    Recherche par Freddy
+                </h3>
+            </div>
+            <div class="freddy-content">
+                <div class="freddy-intro">
+                    <img src="{{ url_for('static', filename='img/freddy.png') }}" alt="Freddy" loading="lazy">
+                    <div>
+                        <p><strong>Miaaaou !</strong> Je suis <strong>Freddy</strong>, l'assistant de recherche de
+                            SeaTech.</p>
+                        <p>Je fouille dans les documents pour trouver les informations les plus pertinentes
+                            {% if user_profile.get('confirmed') %}pour les {{ user_profile.role }}s{% endif %} !</p>
+                    </div>
+                </div>
+
+                <div class="freddy-logs-title">
+                    <i class="fas fa-search"></i> Analyse de la recherche
+                </div>
+                <div id="freddyLogs" class="freddy-logs">
+                    <div class="freddy-log-entry">
+                        <span class="log-time">{{ current_datetime.strftime('%H:%M:%S') }}</span>
+                        {% if user_profile.get('confirmed') %}
+                        <span class="log-action">Prêt à chercher pour un profil {{ user_profile.role }}</span>
+                        {% else %}
+                        <span class="log-action">En attente de sélection de profil...</span>
+                        {% endif %}
+                    </div>
+                </div>
+
+                <div class="freddy-sources-title">
+                    <i class="fas fa-file-alt"></i> Sources consultées
+                </div>
+                <div id="freddySources" class="freddy-sources-container">
+                    <div class="freddy-source-block">
+                        <div class="freddy-source-header">
+                            <span class="source-name">Informations SeaTech</span>
+                            {% if user_profile.get('confirmed') %}
+                            <span class="medium-relevance">Filtrage par profil {{ user_profile.role }}...</span>
+                            {% else %}
+                            <span class="medium-relevance">En attente de profil...</span>
+                            {% endif %}
+                        </div>
+                        <div class="freddy-source-content">
+                            {% if user_profile.get('confirmed') %}
+                            Prêt à chercher des informations spécifiquement adaptées pour les {{ user_profile.role }}s.
+                            {% else %}
+                            Sélectionnez votre profil pour que je puisse filtrer les informations selon vos besoins.
+                            {% endif %}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </aside>
+    </div>
+
+    <footer class="footer">
+        <p>&copy; {{ current_datetime.year }} École d'ingénieurs SeaTech - Université de Toulon | Tous droits réservés
+        </p>
+    </footer>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', function () {
+            let isConversationMode = false; // mode conversation activé/désactivé
+
+
+            const chatForm = document.getElementById('chatForm');
+            const chatHistory = document.getElementById('chatHistory');
+            const loadingIndicator = document.getElementById('loadingIndicator');
+            const queryInput = document.getElementById('queryInput');
+            const loadingText = document.getElementById('loadingText');
+            const sourcesPanel = document.getElementById('sourcesPanel');
+            const sourcesContent = document.getElementById('sourcesContent');
+            const closeSourcesBtn = document.getElementById('closeSourcesBtn');
+            const freddyLogs = document.getElementById('freddyLogs');
+            const freddySources = document.getElementById('freddySources');
+
+            // Éléments de sélection de rôle
+            const roleButtons = document.querySelectorAll('.role-button');
+            const confirmRoleSection = document.querySelector('.confirm-role-section');
+            const confirmRoleBtn = document.getElementById('confirmRoleBtn');
+            const resetRoleBtn = document.getElementById('resetRoleBtn');
+            const selectedRoleName = document.getElementById('selectedRoleName');
+
+            let selectedRole = null;
+
+            const loadingMessages = [
+                "Freddy fouille dans les archives...",
+                "Freddy déchiffre les acronymes de SeaTech... 🐱",
+                "Freddy explore les données de l'école...",
+                "Miaaaou! Freddy a repéré une information intéressante...",
+                "Freddy chasse les informations pertinentes... 🐾",
+                "Les moustaches de Freddy frémissent... il est sur une piste!"
+            ];
+
+            // Gestion de la sélection de rôle
+            roleButtons.forEach(button => {
+                button.addEventListener('click', function () {
+                    roleButtons.forEach(btn => btn.classList.remove('selected'));
+                    this.classList.add('selected');
+                    selectedRole = this.dataset.role;
+                    selectedRoleName.textContent = selectedRole;
+                    confirmRoleSection.classList.add('active');
+                });
+            });
+
+            if (confirmRoleBtn) {
+                confirmRoleBtn.addEventListener('click', function () {
+                    if (selectedRole) {
+                        fetch('/api/ask', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ role_selection: selectedRole }),
+                            credentials: 'same-origin'
+                        })
+                            .then(response => response.json())
+                            .then(data => {
+                                if (data.status === 'role_selected') {
+                                    window.location.reload();
+                                }
+                            })
+                            .catch(error => console.error('Erreur lors de la sélection de rôle:', error));
+                    }
+                });
+            }
+
+            if (resetRoleBtn) {
+                resetRoleBtn.addEventListener('click', function () {
+                    fetch('/api/reset-role', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        credentials: 'same-origin'
+                    })
+                        .then(response => response.json())
+                        .then(data => {
+                            if (data.status === 'role_reset') {
+                                window.location.reload();
+                            }
+                        })
+                        .catch(error => console.error('Erreur lors de la réinitialisation:', error));
+                });
+            }
+
+            function extractSources(html) {
+                if (!html) return null;
+                const parser = new DOMParser();
+                const doc = parser.parseFromString(html, 'text/html');
+                const sourcesContainer = doc.querySelector('.sources-container');
+                return sourcesContainer ? sourcesContainer.innerHTML : null;
+            }
+
+            function updateFreddyContent(html) {
+                if (!html) return;
+                const parser = new DOMParser();
+                const doc = parser.parseFromString(html, 'text/html');
+                const logsSection = doc.querySelector('.freddy-logs');
+                if (logsSection) freddyLogs.innerHTML = logsSection.innerHTML;
+                const sourcesSection = doc.querySelector('.freddy-sources-container');
+                if (sourcesSection) freddySources.innerHTML = sourcesSection.innerHTML;
+            }
+
+            closeSourcesBtn.addEventListener('click', function () {
+                sourcesPanel.classList.remove('active');
+                sourcesPanel.setAttribute('aria-hidden', 'true');
+            });
+
+            let messageIndex = 0;
+            let loadingInterval;
+
+            function updateLoadingMessage() {
+                loadingText.innerHTML = `${loadingMessages[messageIndex]}<span class="loading-dots"></span>`;
+                messageIndex = (messageIndex + 1) % loadingMessages.length;
+            }
+
+            function scrollToBottom() {
+                chatHistory.scrollTop = chatHistory.scrollHeight;
+            }
+            scrollToBottom();
+
+            function initButtons() {
+                document.querySelectorAll('.show-sources-btn').forEach(button => {
+                    button.addEventListener('click', function () {
+                        sourcesPanel.classList.add('active');
+                        sourcesPanel.setAttribute('aria-hidden', 'false');
+                    });
+                });
+            }
+            initButtons();
+
+            if (chatForm) {
+                chatForm.addEventListener('submit', function (e) {
+                    e.preventDefault();
+                    const query = queryInput.value.trim();
+                    if (!query) return;
+
+                    const userMessageDiv = document.createElement('article');
+                    userMessageDiv.className = 'message user-message';
+                    userMessageDiv.innerHTML = `
+                    <div class="message-content">${query}</div>
+                    <div class="message-avatar">
+                        <img src="${window.location.origin}/static/img/user.png" alt="User" class="avatar" loading="lazy">
+                    </div>
+                `;
+                    chatHistory.appendChild(userMessageDiv);
+                    scrollToBottom();
+
+                    loadingIndicator.style.display = 'block';
+                    messageIndex = 0;
+                    updateLoadingMessage();
+                    loadingInterval = setInterval(updateLoadingMessage, 2000);
+
+                    fetch('/api/ask', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ query: query }),
+                        credentials: 'same-origin'
+                    })
+                        .then(response => response.json())
+                        .then(data => {
+                            clearInterval(loadingInterval);
+                            loadingIndicator.style.display = 'none';
+
+                            if (data.status === 'role_required') {
+                                const errorDiv = document.createElement('article');
+                                errorDiv.className = 'message bot-message';
+                                errorDiv.innerHTML = `
+                            <div class="message-avatar">
+                                <img src="${window.location.origin}/static/img/franky.png" alt="Franky" class="avatar" loading="lazy">
+                            </div>
+                            <div class="message-content">
+                                <div class="message-header"><strong>Franky</strong></div>
+                                ${data.response}
+                            </div>
+                        `;
+                                chatHistory.appendChild(errorDiv);
+                                scrollToBottom();
+                                return;
+                            }
+
+                            const sourcesHtml = data.sources || extractSources(data.response);
+                            let cleanResponse = data.response;
+
+                            if (sourcesHtml && cleanResponse.includes("sources-container")) {
+                                const tempDiv = document.createElement('div');
+                                tempDiv.innerHTML = cleanResponse;
+                                const sourcesContainer = tempDiv.querySelector('.sources-container');
+                                if (sourcesContainer) sourcesContainer.remove();
+                                cleanResponse = tempDiv.innerHTML;
+                            }
+
+                            if (sourcesHtml) sourcesContent.innerHTML = sourcesHtml;
+                            if (data.freddy_logs) updateFreddyContent(data.freddy_logs);
+
+                            const botMessageDiv = document.createElement('article');
+                            botMessageDiv.className = 'message bot-message';
+                            botMessageDiv.innerHTML = `
+                        <div class="message-avatar">
+                            <img src="${window.location.origin}/static/img/franky.png" alt="Franky" class="avatar" loading="lazy">
+                        </div>
+                        <div class="message-content">
+                            <div class="message-header">
+                                <strong>Franky</strong>
+                                <div class="message-actions">
+                                    ${sourcesHtml ? '<button class="show-sources-btn" aria-label="Afficher les sources"><i class="fas fa-file-alt"></i> Sources</button>' : ''}
+                                    ${data.processing_time ? '<span class="processing-time">' + data.processing_time + '</span>' : ''}
+                                    ${data.confirmed_role ? '<span class="role-indicator">Profil: ' + data.confirmed_role + '</span>' : ''}
+                                </div>
+                            </div>
+                            ${cleanResponse}
+                        </div>
+                    `;
+
+                            chatHistory.appendChild(botMessageDiv);
+                            queryInput.value = '';
+                            queryInput.focus();
+                            //ajout Daly
+                            // Lecture vocale de la réponse (TTS)
+                            // Lecture vocale seulement si mode conversation actif
+                            if (isConversationMode && 'speechSynthesis' in window && data.response) {
+                                let textToRead = data.response
+                                    .replace(/<[^>]+>/g, ' ')
+                                    .replace(/[^\w\sàâäçéèêëîïôöùûüÿñœ]/gi, '')
+                                    .replace(/\s+/g, ' ')
+                                    .trim();
+                                const utterance = new SpeechSynthesisUtterance(textToRead);
+                                utterance.lang = "fr-FR";
+                                utterance.rate = 1.0;
+                                utterance.pitch = 1.0;
+                                speechSynthesis.cancel();
+                                speechSynthesis.speak(utterance);
+                            }
+
+                            //fin ajout
+                            scrollToBottom();
+                            initButtons();
+                        })
+                        .catch(error => {
+                            console.error('Erreur:', error);
+                            clearInterval(loadingInterval);
+                            loadingIndicator.style.display = 'none';
+
+                            const errorDiv = document.createElement('article');
+                            errorDiv.className = 'message bot-message';
+                            errorDiv.innerHTML = `
+                        <div class="message-avatar">
+                            <img src="${window.location.origin}/static/img/franky.png" alt="Franky" class="avatar" loading="lazy">
+                        </div>
+                        <div class="message-content">
+                            <div class="message-header"><strong>Franky</strong></div>
+                            <p>Désolé, une erreur s'est produite pendant la recherche. Veuillez réessayer.</p>
+                        </div>
+                    `;
+                            chatHistory.appendChild(errorDiv);
+                            scrollToBottom();
+                        });
+                });
+            }
+
+            // === Reconnaissance vocale ===
+            const micBtn = document.getElementById('micButton'); // utilise l'ID réel du bouton
+            if (micBtn && 'webkitSpeechRecognition' in window) {
+                const recognition = new webkitSpeechRecognition();
+                recognition.lang = "fr-FR";
+                recognition.continuous = false;
+                recognition.interimResults = false;
+
+                micBtn.addEventListener('click', () => {
+                    recognition.start();
+                    micBtn.classList.add("listening"); // effet visuel pendant l'écoute
+                });
+
+                recognition.onresult = (event) => {
+                let transcript = event.results[0][0].transcript;
+
+                // Corrections automatiques pour SeaTech
+                const corrections = {
+                    "steak": "SeaTech",
+                    "scitec": "SeaTech",
+                    "sitec": "SeaTech",
+                    "citech": "SeaTech",
+                    "citek": "SeaTech",
+                    "sutec": "SeaTech",
+                    "sitac": "SeaTech",
+                };
+
+                for (const [wrong, correct] of Object.entries(corrections)) {
+                    const regex = new RegExp(`\\b${wrong}\\b`, "gi"); // cherche le mot entier, insensible à la casse
+                    transcript = transcript.replace(regex, correct);
+                }
+
+                queryInput.value = transcript;      // place le texte corrigé dans la barre de saisie
+                //chatForm.requestSubmit();         // si tu veux envoyer auto, tu décommentes
+                micBtn.classList.remove("listening");
+                };
+
+
+                recognition.onerror = (event) => {
+                    console.error("Erreur vocale:", event.error);
+                    micBtn.classList.remove("listening");
+                };
+
+                recognition.onend = () => {
+                    micBtn.classList.remove("listening");
+                };
+            }
+
+        
+                
+        // === Mode conversation ===
+        const conversationBtn = document.getElementById("conversationBtn");
+        if (conversationBtn && 'webkitSpeechRecognition' in window) {
+            const convRecognition = new webkitSpeechRecognition();
+            convRecognition.lang = "fr-FR";
+            convRecognition.continuous = false;
+            convRecognition.interimResults = false;
+
+            // ✅ Toggle ON/OFF du mode conversation
+            conversationBtn.addEventListener("click", () => {
+                isConversationMode = !isConversationMode;
+
+                if (isConversationMode) {
+                    conversationBtn.classList.add("active");
+                    conversationBtn.innerHTML = '<i class="fas fa-comments"></i> Stop conversation';
+                    convRecognition.start();
+                } else {
+                    conversationBtn.classList.remove("active");
+                    conversationBtn.innerHTML = '<i class="fas fa-comments"></i> Start conversation';
+                    convRecognition.stop();
+                    speechSynthesis.cancel(); // stoppe toute lecture en cours
+                }
+            });
+
+            convRecognition.onresult = (event) => {
+                let transcript = event.results[0][0].transcript;
+
+                // Corrections automatiques pour SeaTech
+                const corrections = { "steak": "SeaTech", "scitec": "SeaTech", "sitec": "SeaTech" };
+                for (const [wrong, correct] of Object.entries(corrections)) {
+                    const regex = new RegExp(`\\b${wrong}\\b`, "gi");
+                    transcript = transcript.replace(regex, correct);
+                }
+
+                // Envoi automatique si mode conversation actif
+                if (isConversationMode) {
+                    fetch('/api/ask', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ query: transcript, mode: "conversation" }),
+                        credentials: 'same-origin'
+                    })
+                        .then(response => response.json())
+                        .then(data => {
+                            const botMessageDiv = document.createElement('article');
+                            botMessageDiv.className = 'message bot-message';
+                            botMessageDiv.innerHTML = `
+                                <div class="message-avatar">
+                                    <img src="${window.location.origin}/static/img/franky.png" alt="Franky" class="avatar" loading="lazy">
+                                </div>
+                                <div class="message-content">
+                                    <div class="message-header"><strong>Franky</strong></div>
+                                    ${data.response}
+                                </div>`;
+                            chatHistory.appendChild(botMessageDiv);
+                            scrollToBottom();
+
+                            // ✅ Lecture vocale courte et propre
+                            if ('speechSynthesis' in window && isConversationMode) {
+                                let textToRead = data.response
+                                    .replace(/<[^>]+>/g, ' ')        // supprime balises HTML
+                                    .replace(/[^\w\sàâäçéèêëîïôöùûüÿñœ]/gi, '') // supprime symboles
+                                    .replace(/\s+/g, ' ')            // normalise espaces
+                                    .trim();
+
+                                const utterance = new SpeechSynthesisUtterance(textToRead);
+                                utterance.lang = "fr-FR";
+                                utterance.rate = 1.0;
+                                utterance.pitch = 1.0;
+                                speechSynthesis.cancel(); // stoppe lectures précédentes
+                                speechSynthesis.speak(utterance);
+                            }
+
+                            convRecognition.start(); // relance automatiquement pour écoute suivante
+                        })
+                        .catch(error => {
+                            console.error("Erreur conversation:", error);
+                        });
+                }
+            };
+
+            convRecognition.onerror = (event) => {
+                console.error("Erreur vocale (mode conv):", event.error);
+                conversationBtn.classList.remove("listening");
+            };
+
+            convRecognition.onend = () => {
+                if (isConversationMode) convRecognition.start(); // boucle tant que mode actif
+            };
+        }
+
+    });
+    </script>
+</body>
+
+</html>