Rankers are made to improve your retrieval results. Besides fast and simple feature-based rankers (such as RecentnessRanker), you can use rich transformer-based models that are sensitive to word order and syntax. In a pipeline, you can pair a Ranker with a keyword-based Retriever, like BM25Retriever. BM25Retriever is lightweight but insensitive to word order. Adding a Ranker after BM25Retriever in your query pipeline offsets this weakness and results in a better-sorted list of relevant documents

The improvement the Ranker brings comes at the cost of computational time.

Basic Information

• Pipeline type: Used in query pipelines.
• Nodes that can precede it in a pipeline: JoinDocuments, Retriever
• Nodes that can follow it in a pipeline: JoinDocuments, PromptNode, Reader
• Node input: Documents
• Node output: Documents
• Available node classes: CohereRanker, DeepsetMetaFieldRanker, DiversityRanker, EmbeddingRanker, LostInTheMiddleRanker, RecentnessRanker, SentenceTransformersRanker

Rankers Overview

There are two categories of rankers: model-based and feature-based. See the table below for a comparison of the two:

CohereRanker

CohereRanker uses models by Cohere to rerank documents. Cohere models are trained with a context length of 512 tokens. The model takes into account both the tokens from the query and the document. If your query is longer than 256 tokens, it's shortened to the first 256 tokens.

For more information and best practices on re-ranking in Cohere, see Cohere documentation.

DeepsetMetaFieldRanker

Use this ranker to rank documents based on the value of their metadata field. You can set the ranking to ascending or descending.

For instance, if you want documents with higher ratings to appear first, you can adjust the settings in DeepsetMetaFieldRanker. Make sure your documents have a metadata field labeled 'rating' to store their scores. Then, set DeepsetMetaFieldRanker to rank the documents by the value of their 'rating' field in descending order, ensuring that documents with higher ratings are prioritized and appear at the top of your list.

Diversity Ranker

This ranker is typically used in retrieval augmented generation (RAG) pipelines where a large language model (LLM) generates the answer based on the documents you feed to it in the prompt. DiversityRanker ensures that the generated answer is based on diverse documents.

It uses a sentence transformer model to calculate the semantic representation (embedding) for each document. Then, it ranks the documents so that each subsequent document is the least similar to the ones it already selected. This results in a diverse set of documents.

You can use it in combination with other rankers. If you do so, place it after the similarity ranker, like SentenceTransformersRanker, but before the LostInTheMiddleRanker. Such setup is typical for the long form question answering task.

For more information, see our blog post.

EmbeddingRanker

EmbeddingRanker re-ranks documents based on the similarity score calculated by comparing the query vector embedding with each document vector embedding. It uses bi-encoder models. When combined with a keyword-based retriever (like BM25Retriever), it brings better results without the additional indexing costs of vector-based retrievers.

LostInTheMiddleRanker

This ranker is intended for pipelines using a large language model (LLM). Recent research showed that LLMs struggle with focusing on relevant passages located in the middle of a long context. The goal of the LostInTheMiddleRanker is to make it easy for an LLM to access the most relevant documents by placing them at the beginning and at the end of the context window.

LostInTheMiddleRanker is meant to be used in combination with other rankers. In a RAG pipeline, place it as the last ranker after the relevance and diversity rankers.

For more information, see the Lost in the Middle: How Language Models Use Long Contexts paper by Liu et al and our blog post.

RecentnessRanker

This ranker re-ranks documents based on both their age and their relevance. You can specify the date metadata field you want it to rank on. Additionally, you can set weight and method parameters for RecentnessRanker. The weight parameter controls whether you want to rank documents based on their recentness, relevance, or both. The method parameter determines how you want to combine the recentness and relevance ranking.

SentenceTransformersRanker

This ranker uses one model (cross-encoder) to encode both the documents and the query at the same time. It can use a sentence-transformer-based cross-encoder model. Cross-encoders naturally produce better results at the cost of latency when compared to bi-encoders.

CNSentenceTransformersRanker works like SentenceTransformersRanker, but it has an additional parameter tokenizer_kwargs that makes it possible to pass additional keyword arguments to the tokenizer.

Recommended Models

For an overview of the ranking models, we recommend, see Models in deepset Cloud.

Usage Example

name: 'cohereranker_pipeline'

