Upload 4 files

config.py

@@ -10,11 +10,14 @@ DATA_DIR: Path = BASE_DIR / "data"
 FAQ_JSON_PATH: str = str(DATA_DIR / "260717_FAQ_Miss_Terry_developpeur.json")
 
 # Configuration des embeddings
-MODEL_NAME: str = os.getenv("MODEL_NAME", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+MODEL_NAME: str = os.getenv("MODEL_NAME", "intfloat/multilingual-e5-small") #"sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
 
 # Configuration ChromaDB
 CHROMA_COLLECTION_NAME: str = "faq"
 
 # Configuration de similarité
-SIMILARITY_THRESHOLD: float = float(os.getenv("SIMILARITY_THRESHOLD", "0.70"))
+SIMILARITY_THRESHOLD: float = float(os.getenv("SIMILARITY_THRESHOLD", "0.80"))
 
+TOP_K = 3
+CROSS_ENCODER_MODEL_NAME = "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
+CROSS_ENCODER_THRESHOLD = 0.5

embeddings.py

@@ -1,7 +1,7 @@
 """Gestion des embeddings avec ChromaDB et Hugging Face Transformers."""
 import os
-# Règle d’or : toute variable d’environnement qui influence le cache Hugging Face doit être
-# définie avant d’importer datasets ou transformers, sinon elle sera ignorée.
+# Règle d'or : toute variable d'environnement qui influence le cache Hugging Face doit être
+# définie avant d'importer datasets ou transformers, sinon elle sera ignorée.
 cache_dir = "/tmp"
 os.makedirs(cache_dir, exist_ok=True)
 
@@ -10,23 +10,30 @@ os.environ["HF_HOME"] = cache_dir
 os.environ["HF_DATASETS_CACHE"] = os.path.join(cache_dir, "datasets")
 os.environ["TRANSFORMERS_CACHE"] = os.path.join(cache_dir, "transformers")
 
-import logging
-from typing import Optional
-from models import QuestionInput, AnswerOutput
+# Désactiver la télémétrie ChromaDB/PostHog pour éviter les erreurs de signature
+# de capture() sur certaines versions de dependent packages.
+os.environ.setdefault("CHROMA_DISABLE_TELEMETRY", "1")
+os.environ.setdefault("CHROMADB_DISABLE_TELEMETRY", "1")
+os.environ.setdefault("POSTHOG_DISABLED", "1")
 
+import logging
+from models import QuestionInput, AnswerOutput, SemanticSearchCandidate
+import unicodedata
 import chromadb
-from sentence_transformers import SentenceTransformer
+from sentence_transformers import SentenceTransformer, CrossEncoder
 import torch
 from config import (
     CHROMA_COLLECTION_NAME,
     MODEL_NAME,
     SIMILARITY_THRESHOLD,
+    TOP_K,
+    CROSS_ENCODER_MODEL_NAME,
+    CROSS_ENCODER_THRESHOLD,
 )
 from faq_loader import FAQEntry
 
 logger = logging.getLogger(__name__)
 
-
 class EmbeddingManager:
     """Gestionnaire des embeddings et de ChromaDB."""
 
@@ -34,6 +41,7 @@ class EmbeddingManager:
         self,
         model_name: str = MODEL_NAME,
         collection_name: str = CHROMA_COLLECTION_NAME,
+        cross_encoder_model_name: str = CROSS_ENCODER_MODEL_NAME,
     ) -> None:
         """
         Initialiser le gestionnaire d'embeddings.
@@ -41,13 +49,34 @@ class EmbeddingManager:
         Args:
             model_name: Nom du modèle Sentence-Transformers à utiliser
             collection_name: Nom de la collection ChromaDB
+            cross_encoder_model_name: Nom du modèle Cross-Encoder utilisé pour le re-ranking
         """
+        # Table de traduction pré-compilée une seule fois (au chargement du module)
+        self._TRANSLATION_TABLE = str.maketrans({
+            "’": "'", "‘": "'",
+            "«": '"', "»": '"',
+            "“": '"', "”": '"',
+            "–": "-", "—": "-",
+            "?": ""
+        })
+        if "-e5-" in model_name:
+            logger.info(f"Modèle {model_name} détecté comme modèle E5.")
+            self._prefix_p = "passage: "
+            self._prefix_q = "query: "
+        else:
+            self._prefix_p = ""
+            self._prefix_q = ""
 
         # Creation du Sentence transformer model
         logger.info(f"Initialisation du modèle d'embeddings: {model_name}")
         device = "cuda" if torch.cuda.is_available() else "cpu"
         self.model = SentenceTransformer(MODEL_NAME, device=device)
 
