Feature/revive advanced rag

compose.yaml

@@ -32,7 +32,6 @@ services:
       - PYTHONUNBUFFERED=1
       - PORT=${PORT:-8000}
       - HOST=${HOST:-0.0.0.0}
-      - BASE_URL=${BASE_URL:-http://localhost}
 
       # R2R
       - CONFIG_NAME=${CONFIG_NAME:-}

py/cli/command_group.py

@@ -1,31 +1,10 @@
-import os
-
 import click
 from sdk.client import R2RClient
 
 
-# TODO: refactor this to remove config path and config name
 @click.group()
-@click.option(
-    "--config-path", default=None, help="Path to the configuration file"
-)
-@click.option(
-    "--config-name", default=None, help="Name of the configuration to use"
-)
-@click.option(
-    "--base-url",
-    default="http://localhost:8000",
-    help="Base URL for client mode",
-)
 @click.pass_context
-def cli(ctx, config_path, config_name, base_url):
+def cli(ctx):
     """R2R CLI for all core operations."""
-    if config_path and config_name:
-        raise click.UsageError(
-            "Cannot specify both config_path and config_name"
-        )
-
-    if config_path:
-        config_path = os.path.abspath(config_path)
 
-    ctx.obj = R2RClient(base_url)
+    ctx.obj = R2RClient()

py/cli/commands/server.py

@@ -182,7 +182,14 @@ def generate_report():
 )
 @click.option("--project-name", default="r2r", help="Project name for Docker")
 @click.option("--image", help="Docker image to use")
-@click.option("--config-path", help="Path to the configuration file")
+@click.option(
+    "--config-name", default=None, help="Name of the R2R configuration to use"
+)
+@click.option(
+    "--config-path",
+    default=None,
+    help="Path to a custom R2R configuration file",
+)
 @click.pass_obj
 def serve(
     client,
@@ -194,6 +201,7 @@ def serve(
     exclude_postgres,
     project_name,
     image,
+    config_name,
     config_path,
 ):
     """Start the R2R server."""
@@ -239,7 +247,7 @@ def serve(
             click.echo(f"Opening browser to {url}")
             webbrowser.open(url)
     else:
-        run_local_serve(client, host, port)
+        run_local_serve(host, port, config_name, config_path)
 
 
 @cli.command()

py/cli/utils/docker_utils.py

@@ -73,8 +73,11 @@ def remove_r2r_network():
 
 
 def run_local_serve(
-    obj: R2RClient, host: str, port: int, config_path: Optional[str] = None
-):
+    host: str,
+    port: int,
+    config_name: Optional[str] = None,
+    config_path: Optional[str] = None,
+) -> None:
     try:
         from r2r import R2R
     except ImportError:
@@ -83,14 +86,17 @@ def run_local_serve(
         )
         sys.exit(1)
 
-    r2r_instance = R2R()
-    llm_provider = r2r_instance.config.completion.provider
-    llm_model = r2r_instance.config.completion.generation_config.model
-    model_provider = llm_model.split("/")[0]
+    r2r_instance = R2R(config_name=config_name, config_path=config_path)
+
+    if config_name or config_path:
+        completion_config = r2r_instance.config.completion
+        llm_provider = completion_config.provider
+        llm_model = completion_config.generation_config.model
+        model_provider = llm_model.split("/")[0]
+        check_llm_reqs(llm_provider, model_provider, include_ollama=True)
 
     available_port = find_available_port(port)
 
-    check_llm_reqs(llm_provider, model_provider, include_ollama=True)
     r2r_instance.serve(host, available_port)
 
 
@@ -115,10 +121,8 @@ def run_docker_serve(
             config_name = client.config_name
         else:
             config_name = "default"
-
-        config = R2RConfig.from_toml(
-            R2RBuilder.CONFIG_OPTIONS[config_name]
-        )
+
+        config = R2RConfig.from_toml(R2RBuilder.CONFIG_OPTIONS[config_name])
 
     completion_provider = config.completion.provider
     completion_model = config.completion.generation_config.model

py/core/__init__.py

@@ -174,6 +174,9 @@
     "RelationshipType",
     "format_entity_types",
     "format_relations",
+    ## INTEGRATIONS
+    # Serper
+    "SerperClient",
     ## MAIN
     ## R2R ABSTRACTIONS
     "R2RProviders",

py/core/base/abstractions/search.py

@@ -15,7 +15,7 @@ class VectorSearchResult(BaseModel):
     fragment_id: UUID
     extraction_id: UUID
     document_id: UUID
-    user_id: UUID
+    user_id: Optional[UUID]
     group_ids: list[UUID]
     score: float
     text: str

py/core/examples/scripts/serve_with_hyde.py

@@ -0,0 +1,20 @@
+from r2r import R2RBuilder, R2RConfig, R2RPipeFactoryWithMultiSearch
+import fire
+
+
+def main(task_prompt_name="hyde"):
+    # Load the default configuration file
+    config = R2RConfig.from_toml()
+
+    app = (
+        R2RBuilder(config)
+        .with_pipe_factory(R2RPipeFactoryWithMultiSearch)
+        .build(
+            # Add optional override arguments which propagate to the pipe factory
+            task_prompt_name=task_prompt_name,
+        )
+    )
+    app.serve()
+
+if __name__ == "__main__":
+    fire.Fire(main)

py/core/examples/scripts/run_web_rag.py → py/core/examples/scripts/serve_with_web.py

@@ -1,24 +1,16 @@
 import fire
-from core.base.abstractions.llm import GenerationConfig
 from r2r import R2RBuilder, SerperClient, WebSearchPipe
 
 
-def run_rag_pipeline(query="Who was Aristotle?"):
+def run_rag_pipeline():
     # Create search pipe override and pipes
     web_search_pipe = WebSearchPipe(
         serper_client=SerperClient()  # TODO - Develop a `WebSearchProvider` for configurability
     )
 
     app = R2RBuilder().with_vector_search_pipe(web_search_pipe).build()
 
-    # Run the RAG pipeline through the R2R application
-    result = app.rag(
-        query,
-        rag_generation_config=GenerationConfig(model="gpt-4o"),
-    )
-
-    print(f"Search Results:\n\n{result.search_results}")
-    print(f"RAG Results:\n\n{result.completion}")
+    app.serve()
 
 
 if __name__ == "__main__":

py/core/examples/scripts/run_web_multi_rag.py → py/core/examples/scripts/serve_with_web_hyde.py

@@ -4,7 +4,7 @@
 from core.main.assembly.factory_extensions import R2RPipeFactoryWithMultiSearch
 
 
-def run_rag_pipeline(query="Who was Aristotle?"):
+def run_rag_pipeline():
     # Initialize a web search pipe
     web_search_pipe = WebSearchPipe(serper_client=SerperClient())
 
@@ -37,17 +37,7 @@ def run_rag_pipeline(query="Who was Aristotle?"):
             multi_inner_search_pipe_override=web_search_pipe,
             query_generation_template_override=synthetic_query_generation_template,
         )
-    )
-
-    # Run the RAG pipeline through the R2R application
-    result = app.rag(
-        query,
-        rag_generation_config=GenerationConfig(model="gpt-4o"),
-    )
-
-    print(f"Search Results:\n\n{result.search_results}")
-    print(f"RAG Results:\n\n{result.completion}")
-
+    ).serve()
 
 if __name__ == "__main__":
     fire.Fire(run_rag_pipeline)

py/core/main/api/routes/auth/base.py

@@ -20,7 +20,9 @@
 
 
 class AuthRouter(BaseRouter):
-    def __init__(self, engine: "R2REngine", run_type: RunType = RunType.INGESTION):
+    def __init__(
+        self, engine: "R2REngine", run_type: RunType = RunType.INGESTION
+    ):
         super().__init__(engine, run_type)
         self.setup_routes()
 

py/core/main/api/routes/ingestion/base.py

@@ -19,7 +19,9 @@
 
 
 class IngestionRouter(BaseRouter):
-    def __init__(self, engine: R2REngine, run_type: RunType = RunType.INGESTION):
+    def __init__(
+        self, engine: R2REngine, run_type: RunType = RunType.INGESTION
+    ):
         super().__init__(engine, run_type)
         self.openapi_extras = self.load_openapi_extras()
         self.setup_routes()

py/core/main/api/routes/management/base.py

@@ -31,7 +31,9 @@
 
 
 class ManagementRouter(BaseRouter):
-    def __init__(self, engine: R2REngine, run_type: RunType = RunType.MANAGEMENT):
+    def __init__(
+        self, engine: R2REngine, run_type: RunType = RunType.MANAGEMENT
+    ):
         super().__init__(engine, run_type)
         self.start_time = datetime.now(timezone.utc)
         self.setup_routes()