components:
	- name: Ranker
  	type: CohereRanker
    params:
    	model_name_or_path: rerank-multilingual-v2.0
      api_key: <your_cohere_api_key>
      top_k: 10
      ...
pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: Ranker
        inputs: [Retriever]
      - name: PromptNode
        inputs: [Ranker]
  - name: indexing
    nodes:
    	# here comes your indexing pipeline configuration

name: 'metafieldranker_pipeline'

 - name: MetaFieldRanker
    type: DeepsetMetaFieldRanker
    params:
      meta_field: feedback_score
      weight: 1
      sort_order: descending
      top_k: 20
      ... # Here come other components

  - name: query
    nodes:
      - name: BM25Retriever
        inputs: [Query]
      - name: EmbeddingRetriever
        inputs: [Query]
      - name: JoinResults
        inputs: [BM25Retriever, EmbeddingRetriever]
      - name: Reranker
        inputs: [JoinResults]
      - name: MetaFieldRanker
        inputs: [Reranker]
... # Here comes the indexing pipeline

# These rankers are usually used in combination with other rankers
# LostIntheMiddleRanker comes at the end of the query pipeline, before PromptNode
# DiversityRanker comes after a similarity ranker but before LostInTheMiddleRanker

name: 'diversity_lostinthemiddle_rankers_pipeline'

components:
	- name: DiversityRanker
  	type: DiversityRanker
  - name: LostIntheMiddle
    type: LostInTheMiddleRanker
    params:
    	word_count_threshold: 1024
  ...
pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: DiversityRanker
        inputs: [Retriever]
      - name: LostInTheMiddle
      	inputs: [DiversityRanker]
      - name: PromptNode
        inputs: [LostInTheMiddle]
  - name: indexing
    nodes:
    	# here comes your indexing pipeline configuration

name: 'embedding_ranker_pipeline'

components:
	- name: Ranker
  	type: EmbeddingRanker
    params:
    	embedding_model: sentence-transformers/all-mpnet-base-v2
      ...
pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: Ranker
        inputs: [Retriever]
      - name: PromptNode
        inputs: [Ranker]
  - name: indexing
    nodes:
    	# here comes your indexing pipeline configuration

name: 'search_by_recency'

components:
	- name: Ranker
  	type: RecentnessRanker
    params:
    	date_meta_field: updated_at # this is the name of the document's metadata field containing the date
      ...
pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: Ranker
        inputs: [Retriever]
      - name: PromptNode
        inputs: [Ranker]
  - name: indexing
    nodes:
    	# here comes your indexing pipeline configuration

name: 'ranker_pipeline'

components:
	- name: Ranker
  	type: SentenceTransformersRanker
    params:
    	model_name_or_path: cross-encoder/ms-marco-MiniLM-L-12-v2
      ...
pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: Ranker
        inputs: [Retriever]
      - name: PromptNode
        inputs: [Ranker]
  - name: indexing
    nodes:
    	# here comes your indexing pipeline configuration

Combining Rankers

You can use multiple Rankers in your pipeline. Combining RecentnessRanker with a model-based Ranker is a handy way of handling situations when the Retriever you're using returns improper scores (scores that don't scale between 0 and 1), but you want to use the score method for the RecentnessRanker.

...
components:
  - 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
  - name: RecentnessRanker 
    type: RecentnessRanker # Incorporate recentness into the semantic ranking
    params:
      date_identifier: updated_at
      method: score
  - name: SentenceTransformersRanker 
    type: SentenceTransformersRanker # Model-based Ranker
    params:
      model_name_or_path: cross-encoder/ms-marco-MiniLM-L-12-v2
      top_k: 15

pipelines:
  - name: query
    nodes:
      - name: Retriever
        inputs: [Query]
      - name: SentenceTransformersRanker
        inputs: [Retriever]
      - name: RecentnessRanker
        inputs: [SentenceTransformersRanker]
      - name: PromptNode
        inputs: [RecentnessRanker]
        ...

Parameters

Here are the parameters each ranker type can take in pipeline YAML:

CohereRanker Parameters

DeepsetMetaFieldRanker Parameters

DiversityRanker Parameters

EmbeddingRanker Parameters

LostInTheMiddleRanker Parameters

RecentnessRanker Parameters

SentenceTransformersRanker Parameters

CNSentenceTransformersRanker Parameters

This ranker uses the same parameters as SentenceTransformersRanker with an additional tokenizer_kwargs parameter: