Reclassifieurs

Les reclassifieurs appliquent un système de notation plus sophistiqué pour améliorer la qualité du classement. La récupération initiale est rapide mais approximative ; les reclassifieurs utilisent des modèles ou une logique plus approfondis pour affiner les résultats.

Search Toolkit propose des reclassifieurs dans deux catégories :

ReRanker — traite une seule liste de résultats (LLMReRanker, CrossEncoderReRanker)
GroupedRanker — traite plusieurs groupes de résultats (RRFRanker pour la fusion)

Plusieurs reclassifieurs peuvent être enchaînés dans la liste QueryEngine.rerankers et sont appliqués séquentiellement.

Reclassifieurs disponibles

Reclassifieur	Type	Usage
Reclassifieur LLM	ReRanker	Notation de pertinence approfondie à l’aide d’un LLM
Reclassifieur Cross-Encoder	ReRanker	Reclassement rapide à l’aide d’un modèle dédié
RRF Ranker	GroupedRanker	Fusionne les résultats de plusieurs outils de récupération
Reclassifieurs personnalisés	ReRanker / GroupedRanker	Logique de notation et fusion personnalisée

Reclassifieur LLM

Utilise un modèle de langage pour renoter les résultats avec une compréhension approfondie de leur pertinence par rapport à la requête.

Installation : bibliothèque principale (aucune dépendance supplémentaire requise)

Exemple :

from mistralai.search.toolkit.retrieval.rerankers import LLMReRanker
from mistralai.search.toolkit.retrieval import QueryEngine
from mistralai.search.toolkit.llm import MistralChat, LLMConfig
from mistralai.client import Mistral

llm = MistralChat(
    client=Mistral(api_key="your-api-key"),
    config=LLMConfig(
        model="mistral-small-latest",
        temperature=0.1,
        response_format={"type": "json_object"},
    ),
)

reranker = LLMReRanker(
    llm_provider=llm,
    top_k=10,  # Return top 10 after reranking
)

# Use in QueryEngine
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[reranker],
)

result = await query_engine.search(query="What is RAG?", top_k=10)

from mistralai.search.toolkit.retrieval.rerankers import LLMReRanker
from mistralai.search.toolkit.retrieval import QueryEngine
from mistralai.search.toolkit.llm import MistralChat, LLMConfig
from mistralai.client import Mistral

llm = MistralChat(
    client=Mistral(api_key="your-api-key"),
    config=LLMConfig(
        model="mistral-small-latest",
        temperature=0.1,
        response_format={"type": "json_object"},
    ),
)

reranker = LLMReRanker(
    llm_provider=llm,
    top_k=10,  # Return top 10 after reranking
)

# Use in QueryEngine
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[reranker],
)

result = await query_engine.search(query="What is RAG?", top_k=10)

Options de configuration :

Option	Type	Valeur par défaut	Usage
`llm_provider`	LLMProvider	Obligatoire	LLM à utiliser pour la notation (Mistral Large, etc.)
`top_k`	int	10	Nombre de résultats à renvoyer après reclassement
`batch_size`	int	10	Taille du batch pour la notation par LLM

Fonctionnement :

Le LLM reçoit la requête et les fragments récupérés
Le LLM note la pertinence de chaque fragment
Les fragments sont triés selon la note du LLM
Les k principaux résultats sont renvoyés

Quand l’utiliser :

Évaluations de pertinence sémantique au-delà de la similarité vectorielle
Nécessite des connaissances domaines complexes pour le classement
Après une récupération initiale pour améliorer la qualité
Tolérance à un débit plus faible (les appels LLM sont plus lents)

Optimisation des coûts :

Le reclassement par LLM est coûteux (1 appel LLM par fragment). Réduisez les coûts en :

# 1. Get many results from retriever (fast)
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[LLMReRanker(llm_provider=llm, top_k=10)],
)

# 2. Vector retriever returns top 100 to reranker (cheaper than querying LLM for all)
result = await query_engine.search(query="...", top_k=10)

# 1. Get many results from retriever (fast)
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[LLMReRanker(llm_provider=llm, top_k=10)],
)

