Search the ChromaDB collection and return results with real similarity scores.

Combine multiple ranked lists using Reciprocal Rank Fusion.

Wrap a retrieval method with cross-encoder reranking + truncation. Retrieves `candidate_pool` candidates from the underlying method, then reranks

BM25 keyword search returning {doc_id: score} dict (same format as vector_search).

Return cached LLM-generated rewrites, or generate + persist them.

Download and unzip NFCorpus from the BEIR repository.

Generate multiple search queries from a single input query using ChatGPT.

Ingest corpus into a persistent ChromaDB collection and return it.

Load NFCorpus and return (corpus, queries, qrels). corpus: {doc_id: text} queries: {query_id: text} qrels: {query_id: {doc_id: relevan

Create a ChromaDB collection and populate it with climate change documents.

Lazy initialization of OpenAI client.

Return a random sample of n query IDs present in both queries and qrels.

Mean Reciprocal Rank. Returns 1/(rank of first relevant doc) or 0.

Normalized Discounted Cumulative Gain at k. qrel_scores is a dict {doc_id: relevance_score} with graded relevance (0/1/2).

Precision at rank k.

Recall at rank k.

Produce a final output from the reranked documents.

Our default: per-query retrieve → fuse → rerank fused pool → truncate.

Paper's ordering: for each (Q1, Q_rewrite_i), retrieve a small pool, rerank, keep the reranked list, then RRF-fuse the reranked lists, truncate to

Score (query, doc) pairs with a cross-encoder; return doc_ids reordered, truncated to top_k.

Compact one-line-per-config table for the headline metric.

Hybrid baseline: BM25 + vector for the original query, fused via RRF, then reranked. No LLM rewrites — this is the 'free lunch' baseline that adds

The strongest fusion variant in the repo: for each query (Q1 + N rewrites), do BOTH BM25 and vector search; fuse all 2*(N+1) result lists via RRF;

Cross-encoder integrated into each sub-query's pipeline before fusion. For each Qi in (Q1 + N rewrites): 1. candidates_i = RRF(BM25(Qi), ve

Build a retrieve fn that uses original_query + first n cached LLM rewrites.

Return a callable scorer (query, list[text]) -> list[float], cached on model_name.

Return dict {method: (mean, lo, hi)} for each method, using shared resampled indices across methods. Also returns paired (method - baseline) CIs.

Build a comparison table of metrics across methods. Args: all_metrics: dict of {method_name: metrics_dict} k_values: list of k va

Compute averaged metrics across all queries. all_results: dict {query_id: [list of retrieved doc IDs]} qrels: dict {query_id: {doc_id: releva

Lazy-build a BM25 index from the ChromaDB collection.

Score three labelled answers; returns dict {label: int 0-3}.

Display top-5 docs from each method for 3 example queries, marking relevant ones.

Vary N rewrites with fixed candidate_pool.

Vary candidate_pool with fixed N rewrites.

Classic BM25 keyword search.

Hybrid (BM25+vector) for each query + diverse LLM-generated queries.

Hybrid BM25 + vector search fused via RRF (no LLM calls).

Argparse type for integers greater than zero.

RAG-Fusion with diverse query generation prompt.

RAG-Fusion with diverse queries + 3x weight on original query.

Verify generate_output accepts the new parameters and still works with use_llm=False.