@@ -99,8 +101,10 @@ async def get_analytics_app(
 
             try:
                 result = await self.engine.aanalytics(
-                    filter_criteria=LogFilterCriteria(**filter_criteria),
-                    analysis_types=AnalysisTypes(**analysis_types),
+                    filter_criteria=LogFilterCriteria(filters=filter_criteria),
+                    analysis_types=AnalysisTypes(
+                        analysis_types=analysis_types
+                    ),
                 )
                 return result
             except json.JSONDecodeError as e:

py/core/main/api/routes/restructure/base.py

@@ -7,7 +7,9 @@
 
 
 class RestructureRouter(BaseRouter):
-    def __init__(self, engine: R2REngine, run_type: RunType = RunType.RESTRUCTURE):
+    def __init__(
+        self, engine: R2REngine, run_type: RunType = RunType.RESTRUCTURE
+    ):
         super().__init__(engine, run_type)
         self.setup_routes()
 

py/core/main/api/routes/retrieval/base.py

@@ -23,7 +23,9 @@
 
 
 class RetrievalRouter(BaseRouter):
-    def __init__(self, engine: R2REngine, run_type: RunType = RunType.RETRIEVAL):
+    def __init__(
+        self, engine: R2REngine, run_type: RunType = RunType.RETRIEVAL
+    ):
         super().__init__(engine, run_type)
         self.openapi_extras = self.load_openapi_extras()
         self.setup_routes()

py/core/main/app_entry.py

@@ -22,7 +22,6 @@ class PipelineType(Enum):
 def r2r_app(
     config_name: Optional[str] = "default",
     config_path: Optional[str] = None,
-    base_url: Optional[str] = None,
     pipeline_type: PipelineType = PipelineType.QNA,
 ) -> FastAPI:
     if pipeline_type != PipelineType.QNA:
@@ -58,19 +57,16 @@ def r2r_app(
 config_path = os.getenv("CONFIG_PATH", None)
 if not config_path and not config_name:
     config_name = "default"
-base_url = os.getenv("BASE_URL")
 host = os.getenv("HOST", "0.0.0.0")
 port = int(os.getenv("PORT", "8000"))
 pipeline_type = os.getenv("PIPELINE_TYPE", "qna")
 
 logger.info(f"Environment CONFIG_NAME: {config_name}")
 logger.info(f"Environment CONFIG_PATH: {config_path}")
-logger.info(f"Environment BASE_URL: {base_url}")
 logger.info(f"Environment PIPELINE_TYPE: {pipeline_type}")
 
 app = r2r_app(
     config_name=config_name,
     config_path=config_path,
-    base_url=base_url,
     pipeline_type=PipelineType(pipeline_type),
 )

py/core/main/assembly/builder.py

@@ -44,7 +44,9 @@ class R2RBuilder:
     CONFIG_OPTIONS["default"] = None
 
     @staticmethod
-    def _get_config(config_name):
+    def _get_config(config_name, config_path=None):
+        if config_path:
+            return R2RConfig.from_toml(config_path)
         if config_name is None:
             return R2RConfig.from_toml()
         if config_name in R2RBuilder.CONFIG_OPTIONS:
@@ -55,10 +57,15 @@ def __init__(
         self,
         config: Optional[R2RConfig] = None,
         config_name: Optional[str] = None,
+        config_path: Optional[str] = None,
     ):
-        if config and config_name:
-            raise ValueError("Cannot specify both config and config_name")
-        self.config = config or R2RBuilder._get_config(config_name)
+        if sum(x is not None for x in [config, config_name, config_path]) > 1:
+            raise ValueError(
+                "Specify only one of config, config_name, or config_path"
+            )
+        self.config = config or R2RBuilder._get_config(
+            config_name, config_path
+        )
         self.r2r_app_override: Optional[Type[R2REngine]] = None
         self.provider_factory_override: Optional[Type[R2RProviderFactory]] = (
             None

py/core/main/assembly/factory.py

@@ -215,6 +215,7 @@ def create_prompt_provider(
         prompt_provider = None
         if prompt_config.provider == "r2r":
             from core.providers import R2RPromptProvider
+
             prompt_provider = R2RPromptProvider(prompt_config)
         else:
             raise ValueError(