AutoRAG 0.3.16__tar.gz → 0.3.17__tar.gz

{autorag-0.3.16 → autorag-0.3.17}/AutoRAG.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoRAG
-Version: 0.3.16
+Version: 0.3.17
 Summary: Automatically Evaluate RAG pipelines with your own data. Find optimal structure for new RAG product.
 Author-email: Marker-Inc <vkehfdl1@gmail.com>
 Project-URL: Homepage, https://github.com/Marker-Inc-Korea/AutoRAG
@@ -44,6 +44,8 @@ Requires-Dist: grpcio<1.68.0,>=1.66.2
 Requires-Dist: grpcio-health-checking<1.68.0,>=1.66.2
 Requires-Dist: grpcio-status<1.68.0,>=1.66.2
 Requires-Dist: grpcio-tools<1.68.0,>=1.66.2
+Requires-Dist: datasets>=3.5.1
+Requires-Dist: pyarrow>=20.0.0
 Requires-Dist: pymilvus>=2.6.0b0
 Requires-Dist: chromadb>=1.0.0
 Requires-Dist: weaviate-client>=4.15.2

{autorag-0.3.16 → autorag-0.3.17}/AutoRAG.egg-info/SOURCES.txt

@@ -101,6 +101,14 @@ autorag/nodes/generator/openai_llm.py
 autorag/nodes/generator/run.py
 autorag/nodes/generator/vllm.py
 autorag/nodes/generator/vllm_api.py
+autorag/nodes/hybridretrieval/__init__.py
+autorag/nodes/hybridretrieval/base.py
+autorag/nodes/hybridretrieval/hybrid_cc.py
+autorag/nodes/hybridretrieval/hybrid_rrf.py
+autorag/nodes/hybridretrieval/run.py
+autorag/nodes/lexicalretrieval/__init__.py
+autorag/nodes/lexicalretrieval/bm25.py
+autorag/nodes/lexicalretrieval/run.py
 autorag/nodes/passageaugmenter/__init__.py
 autorag/nodes/passageaugmenter/base.py
 autorag/nodes/passageaugmenter/pass_passage_augmenter.py
@@ -160,17 +168,17 @@ autorag/nodes/queryexpansion/query_decompose.py
 autorag/nodes/queryexpansion/run.py
 autorag/nodes/retrieval/__init__.py
 autorag/nodes/retrieval/base.py
-autorag/nodes/retrieval/bm25.py
-autorag/nodes/retrieval/hybrid_cc.py
-autorag/nodes/retrieval/hybrid_rrf.py
-autorag/nodes/retrieval/run.py
-autorag/nodes/retrieval/vectordb.py
+autorag/nodes/retrieval/run_util.py
+autorag/nodes/semanticretrieval/__init__.py
+autorag/nodes/semanticretrieval/run.py
+autorag/nodes/semanticretrieval/vectordb.py
 autorag/schema/__init__.py
 autorag/schema/base.py
 autorag/schema/metricinput.py
 autorag/schema/module.py
 autorag/schema/node.py
 autorag/utils/__init__.py
+autorag/utils/cast.py
 autorag/utils/preprocess.py
 autorag/utils/util.py
 autorag/vectordb/__init__.py

{autorag-0.3.16 → autorag-0.3.17}/AutoRAG.egg-info/requires.txt

@@ -26,6 +26,8 @@ grpcio<1.68.0,>=1.66.2
 grpcio-health-checking<1.68.0,>=1.66.2
 grpcio-status<1.68.0,>=1.66.2
 grpcio-tools<1.68.0,>=1.66.2
+datasets>=3.5.1
+pyarrow>=20.0.0
 pymilvus>=2.6.0b0
 chromadb>=1.0.0
 weaviate-client>=4.15.2

