pirag 0.1.7__py3-none-any.whl → 0.2.2__py3-none-any.whl

app/rag/llm/client.py

@@ -0,0 +1,128 @@
+import requests
+import time
+from langchain_openai.llms import OpenAI
+from typing import Dict, Tuple, Any, List, Optional
+
+import app.rag.config as cfn
+from app.rag.utilities import connection_check
+from .utilities import MetricCallbackHandler
+
+class LLMClient:
+    def __init__(self, base_url: str, api_key: str, model: str):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.model = model
+        self._is_connected = True
+        self._client = None
+        
+        if self.check_connection():
+            try:
+                self._client = OpenAI(
+                    base_url = base_url,
+                    api_key = api_key,
+                    model = model
+                )
+            except Exception as e:
+                self._is_connected = False
+    
+    def check_connection(self) -> bool:
+        """Check if the LLM server is accessible"""
+        try:
+            requests.head(url=self.base_url, timeout=5)
+        except requests.exceptions.ConnectionError:
+            self._is_connected = False
+            return False
+        self._is_connected = True
+        return True
+    
+    @connection_check
+    def generate(self, prompt: str) -> tuple:
+        """Generate text from prompt and return usage information
+        
+        Returns:
+            tuple: (generated_text, usage_info)
+        """
+        if not self._is_connected or self._client is None:
+            return "", {}
+        
+        response = self._client.generate([prompt])
+        return response.generations[0][0].text, response.llm_output
+    
+    @connection_check
+    def generate_with_metrics(self, prompt: str) -> Tuple[str, Dict[str, Any]]:
+        """Generate text with timing and usage metrics
+        
+        Returns:
+            tuple: (generated_text, metrics_info)
+        """
+        if not self._is_connected or self._client is None:
+            return "", {"error": "LLM client not connected"}
+        
+        handler = MetricCallbackHandler()
+        
+        # Create streaming client with callback
+        streaming_client = OpenAI(
+            base_url=self.base_url,
+            api_key=self.api_key,
+            model=self.model,
+            streaming=True,
+            callbacks=[handler]
+        )
+        
+        # Make a single request
+        response = streaming_client.generate([prompt], callbacks=[handler])
+        
+        # Get base metrics from response
+        metrics = {}
+        
+        # Extract token usage from response
+        llm_output = response.llm_output if hasattr(response, 'llm_output') else {}
+        
+        # Check if token_usage exists in the response
+        token_usage = llm_output.get('token_usage', {})
+        if token_usage:
+            # If token_usage is available, copy it to our metrics
+            metrics.update(token_usage)
+        
+        # Add model name if available
+        if 'model_name' in llm_output:
+            metrics['model'] = llm_output['model_name']
+        else:
+            metrics['model'] = self.model
+        
+        # Calculate and add timing metrics
+        metrics['ttft'] = handler.ttft or 0.0
+        metrics['total_time'] = (handler.end_time or time.time()) - handler.start_time
+        metrics['tokens_per_second'] = handler.calculate_tokens_per_second()
+        metrics['completion_tokens'] = handler.token_count
+        
+        return handler.result, metrics
+    
+    @connection_check
+    def list_models(self) -> list:
+        """List available models"""
+        if not self._is_connected:
+            return []
+        try:
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers={"Authorization": f"Bearer {self.api_key}"}
+            )
+            if response.status_code == 200:
+                return [model['id'] for model in response.json()['data']]
+            return []
+        except Exception:
+            return []
+    
+    @connection_check
+    def has_model(self, model: str) -> bool:
+        """Check if model exists"""
+        if not self._is_connected:
+            return False
+        return model in self.list_models()
+
+client = LLMClient(
+    base_url = cfn.LLM_BASE_URL,
+    api_key = cfn.LLM_API_KEY,
+    model = cfn.LLM_MODEL,
+)

app/rag/llm/services.py