# 2. Vector retriever returns top 100 to reranker (cheaper than querying LLM for all)
result = await query_engine.search(query="...", top_k=10)

Reclassifieur Cross-Encoder

Utilise un modèle cross-encoder hébergé optimisé pour le reclassement. Plus rapide que le reclassement par LLM, mais nécessite un serveur dédié pour le modèle.

Installation : bibliothèque principale (aucune dépendance supplémentaire requise)

Exemple :

from mistralai.search.toolkit.retrieval.rerankers import CrossEncoderReRanker
from mistralai.search.toolkit.retrieval import QueryEngine

reranker = CrossEncoderReRanker(
    base_url="http://localhost:8080",  # Cross-encoder service endpoint
    model="cross-encoder/ms-marco-MiniLM-L-6-v2",
    top_k=10,
)

query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[reranker],
)

result = await query_engine.search(query="What is RAG?", top_k=10)

from mistralai.search.toolkit.retrieval.rerankers import CrossEncoderReRanker
from mistralai.search.toolkit.retrieval import QueryEngine

reranker = CrossEncoderReRanker(
    base_url="http://localhost:8080",  # Cross-encoder service endpoint
    model="cross-encoder/ms-marco-MiniLM-L-6-v2",
    top_k=10,
)

query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[reranker],
)

result = await query_engine.search(query="What is RAG?", top_k=10)

Options de configuration :

Option	Type	Valeur par défaut	Usage
`base_url`	str	Obligatoire	URL du service cross-encoder
`model`	str	Obligatoire	Identifiant du modèle sur le service
`top_k`	int	10	Nombre de résultats à renvoyer
`timeout`	int	30	Délai d’attente de la requête en secondes

Modèles populaires :

cross-encoder/ms-marco-MiniLM-L-6-v2 — Rapide, usage général
cross-encoder/ms-marco-TinyBERT-L-2-v2 — Léger, faible latence
cross-encoder/qnli-distilroberta-base — Appariement questions-réponses

Quand l’utiliser :

Besoin de reclassement mais souhaitez éviter les coûts des LLM
Avoir un service cross-encoder dédié en cours d’exécution
Nécessiter un reclassement rapide (plus rapide que les LLM)
Jeux de données de pertinence standard (MS MARCO, Natural Questions)

Reclassifieurs personnalisés

Implémentez le protocole ReRanker pour le reclassement d’une seule liste :

from mistralai.search.toolkit.retrieval.rerankers import ReRanker
from mistralai.search.toolkit.indices import SearchResult

class MetadataReRanker(ReRanker):
    """Boost results based on metadata."""

    async def rerank(
        self, query: str, search_results: list[SearchResult]
    ) -> list[SearchResult]:
        """Re-score results by boosting verified content."""
        for result in search_results:
            # Boost chunks with verified metadata
            if result.chunk.metadata.get("verified"):
                result.score *= 1.5

            # Penalize outdated content
            if result.chunk.metadata.get("year") and result.chunk.metadata["year"] < 2020:
                result.score *= 0.8

        # Return sorted by new score
        return sorted(search_results, key=lambda x: x.score, reverse=True)


# Use in QueryEngine
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[MetadataReRanker()],
)

from mistralai.search.toolkit.retrieval.rerankers import ReRanker
from mistralai.search.toolkit.indices import SearchResult

class MetadataReRanker(ReRanker):
    """Boost results based on metadata."""

    async def rerank(
        self, query: str, search_results: list[SearchResult]
    ) -> list[SearchResult]:
        """Re-score results by boosting verified content."""
        for result in search_results:
            # Boost chunks with verified metadata
            if result.chunk.metadata.get("verified"):
                result.score *= 1.5

            # Penalize outdated content
            if result.chunk.metadata.get("year") and result.chunk.metadata["year"] < 2020:
                result.score *= 0.8

        # Return sorted by new score
        return sorted(search_results, key=lambda x: x.score, reverse=True)


# Use in QueryEngine
query_engine = QueryEngine(
    retriever=vector_retriever,
    rerankers=[MetadataReRanker()],
)

Implémentez le protocole GroupedRanker pour la fusion multi-groupes :