{autorag-0.3.16 → autorag-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoRAG
-Version: 0.3.16
+Version: 0.3.17
 Summary: Automatically Evaluate RAG pipelines with your own data. Find optimal structure for new RAG product.
 Author-email: Marker-Inc <vkehfdl1@gmail.com>
 Project-URL: Homepage, https://github.com/Marker-Inc-Korea/AutoRAG
@@ -44,6 +44,8 @@ Requires-Dist: grpcio<1.68.0,>=1.66.2
 Requires-Dist: grpcio-health-checking<1.68.0,>=1.66.2
 Requires-Dist: grpcio-status<1.68.0,>=1.66.2
 Requires-Dist: grpcio-tools<1.68.0,>=1.66.2
+Requires-Dist: datasets>=3.5.1
+Requires-Dist: pyarrow>=20.0.0
 Requires-Dist: pymilvus>=2.6.0b0
 Requires-Dist: chromadb>=1.0.0
 Requires-Dist: weaviate-client>=4.15.2

autorag-0.3.17/autorag/VERSION

@@ -0,0 +1 @@
+0.3.17

{autorag-0.3.16 → autorag-0.3.17}/autorag/data/legacy/qacreation/base.py

@@ -8,7 +8,7 @@ import pandas as pd
 from tqdm import tqdm
 
 import autorag
-from autorag.nodes.retrieval.vectordb import vectordb_ingest, vectordb_pure
+from autorag.nodes.semanticretrieval.vectordb import vectordb_ingest_api, vectordb_pure
 from autorag.utils.util import (
 	save_parquet_safe,
 	fetch_contents,
@@ -176,7 +176,7 @@ def make_qa_with_existing_qa(
 		collection = chroma_client.get_or_create_collection(collection_name)
 
 	# embed corpus_df
-	vectordb_ingest(collection, corpus_df, embeddings)
+	vectordb_ingest_api(collection, corpus_df, embeddings)
 	query_embeddings = embeddings.get_text_embedding_batch(
 		existing_query_df["query"].tolist()
 	)

{autorag-0.3.16 → autorag-0.3.17}/autorag/deploy/api.py

@@ -248,9 +248,19 @@ class ApiRunner(BaseRunner):
 		self.app.run(host=host, port=port, **kwargs)
 
 	def extract_retrieve_passage(self, df: pd.DataFrame) -> List[RetrievedPassage]:
-		retrieved_ids: List[str] = df["retrieved_ids"].tolist()[0]
+		if "retrieved_ids" not in df.columns and "retrieved_ids_semantic" in df.columns:
+			retrieved_ids: List[str] = df["retrieved_ids_semantic"].tolist()[0]
+			scores = df["retrieve_scores_semantic"].tolist()[0]
+		elif (
+			"retrieved_ids" not in df.columns
+			and "retrieved_ids_semantic" not in df.columns
+		):
+			retrieved_ids: List[str] = df["retrieved_ids_lexical"].tolist()[0]
+			scores = df["retrieve_scores_lexical"].tolist()[0]
+		else:
+			retrieved_ids: List[str] = df["retrieved_ids"].tolist()[0]
+			scores = df["retrieve_scores"].tolist()[0]
 		contents = fetch_contents(self.corpus_df, [retrieved_ids])[0]
-		scores = df["retrieve_scores"].tolist()[0]
 		if "path" in self.corpus_df.columns:
 			paths = fetch_contents(self.corpus_df, [retrieved_ids], column_name="path")[
 				0

{autorag-0.3.16 → autorag-0.3.17}/autorag/evaluator.py

@@ -6,18 +6,18 @@ import shutil
 from datetime import datetime
 from itertools import chain
 from typing import List, Dict, Optional
-from rich.progress import Progress, BarColumn, TimeElapsedColumn
 
 import pandas as pd
 import yaml
 
 from autorag.node_line import run_node_line
 from autorag.nodes.retrieval.base import get_bm25_pkl_name
-from autorag.nodes.retrieval.bm25 import bm25_ingest
-from autorag.nodes.retrieval.vectordb import (
-	vectordb_ingest,
+from autorag.nodes.lexicalretrieval.bm25 import bm25_ingest
+from autorag.nodes.semanticretrieval.vectordb import (
+	vectordb_ingest_api,
 	filter_exist_ids,
 	filter_exist_ids_from_retrieval_gt,
+	vectordb_ingest_huggingface,
 )
 from autorag.schema import Node
 from autorag.schema.node import (
@@ -104,7 +104,10 @@ class Evaluator:
 			self.corpus_data.to_parquet(corpus_path_in_project, index=False)
 
 	def start_trial(
-		self, yaml_path: str, skip_validation: bool = False, full_ingest: bool = True
+		self,
+		yaml_path: str,
+		skip_validation: bool = False,
+		full_ingest: bool = True,
 	):
 		"""
 		Start AutoRAG trial.
@@ -158,64 +161,62 @@ class Evaluator:
 		node_lines = self._load_node_lines(yaml_path)
 		self.__ingest_bm25_full(node_lines)
 
-		with Progress(
-			"[progress.description]{task.description}",
-			BarColumn(),
-			"[progress.percentage]{task.percentage:>3.0f}%",
-			"[progress.bar]{task.completed}/{task.total}",
-			TimeElapsedColumn(),
-		) as progress:
-			# Ingest VectorDB corpus
-			if any(
-				list(
-					map(
-						lambda nodes: module_type_exists(nodes, "vectordb"),
-						node_lines.values(),
-					)
+		# Ingest VectorDB corpus
+		if any(
+			list(
+				map(
+					lambda nodes: module_type_exists(nodes, "vectordb"),
+					node_lines.values(),
 				)
-			):
-				task_ingest = progress.add_task("[cyan]Ingesting VectorDB...", total=1)
-
-				loop = get_event_loop()
-				loop.run_until_complete(self.__ingest_vectordb(yaml_path, full_ingest))
-
-				progress.update(task_ingest, completed=1)
-
-			trial_summary_df = pd.DataFrame(
-				columns=[
-					"node_line_name",
-					"node_type",
-					"best_module_filename",
-					"best_module_name",
-					"best_module_params",
-					"best_execution_time",
-				]
-			)
-			task_eval = progress.add_task(
-				"[cyan]Evaluating...", total=sum(map(len, node_lines.values()))
 			)
-
-			for i, (node_line_name, node_line) in enumerate(node_lines.items()):
-				node_line_dir = os.path.join(
-					self.project_dir, trial_name, node_line_name
-				)
-				os.makedirs(node_line_dir, exist_ok=False)
-				if i == 0:
-					previous_result = self.qa_data
-				logger.info(f"Running node line {node_line_name}...")
-				previous_result = run_node_line(
-					node_line, node_line_dir, previous_result, progress, task_eval
+		):
+			vectordb_list = load_all_vectordb_from_yaml(yaml_path, self.project_dir)
+			for vectordb in vectordb_list:
+				loop = get_event_loop()
+				target_corpus = loop.run_until_complete(
+					self.__get_ingest_target_corpus(vectordb, full_ingest)
 				)
+				if vectordb.embedding.__class__.class_name() == "HuggingFaceEmbedding":
+					vectordb_ingest_huggingface(vectordb, target_corpus)
+				else:
+					# API Ingest Method
+					loop = get_event_loop()
+					loop.run_until_complete(
+						vectordb_ingest_api(vectordb, target_corpus)
+					)
 
-				trial_summary_df = self._append_node_line_summary(
-					node_line_name, node_line_dir, trial_summary_df
-				)
+		trial_summary_df = pd.DataFrame(
+			columns=[
+				"node_line_name",
+				"node_type",
+				"best_module_filename",
+				"best_module_name",
+				"best_module_params",
+				"best_execution_time",
+			]
+		)
+
+		for i, (node_line_name, node_line) in enumerate(node_lines.items()):
+			node_line_dir = os.path.join(self.project_dir, trial_name, node_line_name)
+			os.makedirs(node_line_dir, exist_ok=False)
+			if i == 0:
+				previous_result = self.qa_data
+			logger.info(f"Running node line {node_line_name}...")
+			previous_result = run_node_line(
+				node_line,
+				node_line_dir,
+				previous_result,
+			)
 
-			trial_summary_df.to_csv(
-				os.path.join(self.project_dir, trial_name, "summary.csv"), index=False
+			trial_summary_df = self._append_node_line_summary(
+				node_line_name, node_line_dir, trial_summary_df
 			)
 
-			logger.info("Evaluation complete.")
+		trial_summary_df.to_csv(
+			os.path.join(self.project_dir, trial_name, "summary.csv"), index=False
+		)
+
+		logger.info("Evaluation complete.")
 
 	def __ingest_bm25_full(self, node_lines: Dict[str, List[Node]]):
 		if any(
@@ -544,17 +545,15 @@ class Evaluator:
 		)
 		return list(set(embedding_models_list))
 
-	async def __ingest_vectordb(self, yaml_path, full_ingest: bool):
-		vectordb_list = load_all_vectordb_from_yaml(yaml_path, self.project_dir)
+	async def __get_ingest_target_corpus(
+		self, vectordb, full_ingest: bool
+	) -> pd.DataFrame:
 		if full_ingest is True:
 			# get the target ingest corpus from the whole corpus
-			for vectordb in vectordb_list:
-				target_corpus = await filter_exist_ids(vectordb, self.corpus_data)
-				await vectordb_ingest(vectordb, target_corpus)
+			target_corpus = await filter_exist_ids(vectordb, self.corpus_data)
 		else:
 			# get the target ingest corpus from the retrieval gt only
-			for vectordb in vectordb_list:
-				target_corpus = await filter_exist_ids_from_retrieval_gt(
-					vectordb, self.qa_data, self.corpus_data
-				)
-				await vectordb_ingest(vectordb, target_corpus)
+			target_corpus = await filter_exist_ids_from_retrieval_gt(
+				vectordb, self.qa_data, self.corpus_data
+			)
+		return target_corpus

{autorag-0.3.16 → autorag-0.3.17}/autorag/node_line.py

@@ -1,7 +1,6 @@
 import os
 import pathlib
 from typing import Dict, List, Optional
-from rich.progress import Progress
 
 import pandas as pd
 
@@ -26,8 +25,6 @@ def run_node_line(
 	nodes: List[Node],
 	node_line_dir: str,
 	previous_result: Optional[pd.DataFrame] = None,
-	progress: Progress = None,
-	task_eval: Progress.tasks = None,
 ):
 	"""
 	Run the whole node line by running each node.
@@ -36,8 +33,6 @@ def run_node_line(
 	:param node_line_dir: This node line's directory.
 	:param previous_result: A result of the previous node line.
 	    If None, it loads qa data from data/qa.parquet.
-	:param progress: Rich Progress object.
-	:param task_eval: Progress task object
 	:return: The final result of the node line.
 	"""
 	if previous_result is None:
@@ -63,9 +58,6 @@ def run_node_line(
 				"best_execution_time": best_node_row["execution_time"].values[0],
 			}
 		)
-		# Update progress for each node
-		if progress:
-			progress.update(task_eval, advance=1)
 
 	pd.DataFrame(summary_lst).to_csv(
 		os.path.join(node_line_dir, "summary.csv"), index=False

{autorag-0.3.16/autorag/nodes/retrieval → autorag-0.3.17/autorag/nodes/hybridretrieval}/__init__.py

@@ -1,4 +1,2 @@
-from .bm25 import BM25
 from .hybrid_cc import HybridCC
 from .hybrid_rrf import HybridRRF
-from .vectordb import VectorDB

autorag-0.3.17/autorag/nodes/hybridretrieval/base.py

@@ -0,0 +1,58 @@
+import abc
+
+import pandas as pd
+
+from autorag.nodes.retrieval.base import BaseRetrieval
+from autorag.utils import result_to_dataframe
+from autorag.utils.util import pop_params, fetch_contents
+
+
+class HybridRetrieval(BaseRetrieval, metaclass=abc.ABCMeta):
+	def __init__(self, project_dir: str, *args, **kwargs):
+		super().__init__(project_dir)
+
+	@result_to_dataframe(["retrieved_contents", "retrieved_ids", "retrieve_scores"])
+	def pure(self, previous_result: pd.DataFrame, *args, **kwargs):
+		previous_info = self.cast_to_run(previous_result, *args, **kwargs)
+		_pure_params = pop_params(self._pure, kwargs)
+		ids, scores = self._pure(previous_info, **_pure_params)
+		contents = fetch_contents(self.corpus_df, ids)
+		return contents, ids, scores
+
+	def cast_to_run(self, previous_result: pd.DataFrame, *args, **kwargs):
+		return hybrid_cast(previous_result)
+
+	@classmethod
+	def cast_to_run_class(cls, previous_result: pd.DataFrame):
+		return hybrid_cast(previous_result)
+
+
+def hybrid_cast(
+	previous_result: pd.DataFrame,
+):
+	assert "query" in previous_result.columns, "previous_result must have query column."
+	queries = previous_result["query"].tolist()
+
+	assert "retrieved_contents_semantic" in previous_result.columns
+	assert "retrieved_contents_lexical" in previous_result.columns
+	assert "retrieve_scores_semantic" in previous_result.columns
+	assert "retrieve_scores_lexical" in previous_result.columns
+	assert "retrieved_ids_semantic" in previous_result.columns
+	assert "retrieved_ids_lexical" in previous_result.columns
+
+	contents_semantic = previous_result["retrieved_contents_semantic"].tolist()
+	contents_lexical = previous_result["retrieved_contents_lexical"].tolist()
+	scores_semantic = previous_result["retrieve_scores_semantic"].tolist()
+	scores_lexical = previous_result["retrieve_scores_lexical"].tolist()
+	ids_semantic = previous_result["retrieved_ids_semantic"].tolist()
+	ids_lexical = previous_result["retrieved_ids_lexical"].tolist()
+
+	return {
+		"queries": queries,
+		"retrieved_contents_semantic": contents_semantic,
+		"retrieved_contents_lexical": contents_lexical,
+		"retrieve_scores_semantic": scores_semantic,
+		"retrieve_scores_lexical": scores_lexical,
+		"retrieved_ids_semantic": ids_semantic,
+		"retrieved_ids_lexical": ids_lexical,
+	}

{autorag-0.3.16/autorag/nodes/retrieval → autorag-0.3.17/autorag/nodes/hybridretrieval}/hybrid_cc.py

@@ -1,12 +1,12 @@
-import os
 from pathlib import Path
 from typing import Tuple, List, Union
 
 import numpy as np
 import pandas as pd
 
-from autorag.nodes.retrieval.base import HybridRetrieval
-from autorag.utils.util import pop_params, fetch_contents, result_to_dataframe
+from autorag.nodes.hybridretrieval.base import HybridRetrieval
+from autorag.nodes.hybridretrieval.run import evaluate_retrieval_node
+from autorag.strategy import select_best
 
 
 def normalize_mm(scores: List[str], fixed_min_value: float = 0):
@@ -53,8 +53,7 @@ normalize_method_dict = {
 class HybridCC(HybridRetrieval):
 	def _pure(
 		self,
-		ids: Tuple,
-		scores: Tuple,
+		info: dict,
 		top_k: int,
 		weight: float,
 		normalize_method: str = "mm",
@@ -62,8 +61,8 @@ class HybridCC(HybridRetrieval):
 		lexical_theoretical_min_value: float = 0.0,
 	):
 		return hybrid_cc(
-			ids,
-			scores,
+			(info["retrieved_ids_semantic"], info["retrieved_ids_lexical"]),
+			(info["retrieve_scores_semantic"], info["retrieve_scores_lexical"]),
 			top_k,
 			weight,
 			normalize_method,
@@ -79,34 +78,48 @@ class HybridCC(HybridRetrieval):
 		*args,
 		**kwargs,
 	):
-		if "ids" in kwargs and "scores" in kwargs:
-			data_dir = os.path.join(project_dir, "data")
-			corpus_df = pd.read_parquet(
-				os.path.join(data_dir, "corpus.parquet"), engine="pyarrow"
+		assert "strategy" in kwargs, "You must specify the strategy to use."
+		assert (
+			"input_metrics" in kwargs
+		), "You must specify the input metrics to use, which is list of MetricInput."
+		strategies = kwargs.pop("strategy")
+		input_metrics = kwargs.pop("input_metrics")
+		weight_range = kwargs.pop("weight_range", (0.0, 1.0))
+		test_weight_size = kwargs.pop("test_weight_size", 101)
+		weight_candidates = np.linspace(
+			weight_range[0], weight_range[1], test_weight_size
+		).tolist()
+
+		result_list = []
+		instance = cls(project_dir, *args, **kwargs)
+		for weight_value in weight_candidates:
+			result_df = instance.pure(previous_result, weight=weight_value, **kwargs)
+			result_list.append(result_df)
+
+		if strategies.get("metrics") is None:
+			raise ValueError("You must at least one metrics for retrieval evaluation.")
+		result_list = list(
+			map(
+				lambda x: evaluate_retrieval_node(
+					x,
+					input_metrics,
+					strategies.get("metrics"),
+				),
+				result_list,
 			)
+		)
 
-			params = pop_params(hybrid_cc, kwargs)
-			assert (
-				"ids" in params and "scores" in params and "top_k" in params
-			), "ids, scores, and top_k must be specified."
-
-			@result_to_dataframe(
-				["retrieved_contents", "retrieved_ids", "retrieve_scores"]
-			)
-			def __cc(**cc_params):
-				ids, scores = hybrid_cc(**cc_params)
-				contents = fetch_contents(corpus_df, ids)
-				return contents, ids, scores
-
-			return __cc(**params)
-		else:
-			assert (
-				"target_modules" in kwargs and "target_module_params" in kwargs
-			), "target_modules and target_module_params must be specified if there is not ids and scores."
-			instance = cls(project_dir, *args, **kwargs)
-			result = instance.pure(previous_result, *args, **kwargs)
-			del instance
-			return result
+		# select best result
+		best_result_df, best_weight = select_best(
+			result_list,
+			strategies.get("metrics"),
+			metadatas=weight_candidates,
+			strategy_name=strategies.get("strategy", "normalize_mean"),
+		)
+		return {
+			"best_result": best_result_df,
+			"best_weight": best_weight,
+		}
 
 
 def hybrid_cc(

{autorag-0.3.16/autorag/nodes/retrieval → autorag-0.3.17/autorag/nodes/hybridretrieval}/hybrid_rrf.py

@@ -1,16 +1,23 @@
-import os
 from pathlib import Path
 from typing import List, Tuple, Union
 
+import numpy as np
 import pandas as pd
 
-from autorag.nodes.retrieval.base import HybridRetrieval
-from autorag.utils.util import pop_params, fetch_contents, result_to_dataframe
+from autorag.nodes.hybridretrieval.base import HybridRetrieval
+from autorag.nodes.hybridretrieval.run import evaluate_retrieval_node
+from autorag.strategy import select_best
 
 
 class HybridRRF(HybridRetrieval):
-	def _pure(self, ids, scores, top_k: int, weight: int = 60, rrf_k: int = -1):
-		return hybrid_rrf(ids, scores, top_k, weight, rrf_k)
+	def _pure(self, info: dict, top_k: int, weight: int = 60, rrf_k: int = -1):
+		return hybrid_rrf(
+			(info["retrieved_ids_semantic"], info["retrieved_ids_lexical"]),
+			(info["retrieve_scores_semantic"], info["retrieve_scores_lexical"]),
+			top_k,
+			weight,
+			rrf_k,
+		)
 
 	@classmethod
 	def run_evaluator(
@@ -20,34 +27,48 @@ class HybridRRF(HybridRetrieval):
 		*args,
 		**kwargs,
 	):
-		if "ids" in kwargs and "scores" in kwargs:
-			data_dir = os.path.join(project_dir, "data")
-			corpus_df = pd.read_parquet(
-				os.path.join(data_dir, "corpus.parquet"), engine="pyarrow"
+		assert "strategy" in kwargs, "You must specify the strategy to use."
+		assert (
+			"input_metrics" in kwargs
+		), "You must specify the input metrics to use, which is list of MetricInput."
+		strategies = kwargs.pop("strategy")
+		input_metrics = kwargs.pop("input_metrics")
+		weight_range = kwargs.pop("weight_range", (4, 80))
+		test_weight_size = weight_range[1] - weight_range[0] + 1
+		weight_candidates = np.linspace(
+			weight_range[0], weight_range[1], test_weight_size
+		).tolist()
+
+		result_list = []
+		instance = cls(project_dir, *args, **kwargs)
+		for weight_value in weight_candidates:
+			result_df = instance.pure(previous_result, weight=weight_value, **kwargs)
+			result_list.append(result_df)
+
+		if strategies.get("metrics") is None:
+			raise ValueError("You must at least one metrics for retrieval evaluation.")
+		result_list = list(
+			map(
+				lambda x: evaluate_retrieval_node(
+					x,
+					input_metrics,
+					strategies.get("metrics"),
+				),
+				result_list,
 			)
-
-			params = pop_params(hybrid_rrf, kwargs)
-			assert (
-				"ids" in params and "scores" in params and "top_k" in params
-			), "ids, scores, and top_k must be specified."
-
-			@result_to_dataframe(
-				["retrieved_contents", "retrieved_ids", "retrieve_scores"]
-			)
-			def __rrf(**rrf_params):
-				ids, scores = hybrid_rrf(**rrf_params)
-				contents = fetch_contents(corpus_df, ids)
-				return contents, ids, scores
-
-			return __rrf(**params)
-		else:
-			assert (
-				"target_modules" in kwargs and "target_module_params" in kwargs
-			), "target_modules and target_module_params must be specified if there is not ids and scores."
-			instance = cls(project_dir, *args, **kwargs)
-			result = instance.pure(previous_result, *args, **kwargs)
-			del instance
-			return result
+		)
+
+		# select best result
+		best_result_df, best_weight = select_best(
+			result_list,
+			strategies.get("metrics"),
+			metadatas=weight_candidates,
+			strategy_name=strategies.get("strategy", "normalize_mean"),
+		)
+		return {
+			"best_result": best_result_df,
+			"best_weight": best_weight,
+		}
 
 
 def hybrid_rrf(