+        # Création du modèle Cross-Encoder utilisé pour le re-ranking
+        logger.info(f"Initialisation du modèle Cross-Encoder: {cross_encoder_model_name}")
+        self.cross_encoder = CrossEncoder(cross_encoder_model_name, device=device)
+        self.cross_encoder_model_name: str = cross_encoder_model_name
+
         # Initialiser ChromaDB en mémoire (EphemeralClient)
         # Idéal pour HF Spaces: pas de persistance disque, plus rapide au startup
         logger.info("Initialisation ChromaDB en mémoire (EphemeralClient)")
@@ -80,7 +109,7 @@ class EmbeddingManager:
             self.collection.delete(ids=existing_ids)
 
         # Générer les embeddings pour toutes les formulations
-        formulations: list[str] = [entry.formulation for entry in faq_entries]
+        formulations: list[str] = [self._prefix_p + self._normalize_text(entry.formulation) for entry in faq_entries]
         logger.info("Génération des embeddings...")
         embeddings = self.model.encode(formulations, show_progress_bar=True,
                                          convert_to_numpy=True, normalize_embeddings=True)
@@ -102,29 +131,102 @@ class EmbeddingManager:
 
         logger.info(f"✓ ChromaDB peuplée avec {len(faq_entries)} entrées")
 
+    def _filter_and_dedup_by_theme(
+        self,
+        documents: list[str],
+        metadatas: list[dict],
+        distances: list[float],
+        similarity_threshold: float,
+        top_k: int,
+    ) -> list[SemanticSearchCandidate]:
+        """
+        Filtre les candidats Chroma par seuil de similarité cosinus, puis conserve
+        une seule formulation (la meilleure) par thème, jusqu'à obtenir `top_k`
+        thèmes distincts.
+
+        Les résultats de Chroma étant triés par similarité décroissante, la
+        fonction s'arrête dès que le seuil n'est plus atteint ou que `top_k`
+        thèmes distincts ont été retenus.
+        """
+        seen_themes: set[str] = set()
+        candidates: list[SemanticSearchCandidate] = []
+
+        for document, metadata, distance in zip(
+            documents,
+            metadatas,
+            distances,
+            strict=True,
+        ):
+            similarity = 1.0 - distance
+
+            # Les résultats étant triés par similarité décroissante,
+            # tous les suivants seront également sous le seuil.
+            if similarity < similarity_threshold:
+                break
+
+            theme = metadata["theme"]
+
+            if theme not in seen_themes:
+                seen_themes.add(theme)
+
+                candidates.append(
+                    SemanticSearchCandidate(
+                        formulation=document,
+                        theme=theme,
+                        response=metadata["response"],
+                        similarity_score=similarity,
+                    )
+                )
+
+                if len(candidates) == top_k:
+                    break
+
+        return candidates
+
     def search_similar_faq(self, payload: QuestionInput) -> AnswerOutput:
         """
-        Rechercher dans la FAQ la formulation laplus similaire à une question donnée.
+        Rechercher dans la FAQ la formulation la plus pertinente pour une question donnée.
+
+        Étapes :
+        1. Récupération des candidats dans ChromaDB (similarité cosinus), filtrés
+           par SIMILARITY_THRESHOLD et dédupliqués pour ne garder qu'une
+           formulation par thème, limités à top_k.
+        2. Re-ranking de ces top_k candidats avec un Cross-Encoder (question, formulation).
+        3. Retour de la réponse associée au meilleur score Cross-Encoder si celui-ci
+           dépasse le seuil fourni, sinon message de repli.
 
         Args:
-            question: Question à chercher
-            threshold: Seuil de confiance minimum pour retourner une réponse
+            payload: QuestionInput contenant la question, et éventuellement
+                     threshold (cosinus), top_k et le seuil cross-encoder.
 
         Returns:
-            Tuple (formulation, theme, response, similarity_score) ou None si aucun match
+            AnswerOutput
         """
-        # Récupérer la question et le seuil depuis le payload
+        # Récupérer la question et les paramètres depuis le payload
         question = payload.question