@@ -0,0 +1,26 @@
+from loguru import logger
+
+import app.rag.config as cfn
+from .client import client
+
+def doctor(resolve: bool):
+    # Check connection
+    is_connected = client.check_connection()
+    if not is_connected:
+        logger.error(f"- ❌ FAILED: LLM connection ({cfn.LLM_BASE_URL})")
+    else:
+        logger.info(f"- ✅ PASSED: LLM connection ({cfn.LLM_BASE_URL})")
+    
+    # Check model availability
+    try:
+        if not is_connected:
+            logger.warning(f"- ⏭️  SKIPPED: LLM model (Server is not accessible)")
+        else:
+            # List models
+            models = client.list_models()
+            if cfn.LLM_MODEL not in models:
+                logger.error(f"- ❌ FAILED: LLM model not found ({cfn.LLM_MODEL})")
+            else:
+                logger.info(f"- ✅ PASSED: LLM model found (Model `{cfn.LLM_MODEL}` exists)")
+    except Exception as e:
+        logger.error(f"- ❌ FAILED: LLM model check ({str(e)})")

app/rag/llm/utilities.py

@@ -0,0 +1,40 @@
+import time
+from langchain.callbacks.base import BaseCallbackHandler
+
+class MetricCallbackHandler(BaseCallbackHandler):
+    def __init__(self):
+        self.start_time = time.time()
+        self.ttft = None
+        self.first_token_time = None
+        self.result = ""
+        self.end_time = None
+        self.token_count = 0
+        self.token_timestamps = []
+    
+    def on_llm_new_token(self, token: str, **kwargs):
+        current_time = time.time()
+        self.token_count += 1
+        self.token_timestamps.append(current_time)
+        
+        if self.ttft is None:
+            self.ttft = current_time - self.start_time
+            self.first_token_time = current_time
+            
+        self.result += token
+    
+    def on_llm_end(self, *args, **kwargs):
+        self.end_time = time.time()
+    
+    def calculate_tokens_per_second(self):
+        """Calculate tokens per second after the first token"""
+        if self.token_count <= 1 or self.first_token_time is None or self.end_time is None:
+            return 0.0
+        
+        # Calculate time from first token to completion (exclude TTFT)
+        generation_time = self.end_time - self.first_token_time
+        if generation_time <= 0:
+            return 0.0
+        
+        # Exclude the first token from the count since we're measuring from after it arrived
+        tokens_after_first = self.token_count - 1
+        return tokens_after_first / generation_time

app/rag/models.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+class SystemStatusResponse(BaseModel):
+    """
+    Response model for the system status endpoint.
+    """
+    status: int
+    message: str
+    
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "status": 200,
+                    "message": "System is running normally"
+                }
+            ]
+        }
+    }

app/rag/routers.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter
+
+from .models import SystemStatusResponse
+
+system_router = APIRouter()
+
+@system_router.get(
+    path = "/",
+    summary = "Root Endpoint",
+    description = "Root endpoint for the RAG API",
+    response_model = SystemStatusResponse,
+)
+async def root():
+    return SystemStatusResponse(
+        status = 200,
+        message = "RAG API is running. If you want to see API documentation, please visit /docs",
+    )
+
+@system_router.get(
+    path = "/livez",
+    summary = "Liveness Probe",
+    description = "Check if the RAG API is running",
+    response_model = SystemStatusResponse,
+)
+async def livez():
+    return SystemStatusResponse(
+        status = 200,
+        message = "RAG API is live",
+    )
+
+@system_router.get(
+    path = "/readyz",
+    summary = "Readiness Probe",
+    description = "Check if the RAG API is ready to serve requests",
+    response_model = SystemStatusResponse,
+)
+async def readyz():
+    return SystemStatusResponse(
+        status = 200,
+        message = "RAG API is ready to serve requests",
+    )

app/rag/utilities.py

@@ -0,0 +1,15 @@
+import requests
+from functools import wraps
+
+def connection_check(func):
+    """Check if the server is accessible. `base_url` and `_is_connected` must be provided."""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            requests.head(url=self.base_url, timeout=1)
+            self._is_connected = True
+            return func(self, *args, **kwargs)
+        except requests.exceptions.ConnectionError:
+            self._is_connected = False
+            return []
+    return wrapper

app/rag/v1/routers.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/")
+async def root():
+    return {"message": "RAG API is running"}

app/rag/vector_store/client.py

@@ -0,0 +1,84 @@
+import requests
+from pymilvus import MilvusClient
+from pymilvus.exceptions import MilvusException
+
+import app.rag.config as cfn
+from app.rag.utilities import connection_check
+
+
+class VectorStoreClient(MilvusClient):
+    def __init__(self, base_url: str, user: str, password: str, database: str, collection: str, metric_type: str):
+        self.base_url = base_url
+        self.user = user
+        self.password = password
+        self.database = database
+        self.collection = collection
+        self.metric_type = metric_type
+        self._is_connected = True
+        self._is_database_exists = True
+
+        if self.check_connection():
+            try:
+                super().__init__(
+                    uri = base_url,
+                    db_name = database,
+                    collection = collection,
+                    user = user,
+                    password = password,
+                    metric_type = metric_type,
+                )
+            except MilvusException as e:
+                if e.code == 800:  # database not found
+                    self._is_database_exists = False
+                else:
+                    raise
+
+    def check_connection(self) -> bool:
+        """Check if the Milvus server is accessible"""
+        try:
+            requests.head(url=self.base_url, timeout=5)
+        except requests.exceptions.ConnectionError:
+            self._is_connected = False
+            return False
+        except requests.exceptions.ReadTimeout:
+            self._is_connected = False
+            return False
+        self._is_connected = True
+        return True
+
+    @connection_check
+    def get_databases(self) -> list:
+        """Get list of available databases"""
+        if not self._is_database_exists:
+            return []
+        return self.list_databases()
+
+    @connection_check
+    def get_collections(self) -> list:
+        """Get list of available collections"""
+        if not self._is_database_exists:
+            return []
+        return self.list_collections()
+
+    @connection_check
+    def has_database(self, database: str) -> bool:
+        """Check if database exists"""
+        if not self._is_database_exists:
+            return False
+        return database in self.get_databases()
+
+    @connection_check
+    def has_collection(self, collection: str) -> bool:
+        """Check if collection exists"""
+        if not self._is_database_exists:
+            return False
+        return collection in self.get_collections()
+
+client = VectorStoreClient(
+    base_url = cfn.MILVUS_BASE_URL,
+    user = cfn.MILVUS_USER,
+    password = cfn.MILVUS_PASSWORD,
+    database = cfn.MILVUS_DATABASE,
+    collection = cfn.MILVUS_COLLECTION,
+    metric_type = cfn.MILVUS_METRIC_TYPE,
+)

app/rag/vector_store/services.py

