You can combine a Retriever with a Reader in your pipeline to speed up the search. The Retriever passes the Documents it selected on to the Reader. This way, it saves the Reader from doing more work than it needs to.

In a query pipeline, when given a query, the Retriever sifts through the Documents in the DocumentStore, scores each Document for its relevance to the query, and returns the top candidates. Retriever and DocumentStore are tightly coupled. When configuring a Retriever, you must always specify its DocumentStore.

When used in indexing pipelines, vector-based Retrievers (DensePassagerRetriever and EmbeddingRetriever) take Documents as input, and for each Document, they calculate its vector representation (embedding). This embedding is stored as part of the Document in the DocumentStore.
If you're using a keyword-based Retriever (BM25Retriever or TfidfRetriever) in your indexing pipeline, no embeddings are calculated and the Retriever creates a keyword-based index that it then uses to quickly look up the Documents.

Basic Information

• Pipeline type: Used in query pipelines and in indexing pipelines.
• Position in a pipeline:
  • In query pipelines: At the beginning.
  • In indexing pipelines: After a PreProcessor and before DocumentStore.
• Node input:
  • In query pipelines: Query
  • In indexing pipelines: Document
• Node output:
  • In query pipelines: Documents
  • In indexing pipelines: Documents
• Available node classes: BM25Retriever, DensePassageRetriever, EmbeddingRetriever, TfidfRetriever

Retrievers Overview

There are two categories of retrievers: vector-based (dense) and keyword-based (sparse) retrievers.

Vector-Based Retrievers

Vector-based retrievers work with document embeddings. They embed both the documents and the query using deep neural networks, and then return the documents most similar to the query as top candidates.

Main features:

• Simple but effective.
• Don't need to be trained.
• Work on any language.
• Don't take word order and syntax into account.
• Handle out-of-vocabulary words.
• Indexing is done by creating an inverted index, it's faster and less expensive than in vector-based retrievers.

Available vector-based retrievers:

• EmbeddingRetriever
• DensePassageRetriever

Keyword-Based Retrievers

Keyword-based retrievers look for keywords shared between the documents and the query.

Main features:

• Powerful but more expensive computationally, especially during indexing.
• Trained using labeled datasets.
• Language-specific.
• Use transformer-based encoders which take word order and syntax into account.
• Have problems with out-of-vocabulary words.
• Can build strong semantic representations of text.
• Indexing is done by processing all documents through a neural network and storing the resulting vectors. Requires significant computational power and time.

Available keyword-based retrievers:

• TfidfRetriever
• BM25Retriever
• FilterRetriever

Choosing the Right Retriever

Here are a couple of things to consider when choosing a retriever:

• Do you have a GPU available?
  • Yes: We recommend using the EmbeddingRetriever.
  • No: We recommend using the BM25Retriever.

Usage

Retrievers are usually used as pipeline nodes, not on their own.

Initializing the Node

A Retriever always takes the DeepsetCloudDocumentStore as an argument.

components:
    - name: DocumentStore # First, configure the DocumentStore for the Retriever
    type: DeepsetCloudDocumentStore
    - name: Retriever 
    type: EmbeddingRetriever # Uses a Transformer model to encode the document and the query
    params:
      document_store: DocumentStore
      embedding_model: sentence-transformers/multi-qa-mpnet-base-dot-v1 # Model optimized for semantic search
      model_format: sentence_transformers
      top_k: 20 

#Import the document store from Haystack:
from haystack.document_stores import DeepsetCloudDocumentStore

#Import the retriever:
from haystack.nodes import TfidfRetriever

#Set the document store:
document_store = DeepsetCloudDocumentStore()

#Initialize the retriever:
retriever = TfidfRetriever(document_store)

For arguments you can specify for each retriever type, see the Arguments.

In a Pipeline

In a Query Pipeline

pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: Reader
        inputs: [Retriever]

from haystack.document_stores import DeepsetCloudDocumentStore
from haystack.nodes import EmbeddingRetriever, FARMReader
from haystack.pipelines import Pipeline

document_store = DeepsetCloudDocumentStore()
embedding_retriever = EmbeddingRetriever(document_store=document_store, embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1", model_format="sentence_transformers", top_k=20)
reader = FARMReader(model_name_or_path="deepset/deberta-v3-base-squad2", context_window_size=700)

query_pipeline = Pipeline()
query_pipeline.add_node(component=embedding_retriever, name="EmbeddingRetriever", inputs=["Query"])
query_pipeline.add_node(component=reader, name="Reader", inputs=["EmbeddingRetriever"])

query_pipeline.run("What is the name of a Jazz musician?")

In an Indexing Pipeline

- name: indexing
    nodes:
      - name: FileTypeClassifier
        inputs: [File]
      - name: TextConverter
        inputs: [FileTypeClassifier.output_1] 
      - name: PDFConverter
        inputs: [FileTypeClassifier.output_2] 
      - name: Preprocessor
        inputs: [TextConverter, PDFConverter]
      - name: Retriever
        inputs: [Preprocessor]
      - name: DocumentStore
        inputs: [Retriever]

from haystack.document_stores import DeepsetCloudDocumentStore
from haystack.nodes import EmbeddingRetriever, PreProcessor, TextConverter, PDFConverter, FileTypeClassifier
from haystack.pipelines import Pipeline

document_store = DeepsetCloudDocumentStore()
embedding_retriever = EmbeddingRetriever(document_store=document_store, embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1", model_format="sentence_transformers", top_k=20)
file_classifier = FileTypeClassifier()
text_converter = TextConverter()
pdf_converter = PDFConverter()
preprocessor = PreProcessor(split_by="word", split_length=250, split_overlap=30, split_sentence_boundary=True, language="en")

indexing_pipeline = Pipeline()
indexing_pipeline.add_node(component=file_classifier, name="FileTypeClassifier", inputs=["File"])
indexing_pipeline.add_node(component=text_converter, name="TextConverter", inputs=["FileTypeClassifier.output_1"])
indexing_pipeline.add_node(component=pdf_converter, name="PDFConverter", inputs=["FileTypeClassifier.output_2"])
indexing_pipeline.add_node(component=preprocessor, name="PreProcessor", inputs=["TextConverter", "PDFConverter"])
indexing_pipeline.add_node(component=embedding_retriever, name="EmbeddingRetriever", inputs=["PreProcessor"])
indexing_pipeline.add_node(component=document_store, name="DeepsetCloudDocumentStore", inputs=["Retriever"])

Arguments

Here are the arguments each retriever type can take.

BM25Retriever

DensePassageRetriever (DPR)

You must choose the models you want this retriever to use to convert the documents into embeddings and then another model to convert the query into embeddings.

EmbeddingRetriever

You must specify the model you want this retriever to use to embed the query and the documents.

FilterRetriever

Takes the DeepsetCloudDocumentStore.

TfidfRetriever