Home
Studio

Récupérateurs

Les retrievers exécutent la recherche sur votre index. Search Toolkit fournit des retrievers vectoriels (sémantiques) et par mots-clés (BM25), que vous pouvez combiner pour une recherche hybride.

Récupérateurs disponibles

Récupérateurs disponibles

RécupérateurUsage
Récupérateur vectorielRecherche sémantique à l’aide d’embeddings
Retriever par mots-clésRecherche BM25 / par mots-clés
Recherche hybrideCombiner des retrievers vectoriels et par mots-clés
Récupérateurs personnalisésLogique de recherche personnalisée
Récupérateur vectoriel

Récupérateur vectoriel

Effectue une recherche sémantique à l’aide d’embeddings. Trouve des fragments de sens similaire à la requête, même s’ils utilisent des mots différents.

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

Exemple :

from mistralai.search.toolkit.retrieval.retrievers import VectorRetriever

retriever = VectorRetriever(
    client=vector_store,  # Vector store client (Vespa or custom implementation)
    embedder=embedder,    # MistralEmbedder or custom Embedder
)

results = await retriever.retrieve(
    query="What is semantic search?",
    top_k=10,
)

Options de configuration :

OptionTypeValeur par défautUsage
clientVectorStoreIndexObligatoireStockage vectoriel à rechercher
embedderEmbedderObligatoireEmbedder pour la vectorisation des requêtes

Quand l’utiliser :

  • Recherche sémantique générale dans vos documents
  • Trouver du contenu similaire sur le plan conceptuel
  • Gestion naturelle des synonymes et des reformulations
Retriever par mots-clés

Retriever par mots-clés

Effectue une recherche par mots-clés dans un KeywordStoreIndex. Ce retriever trouve les fragments qui partagent des termes avec la requête et les classe par pertinence lexicale.

i
Information

Les backends Vespa et Postgres intégrés n’implémentent pas KeywordStoreIndex. Utilisez KeywordRetriever avec un stockage de mots-clés personnalisé. Pour une recherche hybride avec un backend intégré, utilisez VectorRetriever ; il transmet le texte et l’embedding de la requête au backend.

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

Exemple :

from mistralai.search.toolkit.retrieval.retrievers import KeywordRetriever

retriever = KeywordRetriever(
    client=keyword_store,  # Custom KeywordStoreIndex implementation
)

results = await retriever.retrieve(
    query="quarterly revenue report",
    top_k=10,
)

Options de configuration :

OptionTypeValeur par défautUsage
clientKeywordStoreIndexObligatoireStockage de mots-clés à interroger

Quand l’utiliser :

  • Correspondance de termes exacts (noms, identifiants, codes d’erreur)
  • Requêtes où la pertinence lexicale compte plus que la sémantique
  • Comme l’un des composants d’une recherche hybride (voir ci-dessous)
Recherche hybride

Recherche hybride

Si vous disposez de stockages vectoriels et de mots-clés personnalisés distincts, exécutez les deux retrievers et fusionnez leurs résultats. Transmettez les retrievers à QueryEngine et combinez-les avec un reranker de fusion comme RRFRanker :

from mistralai.search.toolkit.retrieval import QueryEngine
from mistralai.search.toolkit.retrieval.retrievers import VectorRetriever, KeywordRetriever
from mistralai.search.toolkit.retrieval.rerankers import RRFRanker

query_engine = QueryEngine(
    retriever=[
        VectorRetriever(client=vector_store, embedder=embedder),
        KeywordRetriever(client=keyword_store),
    ],
    rerankers=[RRFRanker(rrf_k=60, top_k=10)],
)

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

Consultez Rerankers pour RRF et d’autres stratégies de fusion.

Récupérateurs personnalisés

Récupérateurs personnalisés

Implémentez le protocole Retriever pour une logique de recherche personnalisée :

from mistralai.search.toolkit.context import RetrievalContext
from mistralai.search.toolkit.retrieval.retrievers import Retriever
from mistralai.search.toolkit.search import SearchResult

class CustomRetriever(Retriever):
    """Custom retriever with domain-specific logic."""

    async def retrieve(
        self,
        query: str,
        top_k: int = 10,
        include_metadata: bool = True,
        include_content: bool = True,
        context: RetrievalContext = RetrievalContext(),
    ) -> list[SearchResult]:
        """Retrieve relevant chunks for the query."""
        # 1. Preprocess query
        processed_query = self._preprocess(query)

        # 2. Search with custom logic
        results = await self._search(processed_query, top_k)

        # 3. Post-process or augment results
        enhanced_results = self._enhance(results)

        return enhanced_results

    def _preprocess(self, query: str) -> str:
        # Custom preprocessing (stemming, lemmatization, etc.)
        return query.lower().strip()

    async def _search(self, query: str, top_k: int) -> list[SearchResult]:
        # Custom search implementation
        ...

    def _enhance(self, results: list[SearchResult]) -> list[SearchResult]:
        # Augment results with additional context
        ...

# Use in QueryEngine
query_engine = QueryEngine(retriever=CustomRetriever())
Voir aussi

Voir aussi