from mistralai.search.toolkit.retrieval.rerankers import GroupedRanker
from mistralai.search.toolkit.indices import SearchResult

class CustomFusionRanker(GroupedRanker):
    """Custom fusion of multiple retriever results."""

    async def rerank_groups(
        self, query: str, result_groups: list[list[SearchResult]]
    ) -> list[SearchResult]:
        """Fuse multiple retriever results with custom logic."""
        # result_groups[0] = vector retriever results
        # result_groups[1] = keyword retriever results
        # etc.

        # Custom fusion logic
        fused = self._custom_fusion(query, result_groups)
        return fused

    def _custom_fusion(self, query: str, groups: list[list[SearchResult]]) -> list[SearchResult]:
        # Implement your fusion algorithm
        ...

from mistralai.search.toolkit.retrieval.rerankers import GroupedRanker
from mistralai.search.toolkit.indices import SearchResult

class CustomFusionRanker(GroupedRanker):
    """Custom fusion of multiple retriever results."""

    async def rerank_groups(
        self, query: str, result_groups: list[list[SearchResult]]
    ) -> list[SearchResult]:
        """Fuse multiple retriever results with custom logic."""
        # result_groups[0] = vector retriever results
        # result_groups[1] = keyword retriever results
        # etc.

        # Custom fusion logic
        fused = self._custom_fusion(query, result_groups)
        return fused

    def _custom_fusion(self, query: str, groups: list[list[SearchResult]]) -> list[SearchResult]:
        # Implement your fusion algorithm
        ...

RRF Ranker

Reciprocal Rank Fusion (RRF) combine les résultats de plusieurs outils de récupération en utilisant leurs positions. Utile pour fusionner différentes stratégies de récupération sur le même index.

Installation : bibliothèque principale (aucune dépendance supplémentaire requise)

Exemple — plusieurs outils de récupération vectorielle avec différents profils de requête :

from mistralai.client import Mistral
from mistralai.search.toolkit.embedders import MistralEmbedder, MODEL_1024_EMBEDDING
from mistralai.search.toolkit.retrieval.retrievers import VectorRetriever
from mistralai.search.toolkit.retrieval.rerankers import RRFRanker
from mistralai.search.toolkit.retrieval import QueryEngine
from mistralai.search.toolkit.plugins.vespa import VespaClientConfig
from vespa_app import app

# Initialize embedder for query vectorization
embedder = MistralEmbedder(
    client=Mistral(api_key="your-api-key"),
    model_name=MODEL_1024_EMBEDDING,
)

# Create Vespa search backends with different query profiles
config = VespaClientConfig(
    endpoint="http://localhost:8080",
)

# Use different query profiles for dense and hybrid search
dense_store = app.get_search_index(config, collection_name="my_collection", query_profile="dense")
hybrid_store = app.get_search_index(config, collection_name="my_collection", query_profile="hybrid")

# Create retrievers with different strategies
dense_retriever = VectorRetriever(client=dense_store, embedder=embedder)
hybrid_retriever = VectorRetriever(client=hybrid_store, embedder=embedder)

# Fuse results with RRF
query_engine = QueryEngine(
    retriever=[dense_retriever, hybrid_retriever],
    rerankers=[RRFRanker(rrf_k=60, top_k=10)],
)

result = await query_engine.search(query="How does RAG work?", top_k=10)

from mistralai.client import Mistral
from mistralai.search.toolkit.embedders import MistralEmbedder, MODEL_1024_EMBEDDING
from mistralai.search.toolkit.retrieval.retrievers import VectorRetriever
from mistralai.search.toolkit.retrieval.rerankers import RRFRanker
from mistralai.search.toolkit.retrieval import QueryEngine
from mistralai.search.toolkit.plugins.vespa import VespaClientConfig
from vespa_app import app

# Initialize embedder for query vectorization
embedder = MistralEmbedder(
    client=Mistral(api_key="your-api-key"),
    model_name=MODEL_1024_EMBEDDING,
)

# Create Vespa search backends with different query profiles
config = VespaClientConfig(
    endpoint="http://localhost:8080",
)

