Récupérateurs

Les récupérateurs exécutent la recherche dans votre index. Search Toolkit propose des récupérateurs vectoriels (sémantiques) pour effectuer des recherches sémantiques dans vos documents.

Récupérateurs disponibles

Récupérateur	Usage
Récupérateur vectoriel	Recherche sémantique à l’aide d’embeddings
Récupérateurs personnalisés	Logique de recherche personnalisée

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,
)

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 :

Option	Type	Valeur par défaut	Usage
`client`	VectorStoreIndex	Obligatoire	Stockage vectoriel à rechercher
`embedder`	Embedder	Obligatoire	Embedder pour la vectorisation des requêtes

Filtrage :

Filtrez par métadonnées pour affiner les résultats :

results = await retriever.retrieve(
    query="machine learning",
    top_k=10,
    filter={"category": "tutorials", "year": 2024},  # Depends on store support
)

results = await retriever.retrieve(
    query="machine learning",
    top_k=10,
    filter={"category": "tutorials", "year": 2024},  # Depends on store support
)

Information

La prise en charge du filtrage dépend de votre backend de stockage vectoriel. Vespa prend en charge le filtrage par métadonnées nativement.

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

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())

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

Présentation de la récupération — Architecture du pipeline de récupération
Réorganisateurs — Réévaluez les résultats pour un meilleur classement
Prétraitement des requêtes — Améliorez les requêtes avant la récupération