Best reranker for RAG: Reflex vs Cohere, Voyage, Jina, Qwen and NVIDIA

Most "best reranker for RAG" lists, such as MachineLearningMastery's top five or Analytics Vidhya's top seven, compare model rerankers against each other: Cohere, BGE, Jina, Qwen, NVIDIA. That is a fair comparison once you have decided you need a model that reads the query and each document together. We think the earlier decision is the one teams skip. Many RAG pipelines rerank a support manual or a product catalog, where the same documents come back for thousands of different questions, and a ranker that reuses work across those questions may be enough.

Reflex is the reranker we built for that case, and it is the default in AIVAX collection search. Our position is that it should be the first thing you try on a recurring corpus and that you should switch to a model reranker only after a test on your own queries shows it misses.

Reflex scores candidates without a pairwise model pass

A cross-encoder scores each query-document pair with a full model pass, and listwise rerankers such as Jina's read the query with a batch of candidates; either way the model sees query and text together, and the work grows with the candidate count. Reflex embeds the query and each candidate separately and orders them by semantic similarity. For larger candidate pools it narrows them first with a fast binary comparison, then scores the survivors exactly.

On top of that, it can adjust the order with lexical evidence computed over the candidates it was given, mostly BM25-style term matching plus how much of the query a candidate covers and how close the terms sit. That adjustment moves candidates within the semantic order without overriding the strongest semantic matches, and it is skipped for some query shapes, including very long queries, where term statistics stop being informative. With small pools it can also promote a few submitted candidates that semantic similarity ranked low but that match the query's terms.

The response keeps each document's input index. Its relevance_score is the semantic score, while the returned order can reflect the lexical adjustment, so preserve the response order instead of re-sorting by score. Neither number is a probability that a passage answers the question.

Recurring documents are where the reuse pays off

Embedding the candidates is the expensive part of that design, and Reflex caches those representations per account. The cache key covers the embedding task, the model and the exact input text, so the same manual section can be reused across different questions while an edited paragraph or another account's copy is computed fresh. The ranking itself is recomputed for every question, and no answer is ever cached.

The reuse is conditional. Entries are short-lived, measured in hours rather than days in the current implementation, so a cold request or a one-off batch pays to embed everything. Candidates from collection search and from the standalone endpoint are formatted differently, so we would not count on one path warming the other. Cached input is still billed at a lower rate, and you still send every candidate string with each standalone request. To see what was reused, compare usage.input_tokens with usage.cached_input_tokens.

What the rerankers on the same endpoint cost

The standalone endpoint, POST /api/v1/generations/rerank, serves Reflex and the third-party rerankers below with the same request shape. These are the rates and limits from the public reranker catalog as read for this update.

Reflex is not the cheapest reranker per uncached token: @qwen/qwen3-reranker-0.6b and the NVIDIA VL model list $0.01 against Reflex's $0.015. Its price advantage appears on repeated documents, where cached input drops to $0.003, and in the daily subscription allowance, which covers Reflex and none of the others. Cohere's 3.5 and 4 models bill per search unit, Cohere's own unit for a query with a batch of documents, so their prices do not compare directly with per-token rates.

Context size matters as much as price. Reflex reads 1,948 tokens per candidate, small next to the 32K and 131K windows of the model rerankers, so long candidates need chunking before they reach it, and a model that reads whole sections is a real alternative when your candidates are long. The per-request document cap varies from 1,024 to 10,000, which matters if you over-retrieve before ranking.

When a model reranker is worth paying for

Reflex is a reasonable first choice when the right document usually reaches the candidate set, the corpus repeats, and queries carry identifiers or product names that lexical evidence can confirm. We would test a model reranker when queries hinge on negation or exceptions, because a model that reads query and passage together can catch what similarity plus term evidence misses. Among those, we would start with a fast tier (Cohere Rerank 5 Fast or Voyage rerank-3-lite at $0.02) to see whether a model pass helps at all, reach for Jina when candidates are long sections that would not fit Reflex's window, and use the 1,024-document Qwen or NVIDIA models only with pools that small. That is a starting order, not a ranking we measured. The reverse also happens: BigDataBoutique points out that for exact-match lookups such as an order ID, where BM25 already puts the answer first, a model trained on natural-language relevance can demote the exact hit.

The reranker documentation gives the same advice: start with the default and switch only for a measured reason.

No reranker fixes a missing candidate. If the answer-bearing document is not in the pool, the problem is retrieval or preparation, which Do I need a reranker for RAG? separates from ordering, and which the RAG pipeline checklist and the PDF ingestion checks cover further upstream. If you already run hybrid BM25 and vector retrieval, keep it as a baseline: rrf fuses retrieval signals after collection search, while a reranker reorders the text it receives.

A test that isolates the ranker

Fix a set of representative queries and label which candidates contain the required evidence. Hold the candidate pool constant across runs, otherwise a retrieval change will look like a ranking improvement. Then run no reranking, Reflex and the model reranker you are considering, and record whether the required document lands inside the slice you actually send to the model, not only whether it moved up.

Run the repeated-document case and the cold case separately and record latency and returned usage for each, because Reflex's cost depends on reuse and a model reranker's does not. Finally, check the generated answers for the hard queries, especially exceptions and conflicting passages, since a better-looking ranking can still feed the model the wrong paragraph. Then take the cheapest ranker that clears your quality bar on that set.

Switching rankers is one field

In AIVAX collection search, a query sorted by score uses Reflex when reranker is omitted, and any model in the table can be named instead; "reranker": "none" turns reranking off. Results sorted by date or another field are not reranked. Collection search applies minScore, 0.2 by default, to semantic candidates before reranking, so no ranker can bring back a candidate that threshold removed; retune it when you change rankers.

Without a collection, send the candidates to the standalone endpoint with an Authorization: Bearer <API_KEY> header:

{
  "model": "@aivax/reflex-v1",
  "query": "How can I rotate an API key without interrupting service?",
  "documents": [
    "Create a replacement key, update the application, verify requests, then revoke the old key.",
    "Billing invoices are available in account settings."
  ],
  "top_n": 1,
  "min_score": 0
}

Change model to compare another reranker with the same body; omitting it selects Reflex. top_n defaults to the smaller of 5 and the number of documents and is capped at 200 for Reflex. A smaller top_n trims the output, but every submitted document is still processed and billed. min_score filters the returned scores after ranking. Join results[].index back to your input array.

Reflex's base rates are listed with its pricing and limits. Request quotas are separate from token charges: the plan limits allow 30 reranking requests per minute and 30 minutes of Reflex processing per day on Free, rising to 500 per minute and 3 hours on Pro, and both quotas count collection searches that rerank as well as standalone calls. The Free plan's daily Reflex allowance, and what a typical rerank consumes from it, is covered in what AIVAX Free covers for RAG.

Last verified on 9 November 2026 against the AIVAX source, documentation and public catalog. We have not benchmarked Reflex against the other rerankers.