-        threshold = payload.threshold if payload.threshold is not None else SIMILARITY_THRESHOLD
+        similarity_threshold = payload.similarity_threshold if payload.similarity_threshold is not None else SIMILARITY_THRESHOLD
+        top_k = getattr(payload, "top_k", None) or TOP_K
+        cross_encoder_threshold = (
+            getattr(payload, "cross_encoder_threshold", None)
+            if getattr(payload, "cross_encoder_threshold", None) is not None
+            else CROSS_ENCODER_THRESHOLD
+        )
 
         # Générer l'embedding de la question
-        question_embedding = self.model.encode([question], convert_to_numpy=True,
-                                                normalize_embeddings=True).tolist()
+        question_embedding = self.model.encode(
+            [self._prefix_q + self._normalize_text(question)],
+            convert_to_numpy=True,
+            normalize_embeddings=True,
+        ).tolist()
+
+        # On récupère un pool de candidats plus large que top_k auprès de Chroma,
+        # car plusieurs formulations peuvent partager le même thème et doivent être
+        # dédupliquées avant d'atteindre top_k thèmes distincts.
+        n_candidates = max(top_k * 5, 20)
 
-        # Rechercher dans ChromaDB
         results = self.collection.query(
             query_embeddings=question_embedding,
-            n_results=1,
+            n_results=n_candidates,
             include=["documents", "metadatas", "distances"]
         )
 
@@ -133,48 +235,84 @@ class EmbeddingManager:
             return AnswerOutput(
                 question=question,
                 formulation="unknown",
-                answer="Je ne dispose pas d'une réponse suffisamment pertinente pour cette question.",
+                answer="Je ne dispose pas d'éléments de réponse pour cette question.",
                 theme="unknown",
                 similarity_score=0.0,
                 confidence=False,
             )
 
-        # Extraire le meilleur résultat
-        # ChromaDB retourne les produits scalaires, on convertit en similarité cosinus
-        distance = results["distances"][0][0]
-        similarity_score: float = 1 - distance
-
-        # Extraire les métadonnées
-        metadata = results["metadatas"][0][0]
-        formulation = results["documents"][0][0]
-        theme = metadata["theme"]
-        response = metadata["response"]
+        # Filtrer par seuil cosinus et dédupliquer par thème (top_k thèmes distincts)
+        candidates = self._filter_and_dedup_by_theme(
+            documents=results["documents"][0],
+            metadatas=results["metadatas"][0],
+            distances=results["distances"][0],
+            similarity_threshold=similarity_threshold,
+            top_k=top_k,
+        )
 
-        # Vérifier le seuil
-        if similarity_score < threshold:
+        if not candidates:
             logger.info(
-                f"Score de similarité {similarity_score:.3f} < seuil {threshold}. "
+                f"Aucun candidat au-dessus du seuil cosinus {similarity_threshold}. "
                 f"Question: {question}"
             )
             return AnswerOutput(
                 question=question,
-                formulation=formulation,
+                formulation="unknown",
+                answer="Je ne dispose pas d'éléments de réponse pour cette question.",
+                theme="unknown",
+                similarity_score=0.0,
+                confidence=False,
+            )
+
+        # Appliquer le Cross-Encoder entre la question et chaque formulation candidate
+        pairs = [(question, candidate.formulation) for candidate in candidates]
+        cross_scores = self.cross_encoder.predict(pairs)
+
+        for candidate, cross_score in zip(candidates, cross_scores):
+            candidate.cross_encoder_score = float(cross_score)
+
+        # Sélectionner le meilleur score cross-encoder
+        best_candidate = max(
+            candidates,
+            key=lambda c: c.cross_encoder_score if c.cross_encoder_score is not None else float("-inf"),
+        )
+
+        logger.info(
+            "Candidats re-classés par cross-encoder: "
+            + ", ".join(
+                f"[{c.theme}: {c.cross_encoder_score:.3f}]" for c in candidates
+            )
+        )
+
+        if best_candidate.cross_encoder_score is None or best_candidate.cross_encoder_score < cross_encoder_threshold:
+            logger.info(
+                f"Meilleur score cross-encoder {best_candidate.cross_encoder_score:.3f} "
+                f"< seuil {cross_encoder_threshold}. Question: {question}"
+            )
+            return AnswerOutput(
+                question=question,
+                formulation=best_candidate.formulation,
                 answer="Je ne dispose pas d'une réponse suffisamment pertinente pour cette question.",
-                theme=theme,
-                similarity_score=round(similarity_score, 4),
+                theme=best_candidate.theme,
+                similarity_score=round(best_candidate.similarity_score or 0.0, 4),
+                cross_encoder_score=round(best_candidate.cross_encoder_score or 0.0, 4),
+                list_candidates=candidates,
                 confidence=False,
             )
 
         logger.info(
-            f"Match trouvé - Theme: {theme}, Score: {similarity_score:.3f}"
+            f"Match trouvé - Theme: {best_candidate.theme}, "
+            f"Score cross-encoder: {best_candidate.cross_encoder_score:.3f}"
         )
 
         return AnswerOutput(
             question=question,
-            formulation=formulation,
-            answer=response,
-            theme=theme,
-            similarity_score=round(similarity_score, 4),
+            formulation=best_candidate.formulation,
+            answer=best_candidate.response,
+            theme=best_candidate.theme,
+            similarity_score=round(best_candidate.similarity_score or 0.0, 4),
+            cross_encoder_score=round(best_candidate.cross_encoder_score or 0.0, 4),
+            list_candidates=candidates,
             confidence=True,
         )
 