@@ -0,0 +1,56 @@
+from loguru import logger
+
+import app.rag.config as cfn
+from .client import client
+
+def doctor(resolve: bool):
+    # Check connection
+    is_connected = client.check_connection()
+    if not is_connected:
+        logger.error(f"- ❌ FAILED: Vector store connection ({cfn.MILVUS_BASE_URL})")
+    else:
+        logger.info(f"- ✅ PASSED: Vector store connection ({cfn.MILVUS_BASE_URL})")
+    
+    # Check databases
+    databases = None
+    try:
+        databases = client.get_databases()
+        if not is_connected:
+            logger.warning("- ⏭️  SKIPPED: Vector store databases (Server is not accessible)")
+        else:
+            if not client.has_database(cfn.MILVUS_DATABASE):
+                logger.error(f"- ❌ FAILED: Vector store databases (Database '{cfn.MILVUS_DATABASE}' not found)")
+                if resolve:
+                    logger.info(f"- 🔧 Resolving issue: Creating database '{cfn.MILVUS_DATABASE}'")
+                    client.create_database(cfn.MILVUS_DATABASE)
+            else:
+                logger.info(f"- ✅ PASSED: Vector store databases (Database '{cfn.MILVUS_DATABASE}' exists)")
+    except Exception as e:
+        logger.error(f"- ❌ FAILED: Database check ({str(e)})")
+    
+    # Check collections
+    try:
+        collections = client.get_collections()
+        if not is_connected:
+            logger.warning("- ⏭️  SKIPPED: Vector store collections (Server is not accessible)")
+        elif len(databases) == 0:
+            logger.warning("- ⏭️  SKIPPED: Vector store collections (No database available)")
+        elif len(collections) == 0:
+            logger.error("- ❌ FAILED: Vector store collections (No collections available)")
+            if resolve:
+                logger.info(f"- 🔧 Resolving issue: Creating collection '{cfn.MILVUS_COLLECTION}'")
+                client.create_collection(cfn.MILVUS_COLLECTION)
+        else:
+            if not client.has_collection(cfn.MILVUS_COLLECTION):
+                logger.error(f"- ❌ FAILED: Vector store collections (Collection '{cfn.MILVUS_COLLECTION}' not found)")
+                if resolve:
+                    logger.info(f"- 🔧 Resolving issue: Creating collection '{cfn.MILVUS_COLLECTION}'")
+                    client.create_collection(
+                        collection_name = cfn.MILVUS_COLLECTION,
+                        dimension = cfn.EMBEDDING_DIMENSION,
+                        metric_type = cfn.MILVUS_METRIC_TYPE
+                    )
+            else:
+                logger.info(f"- ✅ PASSED: Vector store collections (Collection '{cfn.MILVUS_COLLECTION}' exists)")
+    except Exception as e:
+        logger.error(f"- ❌ FAILED: Collection check ({str(e)})")

app/requirements.txt

@@ -1,11 +1,12 @@
-# Core dependencies
-python-dotenv < 1.2
+# App
+dynaconf < 3.3
 loguru < 0.8
-
-# Development
 pytest < 8.4
-black < 25.2
+fastapi < 0.116
+uvicorn < 0.35
 
 # RAG
 ragas < 0.3
 pymilvus < 2.6
+langchain-openai < 0.4
+langchain-ollama < 0.4

app/setup.py

@@ -1,6 +1,5 @@
+import os, tomli
 from setuptools import setup, find_packages
-import os, sys
-import tomli
 
 # Load requirements
 with open(os.path.join(os.path.dirname(__file__), 'requirements.txt'), 'r') as f:
@@ -21,7 +20,7 @@ setup(
     install_requires = requirements,
     entry_points = {
         "console_scripts": [
-            f"{APP_NAME}=main:main",
+            f"{APP_NAME}=app.cli:main",
         ],
     },
 )