# Use different query profiles for dense and hybrid search
dense_store = app.get_search_index(config, collection_name="my_collection", query_profile="dense")
hybrid_store = app.get_search_index(config, collection_name="my_collection", query_profile="hybrid")

# Create retrievers with different strategies
dense_retriever = VectorRetriever(client=dense_store, embedder=embedder)
hybrid_retriever = VectorRetriever(client=hybrid_store, embedder=embedder)

# Fuse results with RRF
query_engine = QueryEngine(
    retriever=[dense_retriever, hybrid_retriever],
    rerankers=[RRFRanker(rrf_k=60, top_k=10)],
)

result = await query_engine.search(query="How does RAG work?", top_k=10)

Options de configuration :

Option	Type	Valeur par défaut	Usage
`rrf_k`	int	60	Facteur de lissage (essayez entre 30 et 100)
`top_k`	int	10	Nombre de résultats à renvoyer

Optimisation du RRF :

# Lower rrf_k = more emphasis on exact rank positions
RRFRanker(rrf_k=30, top_k=10)  # Lower k, more differentiation

# Higher rrf_k = less emphasis on rank positions
RRFRanker(rrf_k=100, top_k=10)  # Higher k, flattens differences

# Lower rrf_k = more emphasis on exact rank positions
RRFRanker(rrf_k=30, top_k=10)  # Lower k, more differentiation

# Higher rrf_k = less emphasis on rank positions
RRFRanker(rrf_k=100, top_k=10)  # Higher k, flattens differences

Quand l’utiliser :

Combinaison de plusieurs stratégies de récupération sur le même index (vecteurs denses, recherche hybride, etc.)
Résultats provenant de plusieurs sources avec des notes incomparables
Aucun modèle ou contrainte de coût supplémentaire
Fusion robuste qui ne nécessite pas de normalisation des notes

Chaînage des reclassifieurs

Plusieurs reclassifieurs peuvent être appliqués en séquence pour un affinage progressif :

from mistralai.search.toolkit.retrieval.rerankers import RRFRanker, LLMReRanker

query_engine = QueryEngine(
    retriever=[dense_retriever, hybrid_retriever],
    rerankers=[
        RRFRanker(rrf_k=60, top_k=50),           # Step 1: Fuse results → top 50
        MetadataReRanker(),                       # Step 2: Boost verified content
        LLMReRanker(llm_provider=llm, top_k=10),  # Step 3: Final LLM reranking
    ],
)

# Process flow:
# 1. Multiple retrievers return results
# 2. RRFRanker fuses them → top 50
# 3. MetadataReRanker applies scoring boost → still ~50
# 4. LLMReRanker scores → top 10
# Total cost: 1 RRF operation + metadata checks + 10 LLM calls (not 100+)
result = await query_engine.search(query="...", top_k=10)

from mistralai.search.toolkit.retrieval.rerankers import RRFRanker, LLMReRanker

query_engine = QueryEngine(
    retriever=[dense_retriever, hybrid_retriever],
    rerankers=[
        RRFRanker(rrf_k=60, top_k=50),           # Step 1: Fuse results → top 50
        MetadataReRanker(),                       # Step 2: Boost verified content
        LLMReRanker(llm_provider=llm, top_k=10),  # Step 3: Final LLM reranking
    ],
)

# Process flow:
# 1. Multiple retrievers return results
# 2. RRFRanker fuses them → top 50
# 3. MetadataReRanker applies scoring boost → still ~50
# 4. LLMReRanker scores → top 10
# Total cost: 1 RRF operation + metadata checks + 10 LLM calls (not 100+)
result = await query_engine.search(query="...", top_k=10)

Bonnes pratiques :

Commencez par des opérations peu coûteuses (fusion RRF, boost de métadonnées)
Terminez par des opérations coûteuses (reclassement par LLM)
Utilisez les reclassifieurs pour réduire progressivement les résultats et les coûts

Voir aussi

Présentation de la récupération — Architecture de la pipeline de récupération
Outils de récupération — Recherche vectorielle et outils de récupération personnalisés
Prétraitement des requêtes — Améliorer les requêtes avant récupération