@@ -186,3 +324,15 @@ class EmbeddingManager:
             Nombre de documents
         """
         return self.collection.count()
+
+    def _normalize_text(self, text: str) -> str:
+        # Uniformise les apostrophes et guillemets typographiques
+        text = text.translate(self._TRANSLATION_TABLE)
+
+        # Normalise les caractères unicode équivalents (NFC)
+        text = unicodedata.normalize("NFC", text)
+
+        # Espaces multiples, trim (déjà optimal : split()+join en C)
+        text = " ".join(text.split())
+
+        return text

embeddings_v1.py

@@ -0,0 +1,247 @@
+"""Gestion des embeddings avec ChromaDB et Hugging Face Transformers."""
+import os
+# Règle d’or : toute variable d’environnement qui influence le cache Hugging Face doit être
+# définie avant d’importer datasets ou transformers, sinon elle sera ignorée.
+cache_dir = "/tmp"
+os.makedirs(cache_dir, exist_ok=True)
+
+# Rediriger le cache HF globalement
+os.environ["HF_HOME"] = cache_dir
+os.environ["HF_DATASETS_CACHE"] = os.path.join(cache_dir, "datasets")
+os.environ["TRANSFORMERS_CACHE"] = os.path.join(cache_dir, "transformers")
+
+# Désactiver la télémétrie ChromaDB/PostHog pour éviter les erreurs de signature
+# de capture() sur certaines versions de dependent packages.
+os.environ.setdefault("CHROMA_DISABLE_TELEMETRY", "1")
+os.environ.setdefault("CHROMADB_DISABLE_TELEMETRY", "1")
+os.environ.setdefault("POSTHOG_DISABLED", "1")
+
+import logging
+from typing import Optional
+from models import QuestionInput, AnswerOutput
+import unicodedata
+import chromadb
+from sentence_transformers import SentenceTransformer
+import torch
+from config import (
+    CHROMA_COLLECTION_NAME,
+    MODEL_NAME,
+    SIMILARITY_THRESHOLD,
+)
+from faq_loader import FAQEntry
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingManager:
+    """Gestionnaire des embeddings et de ChromaDB."""
+
+    def __init__(
+        self,
+        model_name: str = MODEL_NAME,
+        collection_name: str = CHROMA_COLLECTION_NAME,
+    ) -> None:
+        """
+        Initialiser le gestionnaire d'embeddings.
+
+        Args:
+            model_name: Nom du modèle Sentence-Transformers à utiliser
+            collection_name: Nom de la collection ChromaDB
+        """
+        # Table de traduction pré-compilée une seule fois (au chargement du module)
+        self._TRANSLATION_TABLE = str.maketrans({
+            "’": "'", "‘": "'",
+            "«": '"', "»": '"',
+            "“": '"', "”": '"',
+            "–": "-", "—": "-",
+            "?": ""
+        })
+        if "-e5-" in model_name:
+            logger.info(f"Modèle {model_name} détecté comme modèle E5.")
+            self._prefix_p = "passage: "
+            self._prefix_q = "query: "
+        else:
+            self._prefix_p = ""
+            self._prefix_q = ""
+
+        # Creation du Sentence transformer model
+        logger.info(f"Initialisation du modèle d'embeddings: {model_name}")
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = SentenceTransformer(MODEL_NAME, device=device)
+
+        # Initialiser ChromaDB en mémoire (EphemeralClient)
+        # Idéal pour HF Spaces: pas de persistance disque, plus rapide au startup
+        logger.info("Initialisation ChromaDB en mémoire (EphemeralClient)")
+        self.client: chromadb.Client = chromadb.EphemeralClient()
+
+        # Créer ou récupérer la collection
+        self.collection = self.client.get_or_create_collection(
+            name=collection_name,
+            embedding_function=None,
+            metadata={"hnsw:space": "ip"}  # Utiliser produit scalaire => normaliser les embeddings
+        )
+
+        self.collection_name: str = collection_name
+        logger.info(f"✓ EmbeddingManager initialisé (collection: {collection_name})")
+
+    def populate_collection(self, faq_entries: list[FAQEntry]) -> None:
+        """
+        Remplir la collection ChromaDB avec les embeddings des FAQ.
+
+        Args:
+            faq_entries: Liste d'objets FAQEntry à indexer
+        """
+        logger.info(f"Population de ChromaDB avec {len(faq_entries)} entrées...")
+
+        # Vider la collection existante (optionnel, mais plus propre)
+        # Récupérer l'ID de collection pour supprimer les anciens documents
+        existing_ids = self.collection.get()["ids"]
+        if existing_ids:
+            logger.info(f"Suppression de {len(existing_ids)} anciens documents...")
+            self.collection.delete(ids=existing_ids)
+
+        # Générer les embeddings pour toutes les formulations
+        formulations: list[str] = [self._prefix_p + self._normalize_text(entry.formulation) for entry in faq_entries]
+        logger.info("Génération des embeddings...")
+        embeddings = self.model.encode(formulations, show_progress_bar=True,
+                                         convert_to_numpy=True, normalize_embeddings=True)
+
+        # Ajouter à ChromaDB
+        logger.info("Ajout des documents à ChromaDB...")
+        self.collection.add(
+            ids=[f"faq_{i}" for i in range(len(faq_entries))],
+            embeddings=embeddings.tolist(),
+            documents=formulations,
+            metadatas=[
+                {
+                    "theme": entry.theme,
+                    "response": entry.response,
+                }
+                for entry in faq_entries
+            ],
+        )
+
+        logger.info(f"✓ ChromaDB peuplée avec {len(faq_entries)} entrées")
+
+    def search_similar_faq(self, payload: QuestionInput) -> AnswerOutput:
+        """
+        Rechercher dans la FAQ la formulation laplus similaire à une question donnée.
+
+        Args:
+            question: Question à chercher
+            threshold: Seuil de confiance minimum pour retourner une réponse
+
+        Returns:
+            Tuple (formulation, theme, response, similarity_score) ou None si aucun match
+        """
+        # Récupérer la question, le seuil et le nombre de résultats à considérer
+        question = payload.question
+        threshold = payload.threshold if payload.threshold is not None else SIMILARITY_THRESHOLD
+        top_k = payload.top_k if payload.top_k is not None else 1
+        top_k = max(1, top_k)
+
+        # Générer l'embedding de la question
+        question_embedding = self.model.encode([self._prefix_q + self._normalize_text(question)], convert_to_numpy=True,
+                                                normalize_embeddings=True).tolist()
+
+        # Rechercher dans ChromaDB avec plusieurs résultats potentiels
+        results = self.collection.query(
+            query_embeddings=question_embedding,
+            n_results=top_k,
+            include=["documents", "metadatas", "distances"]
+        )
+
+        if not results["ids"] or not results["ids"][0]:
+            logger.warning(f"Aucun résultat trouvé pour: {question}")
+            return AnswerOutput(
+                question=question,
+                formulation="unknown",
+                answer="Je ne dispose pas d'une réponse suffisamment pertinente pour cette question.",
+                theme="unknown",
+                similarity_score=0.0,
+                confidence=False,
+            )
+
+        # Extraire le meilleur résultat parmi les candidats retournés par Chroma
+        # ChromaDB retourne les produits scalaires, on convertit en similarité cosinus
+        best_match = None
+        for index in range(len(results["ids"][0])):
+            distance = results["distances"][0][index]
+            similarity_score: float = 1 - distance
+
+            metadata = results["metadatas"][0][index]
+            formulation = results["documents"][0][index]
+            theme = metadata["theme"]
+            response = metadata["response"]
+
+            candidate = {
+                "formulation": formulation,
+                "theme": theme,
+                "response": response,
+                "similarity_score": similarity_score,
+            }
+
+            if best_match is None or candidate["similarity_score"] > best_match["similarity_score"]:
+                best_match = candidate
+
+        if best_match is None:
+            logger.warning(f"Aucun candidat exploitable trouvé pour: {question}")
+            return AnswerOutput(
+                question=question,
+                formulation="unknown",
+                answer="Je ne dispose pas d'une réponse suffisamment pertinente pour cette question.",
+                theme="unknown",
+                similarity_score=0.0,
+                confidence=False,
+            )
+
+        similarity_score = round(best_match["similarity_score"], 4)
+
+        # Vérifier le seuil
+        if similarity_score < threshold:
+            logger.info(
+                f"Score de similarité {similarity_score:.3f} < seuil {threshold}. "
+                f"Question: {question}"
+            )
+            return AnswerOutput(
+                question=question,
+                formulation=best_match["formulation"],
+                answer="Je ne dispose pas d'une réponse suffisamment pertinente pour cette question.",
+                theme=best_match["theme"],
+                similarity_score=similarity_score,
+                confidence=False,
+            )
+
+        logger.info(
+            f"Match trouvé - Theme: {best_match['theme']}, Score: {similarity_score:.3f}"
+        )
+
+        return AnswerOutput(
+            question=question,
+            formulation=best_match["formulation"],
+            answer=best_match["response"],
+            theme=best_match["theme"],
+            similarity_score=similarity_score,
+            confidence=True,
+        )
+
+    def get_collection_size(self) -> int:
+        """
+        Obtenir le nombre de documents dans la collection.
+
+        Returns:
+            Nombre de documents
+        """
+        return self.collection.count()
+
+    def _normalize_text(self, text: str) -> str:
+        # Uniformise les apostrophes et guillemets typographiques
+        text = text.translate(self._TRANSLATION_TABLE)
+
+        # Normalise les caractères unicode équivalents (NFC)
+        text = unicodedata.normalize("NFC", text)
+
+        # Espaces multiples, trim (déjà optimal : split()+join en C)
+        text = " ".join(text.split())
+
+        return text

models.py

@@ -1,4 +1,5 @@
 """Modèles Pydantic pour les requêtes et réponses API."""
+from dataclasses import dataclass
 from typing import Optional
 
 from pydantic import BaseModel, Field, ConfigDict
@@ -11,8 +12,10 @@ class QuestionInput(BaseModel):
         None,
         ge=0.0,
         le=1.0,
-        description="Seuil de similarité cosinus souhaité entre 0.0 et 1.0. Si omis, la valeur par défaut du service est utilisée.",
+        description="Seuil de similarité cosinus souhaité entre 0.0 et 1.0.",
     )
+    top_k: Optional[int] = None
+    cross_encoder_threshold: Optional[float] = None
 
     model_config = ConfigDict(
         json_schema_extra={
@@ -23,6 +26,14 @@ class QuestionInput(BaseModel):
         }
     )
 
+@dataclass(slots=True)
+class SemanticSearchCandidate:
+    """Candidat issu de la recherche sémantique."""
+    formulation: str
+    theme: str
+    response: str
+    similarity_score: float
+    cross_encoder_score: float | None = None
 
 class AnswerOutput(BaseModel):
     """Modèle pour une réponse de sortie."""
@@ -31,7 +42,9 @@ class AnswerOutput(BaseModel):
     answer: str = Field(..., description="Réponse trouvée dans la base FAQ")
     theme: str = Field(..., description="Thème/catégorie de la réponse")
     similarity_score: float = Field(..., ge=0.0, le=1.0, description="Score de similarité cosinus [0, 1]")
+    cross_encoder_score: Optional[float] = Field(None, ge=0.0, le=1.0, description="Score du cross-encoder [0, 1]")
     confidence: bool = Field(..., description="True si score >= seuil de confiance, False sinon")
+    list_candidates: Optional[list[SemanticSearchCandidate]] = Field(None, description="Liste des candidats sémantiques")
 
     model_config = ConfigDict(
         json_schema_extra={
@@ -41,7 +54,9 @@ class AnswerOutput(BaseModel):
                 "answer": "Tu peux soit 'tinscrire, soit commencer ta candidature depuis le bouton « Inscription » du site. Tu renseigneras ton profil, tes compétences et les domaines qui t’intéressent afin que l’équipe puisse étudier ta candidature.",
                 "theme": "comment_rejoindre_guild_open_tech",
                 "similarity_score": 0.889,
-                "confidence": True
+                "cross_encoder_score": 0.95,
+                "confidence": True,
+                "list_candidates": []
             }
         }
     )