{pirag-0.1.7.dist-info → pirag-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pirag
-Version: 0.1.7
+Version: 0.2.2
 Summary: CLI Projects of On-Premise RAG. You can use your own LLM and vector DB. Or just add remote LLM servers and vector DB.
 Author-email: semir4in <semir4in@gmail.com>, jyje <jyjeon@outlook.com>
 Project-URL: Homepage, https://github.com/jyje/pilot-onpremise-rag
@@ -9,12 +9,15 @@ Project-URL: Issue, https://github.com/jyje/pilot-onpremise-rag/issues
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-dotenv<1.2
+Requires-Dist: dynaconf<3.3
 Requires-Dist: loguru<0.8
 Requires-Dist: pytest<8.4
-Requires-Dist: black<25.2
+Requires-Dist: fastapi<0.116
+Requires-Dist: uvicorn<0.35
 Requires-Dist: ragas<0.3
 Requires-Dist: pymilvus<2.6
+Requires-Dist: langchain-openai<0.4
+Requires-Dist: langchain-ollama<0.4
 Dynamic: license-file
 
 <div align="center">

pirag-0.2.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+app/main.py,sha256=H2M3jzG61MvEszebTdvrQc2PyHiKTwVoLFJo_W-T50s,2335
+app/requirements.txt,sha256=SvJdCesmBDu3w8ANXuFkHUf08NsxIlI3PMmDCuPrUps,158
+app/setup.py,sha256=nwUhqn3SLcm6L-WN0saHFisF-K9BpMR3qktszjBJcA4,736
+app/rag/api.py,sha256=IdM296NbcyF4yzLRpTnsAiPRMntHBlTYJwW7rx-18qo,1077
+app/rag/cli.py,sha256=IgzViBkIMIkdwYk4F3nrp-wMpBciza_yod6rt98HBZA,1703
+app/rag/config.py,sha256=qenCAkJdgMWEMODuWWhtx6wJzsxDW7yUcY6nz37G33Q,4938
+app/rag/models.py,sha256=VwkNFwzzTKeGUEkx4MPJR0Y2y1uaIMu37ja58Za70GY,415
+app/rag/routers.py,sha256=Jv1rAmIl6-sRy5YLvEbRF2kpME_XYVC5Gm3Lxb6NAvw,1058
+app/rag/utilities.py,sha256=AyKNakKmbNcAhjGUj9h2UUQGQV0A4759mJpTlCvMrCY,510
+app/rag/agent/services.py,sha256=xi38u5cL1t5doVMnfOLIOb1aux1XCkqBf3yhKzQZBaw,199
+app/rag/embedding/client.py,sha256=RKNKc1Tt0c_uLfNsd4ZWsBrEYmFEy59Xdromn-gKcg4,2163
+app/rag/embedding/services.py,sha256=6LbbU5RetvO5DuB2AyLMw0r7Lnsi5u_mEoRusqDZu_E,1007
+app/rag/llm/client.py,sha256=FdvbSq-_PMjYp3nD9iNzLiWnylFg8Zuc5cPnaPMLO-c,4231
+app/rag/llm/services.py,sha256=5fQ_KdHpgt5PdHXQO54EnUSeQvyVtteXtRFbPb1Smwg,941
+app/rag/llm/utilities.py,sha256=xLMxdwetxAetJP23uqygjy0zt_mCot4ToEZDl6zkGrA,1437
+app/rag/test/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/train/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/v1/routers.py,sha256=mE-c-c_vNVN_V7M0-Z8OSGlzWTOa419sfxSV35Qs7DU,133
+app/rag/v1/services.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/vector_store/client.py,sha256=aj7xPOIua0c0Z_ZuVJ52NNQtrEpdbzyTxAM7-oNE2qM,2729
+app/rag/vector_store/services.py,sha256=oslu4Yzubd7MYVhVEHDIV1pBh18VsrbvmW_1_5sMn-8,2705
+pirag-0.2.2.dist-info/licenses/LICENSE,sha256=gBUmwRyDQYI4Q4Ju5S88urvB-B-nqsXN45n8oQ3DZ3Y,1079
+pirag-0.2.2.dist-info/METADATA,sha256=VlARBEA9P4ZmyoEjVd2NXjHBTPWO0SuDI9hSZMjTf-o,5635
+pirag-0.2.2.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+pirag-0.2.2.dist-info/entry_points.txt,sha256=1tHs5rP66AVq5SMEWRRIWRf_XqJo2Gb1TJl9-Kw_MSo,40
+pirag-0.2.2.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+pirag-0.2.2.dist-info/RECORD,,

{pirag-0.1.7.dist-info → pirag-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

app/rag/agent.py

@@ -1,64 +0,0 @@
-from langchain_openai.llms import OpenAI
-from langchain_openai.embeddings import OpenAIEmbeddings
-from pymilvus import MilvusClient
-
-class Agent():
-    def __init__(
-        self,
-        llm_base_url: str,
-        llm_api_key: str,
-        llm_model: str,
-        embedding_base_url: str,
-        embedding_api_key: str,
-        embedding_model: str,
-        milvus_host: str,
-        milvus_database: str,
-        milvus_collection: str,
-    ):
-        self.llm_base_url = llm_base_url
-        self.llm_api_key = llm_api_key
-        self.llm_model = llm_model
-        self.embedding_base_url = embedding_base_url
-        self.embedding_api_key = embedding_api_key
-        self.embedding_model = embedding_model
-        self.milvus_host = milvus_host
-        self.milvus_database = milvus_database
-        self.milvus_collection = milvus_collection
-        
-        self._llm_client: OpenAI = None
-        self._embedding_client: OpenAIEmbeddings = None
-        self._milvus_client: MilvusClient = None
-
-    def retrieve_knowledge_base(self, query: str) -> str:
-        llm_client = self._get_llm_client()
-        embedding_client = self._get_embedding_client()
-        milvus_client = self._get_milvus_client()
-    
-        
-    def _get_llm_client(self) -> OpenAI:
-        if self._llm_client is None:
-            self._llm_client = OpenAI(
-                base_url=self.llm_base_url,
-                api_key=self.llm_api_key,
-                model=self.llm_model,
-            )
-        return self._llm_client
-
-
-    def _get_embedding_client(self) -> OpenAIEmbeddings:
-        if self._embedding_client is None:
-            self._embedding_client = OpenAIEmbeddings(
-                base_url=self.embedding_base_url,
-                api_key=self.embedding_api_key,
-                model=self.embedding_model,
-            )
-        return self._embedding_client
-
-    def _get_milvus_client(self) -> MilvusClient:
-        if self._milvus_client is None:
-            self._milvus_client = MilvusClient(
-                host=self.milvus_host,
-                database=self.milvus_database,
-                collection=self.milvus_collection,
-            )
-        return self._milvus_client

app/rag/ask/__init__.py

@@ -1,2 +0,0 @@
-from .config import parser, help
-from .router import route

app/rag/ask/config.py

@@ -1,9 +0,0 @@
-import argparse
-
-help = "Ask a question to the RAG system."
-
-parser = argparse.ArgumentParser(
-    description = f"{help} Queries the knowledge base with natural language questions, retrieves relevant context, and generates accurate, contextually-aware responses based on the retrieved information",
-    add_help = False,
-    formatter_class = argparse.ArgumentDefaultsHelpFormatter,
-)

app/rag/ask/router.py

@@ -1,4 +0,0 @@
-from argparse import Namespace
-
-def route(args: Namespace):
-    print(args)

app/rag/doctor/__init__.py

@@ -1,2 +0,0 @@
-from .config import parser, help
-from .router import route

app/rag/doctor/config.py

@@ -1,24 +0,0 @@
-import argparse
-
-from app.rag.config import top_parser, common_parser
-
-help = "Diagnose the RAG system."
-
-parser = argparse.ArgumentParser(
-    description = f"{help} Performs comprehensive health checks on all components, validates configurations, and reports issues to ensure optimal system operation",
-    add_help = False,
-    formatter_class = argparse.ArgumentDefaultsHelpFormatter,
-)
-
-subparsers = parser.add_subparsers(
-    title = "subcommands",
-    dest = "subcommand",
-)
-
-subparsers.add_parser(
-    "check",
-    help = "Check RAG System. Scan all components of the system and diagnose status",
-    description = "Check RAG System. Scan all components of the system and diagnose status",
-    parents = [top_parser, common_parser],
-    add_help = False,
-)

app/rag/doctor/router.py

@@ -1,4 +0,0 @@
-from argparse import Namespace
-
-def route(args: Namespace):
-    print(args)

app/rag/test/__init__.py

@@ -1,2 +0,0 @@
-from .config import parser, help
-from .router import route

app/rag/test/config.py

@@ -1,9 +0,0 @@
-import argparse
-
-help = "Test the RAG system."
-
-parser = argparse.ArgumentParser(
-    description = f"{help} Evaluates system performance by running predefined test cases, measuring accuracy, relevance, and latency metrics to validate retrieval and generation capabilities",
-    add_help = False,
-    formatter_class = argparse.ArgumentDefaultsHelpFormatter,
-)

app/rag/test/router.py

@@ -1,4 +0,0 @@
-from argparse import Namespace
-
-def route(args: Namespace):
-    print(args)

app/rag/train/__init__.py

@@ -1,2 +0,0 @@
-from .config import parser, help
-from .router import route