pirag 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

app/main.py

@@ -1,81 +1,49 @@
-import argparse, os
-from dotenv import load_dotenv
 from loguru import logger
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
 
-load_dotenv(dotenv_path=os.environ.get('ENV_FILE', '.env'), override=True)
+import app.rag.config as cfn
+import app.rag.api as api
+import app.rag.cli as cli
 
-from app.rag.config import top_parser, common_parser, setup_logger
-from app.rag.doctor import help as doctor_help, parser as doctor_parser, route as doctor_route
-from app.rag.train import help as train_help, parser as train_parser, route as train_route
-from app.rag.ask import help as ask_help, parser as ask_parser, route as ask_route
-from app.rag.test import help as test_help, parser as test_parser, route as test_route
+# Command definitions
+commands = {
+    "serve"  : ("Start the RAG server",     "Run a FastAPI-based RAG server",              api.serve),
+    "chat"   : ("Chat with the RAG system", "Run an interactive chat with the RAG system", cli.chat),
+    "train"  : ("Train the RAG system",     "Run a pipeline to train the RAG system",      cli.train),
+    "test"   : ("Test the RAG system",      "Run a pipeline to test the RAG system",       cli.test),
+    "doctor" : ("Diagnose the RAG system",  "Run a pipeline to diagnose the RAG system",   cli.doctor),
+}
 
 # Main parser
-parser = argparse.ArgumentParser(
-    formatter_class = argparse.ArgumentDefaultsHelpFormatter,
-    description = 'Pilot of On-Premise RAG',
-    parents = [top_parser],
+parser = ArgumentParser(
+    formatter_class = ArgumentDefaultsHelpFormatter,
+    description = """
+        Pilot of On-Premise RAG.
+    """,
+    parents = [cfn.top_parser, cfn.common_parser],
     add_help = False,
 )
 
-# Commands
-subparsers = parser.add_subparsers(
-    title = 'commands',
-    dest = 'command',
-)
-
-subparsers.add_parser(
-    'doctor',
-    help = doctor_help,
-    description = doctor_parser.description,
-    parents = [top_parser, common_parser, doctor_parser],
-    add_help = False,
-)
-
-subparsers.add_parser(
-    'train',
-    help = train_help,
-    description = train_parser.description,
-    parents = [top_parser, common_parser, train_parser],
-    add_help = False,
-)
-
-subparsers.add_parser(
-    'test',
-    help = test_help,
-    description = test_parser.description,
-    parents = [top_parser, common_parser, test_parser],
-    add_help = False,
-)
-
-subparsers.add_parser(
-    'ask',
-    help = ask_help,
-    description = ask_parser.description,
-    parents = [top_parser, common_parser, ask_parser],
-    add_help = False,
-)
+# Add command parsers
+subparsers = parser.add_subparsers(title="commands", dest="command")
+for name, (help, description, _) in commands.items():
+    subparsers.add_parser(
+        name = name,
+        help = help,
+        description = description,
+        parents = [cfn.common_parser],
+        add_help = False,
+    )
 
 def main():
     args = parser.parse_args()
-    setup_logger(
-        log_level = args.log_level,
-        log_dir = args.log_dir,
-    )
-    command_message = f"with command: {args.command}" if args.command else ""
-    logger.info(f"RAG Started {command_message}")
+    cfn.setup_logger(cfn.LOG_LEVEL, cfn.LOG_SAVE, cfn.LOG_DIR)
     logger.debug(f"Parsed arguments: {args}")
 
-    if args.command == 'doctor':
-        doctor_route(args)
-    elif args.command == 'ask':
-        ask_route(args)
-    elif args.command == 'train':
-        train_route(args)
-    elif args.command == 'test':
-        test_route(args)
+    if func := commands.get(args.command):
+        func[-1]()
     else:
         parser.print_help()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

app/rag/api.py

@@ -0,0 +1,50 @@
+import uvicorn
+from fastapi import FastAPI, Request, Depends, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+
+from loguru import logger
+import app.rag.config as cfn
+from app.rag.v1.router import router as core_router
+
+# Initialize FastAPI app
+api = FastAPI(
+    title = "RAG API",
+    description = "API for Retrieval-Augmented Generation",
+    version = cfn.__version__,
+)
+
+# Add CORS middleware
+api.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@api.get("/")
+async def _():
+    return {"message": "RAG API is running"}
+
+
+@api.get("/livez")
+async def _():
+    return {"status": "ok"}
+
+
+@api.get("/readyz")
+async def _():
+    return {"status": "ok"}
+
+api.include_router(router=core_router, prefix="/v1")
+
+def serve():
+    print("Serving the RAG API...")
+    print(cfn.API_HOST, cfn.API_PORT, cfn.API_RELOAD)
+    uvicorn.run(
+        app = "app.rag.api:api",
+        host = cfn.API_HOST,
+        port = cfn.API_PORT,
+        reload = cfn.API_RELOAD,
+    )

app/rag/cli.py

@@ -0,0 +1,33 @@
+import app.rag.config as cfn
+from loguru import logger
+
+from app.rag.llm.service import doctor as doctor_llm
+from app.rag.embedding.service import doctor as doctor_embedding
+from app.rag.vector_store.service import doctor as doctor_vector_store
+
+def chat():
+    print("Chatting with the RAG system...")
+
+
+def train():
+    print("Training the RAG system...")
+
+
+def test():
+    print("Testing the RAG system...")
+
+
+def doctor():
+    logger.info("💚 Doctoring the RAG system...")
+
+    # -- LLM Server
+    logger.info("Checking the LLM server (OpenAI-compatible)...")
+    doctor_llm()
+
+    # -- Embedding Server
+    logger.info("Checking the embedding server (OpenAI-compatible)...")
+    doctor_embedding()
+
+    # -- Vector Store
+    logger.info("Checking the vector store server (Milvus)...")    
+    doctor_vector_store()

app/rag/config.py

@@ -1,35 +1,82 @@
-import argparse, os, sys
-from pathlib import Path
+import argparse, sys, pathlib
 from loguru import logger
+from dynaconf import Dynaconf
+from importlib.metadata import version, PackageNotFoundError
+try:
+    __version__ = version("pirag")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+
+# -- Load configuration
+settings = Dynaconf(
+    settings_files = ["settings.yaml"],
+    envvar_prefix = False,
+    load_dotenv = False,
+)
+
+
+# -- Loging
+LOG_LEVEL: str = settings.get("LOG.LEVEL", "INFO").upper()
+if LOG_LEVEL not in ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"]:
+    raise ValueError(f"Invalid log level: {LOG_LEVEL}. Must be one of: INFO, DEBUG, WARNING, ERROR, CRITICAL")
+
+LOG_SAVE: bool = settings.get("LOG.SAVE", False)
+LOG_DIR: str = settings.get("LOG.DIR", ".pirag/logs")
 
-# Logger format constants
 LOG_TIME_FORMAT = "{time:YYYY-MM-DD HH:mm:ss.SSS!UTC}Z"
 LOG_FILE_FORMAT = f"{LOG_TIME_FORMAT} | {{level: <8}} | {{name}}:{{function}}:{{line}} - {{message}}"
 LOG_CONSOLE_FORMAT_FULL = f"<green>{LOG_TIME_FORMAT}</green> | <level>{{level: <8}}</level> | <cyan>{{name}}</cyan>:<cyan>{{function}}</cyan>:<cyan>{{line}}</cyan> - <level>{{message}}</level>\n"
 LOG_CONSOLE_FORMAT_SIMPLE = f"<green>{LOG_TIME_FORMAT}</green> | <level>{{level: <8}}</level> | <level>{{message}}</level>\n"
 
-def setup_logger(log_level: str, log_dir: str):
+
+# -- Serving API
+API_HOST: str = settings.get("API.HOST", "0.0.0.0")
+API_PORT: int = settings.get("API.PORT", 8000)
+API_RELOAD: bool = settings.get("API.RELOAD", True)
+
+
+# -- LLM Server
+LLM_BASE_URL: str = settings.get("LLM.BASE_URL", "http://localhost:11434")
+LLM_API_KEY: str = settings.get("LLM.API_KEY", "llm_api_key")
+LLM_MODEL: str = settings.get("LLM.MODEL", "gemma3:4b")
+
+
+# -- Embedding Server
+EMBEDDING_BASE_URL: str = settings.get("EMBEDDING.BASE_URL", "http://localhost:11434")
+EMBEDDING_API_KEY: str = settings.get("EMBEDDING.API_KEY", "embedding_api_key")
+EMBEDDING_MODEL: str = settings.get("EMBEDDING.MODEL", "nomic-embed-text:latest")
+EMBEDDING_DIMENSION: int = settings.get("EMBEDDING.DIMENSION", 768)
+
+
+# -- Data Warehouse
+MINIO_BASE_URL: str = settings.get("MINIO.BASE_URL", "http://localhost:9000")
+MINIO_ACCESS_KEY: str = settings.get("MINIO.ACCESS_KEY", "minioadmin")
+MINIO_SECRET_KEY: str = settings.get("MINIO.SECRET_KEY", "minioadmin")
+MINIO_BUCKET: str = settings.get("MINIO.BUCKET", "pirag")
+MINIO_REGION: str = settings.get("MINIO.REGION", "us-east-1")
+
+
+# -- Vector Store
+MILVUS_BASE_URL: str = settings.get("MILVUS.BASE_URL", "http://localhost:19530")
+MILVUS_USER: str = settings.get("MILVUS.USER", "milvus")
+MILVUS_PASSWORD: str = settings.get("MILVUS.PASSWORD", "milvus")
+MILVUS_DATABASE: str = settings.get("MILVUS.DATABASE", "milvus_database")
+MILVUS_COLLECTION: str = settings.get("MILVUS.COLLECTION", "milvus_collection")
+MILVUS_METRIC_TYPE: str = settings.get("MILVUS.METRIC_TYPE", "IP")
+
+
+# -- Monitoring
+LANGFUSE_BASE_URL: str = settings.get("LANGFUSE.BASE_URL", "http://localhost:8000")
+LANGFUSE_API_KEY: str = settings.get("LANGFUSE.API_KEY", "langfuse_api_key")
+LANGFUSE_PROJECT_ID: str = settings.get("LANGFUSE.PROJECT_ID", "langfuse_project_id")
+
+
+def setup_logger(log_level: str, log_save: bool, log_dir: str):
     """Configure logger with specified level and outputs"""
-    
-    log_dir = Path(log_dir)
-    log_dir.mkdir(exist_ok=True, parents=True)
-    
+
     logger.remove()
-    
-    # File handler
-    logger.add(
-        sink = log_dir / "{time:YYYYMMDD-HHmmss!UTC}Z.log",
-        level = log_level,
-        rotation = "100 MB",
-        retention = 0,
-        format = LOG_FILE_FORMAT,
-        serialize = False,
-        enqueue = True,
-        backtrace = True,
-        diagnose = True,
-        catch = True
-    )
-    
+
     # Console handler
     logger.add(
         sink = sys.stderr,
@@ -38,114 +85,40 @@ def setup_logger(log_level: str, log_dir: str):
         colorize = True
     )
 
-
-class EnvDefault(argparse.Action):
-    """Custom argparse action that uses environment variables as defaults.
-
-    This action extends the standard argparse.Action to support reading default values
-    from environment variables. If the specified environment variable exists, its value
-    will be used as the default value for the argument.
-
-    For boolean flags (store_true/store_false), the environment variable is interpreted
-    as a boolean value where 'true', '1', 'yes', or 'on' (case-insensitive) are
-    considered True.
-
-    Args:
-        envvar (str): Name of the environment variable to use as default
-        required (bool, optional): Whether the argument is required. Defaults to True.
-            Note: If a default value is found in environment variables, required is set to False.
-        default (Any, optional): Default value if environment variable is not set. Defaults to None.
-        **kwargs: Additional arguments passed to argparse.Action
-
-    Example:
-        ```python
-        parser.add_argument(
-            '--log-level',
-            envvar='LOG_LEVEL',
-            help='Logging level',
-            default='INFO',
-            action=EnvDefault
+    if log_save:
+        log_dir = pathlib.Path(log_dir)
+        log_dir.mkdir(exist_ok=True, parents=True)
+
+        # File handler
+        logger.add(
+            sink = log_dir / "{time:YYYYMMDD-HHmmss!UTC}Z.log",
+            level = log_level,
+            rotation = "100 MB",
+            retention = 0,
+            format = LOG_FILE_FORMAT,
+            serialize = False,
+            enqueue = True,
+            backtrace = True,
+            diagnose = True,
+            catch = True
         )
-        ```
-
-    Note:
-        The help text is automatically updated to include the environment variable name.
-    """
-    def __init__(self, envvar, required=True, default=None, **kwargs):
-        if envvar and envvar in os.environ:
-            env_value = os.environ[envvar]
-            # Convert string environment variable to boolean
-            if kwargs.get('nargs') is None and kwargs.get('const') is not None:  # store_true/store_false case
-                default = env_value.lower() in ('true', '1', 'yes', 'on')
-            else:
-                default = env_value
-            logger.debug(f"Using {envvar}={default} from environment")
-        
-        if envvar:
-            kwargs["help"] += f" (envvar: {envvar})"
-        
-        if required and default:
-            required = False
-            
-        super(EnvDefault, self).__init__(default=default, required=required, **kwargs)
-        self.envvar = envvar
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, values if values is not None else self.default)
-
-
-# Top-level parser with common options
-top_parser = argparse.ArgumentParser(add_help=False)
-
-top_parser.add_argument(
-    '-h', '--help',
-    help = 'Show help message and exit',
-    default = argparse.SUPPRESS,
-    action = 'help',
-)
 
-top_parser.add_argument(
-    '--env-file',
-    envvar = 'ENV_FILE',
-    help = 'Path to environment file',
-    default = '.env',
-    type = str,
-    action = EnvDefault,
-)
-
-top_parser.add_argument(
-    '--log-level',
-    envvar = 'LOG_LEVEL',
-    help = 'Logging level',
-    default = 'INFO',
-    type = lambda x: x.upper(),
-    choices = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
-    required = False,
-    action = EnvDefault,
-)
 
+# Top-level parser 
+top_parser = argparse.ArgumentParser(add_help=False)
 top_parser.add_argument(
-    '--log-dir',
-    envvar = 'LOG_DIR',
-    help = 'Path to log directory',
-    default = '.pirag/logs',
-    type = str,
-    required = False,
-    action = EnvDefault,
+    "-v", "--version",
+    help = "Show the `pirag` application's version and exit",
+    action = "version",
+    version = f"{__version__}",
 )
 
-top_parser.add_argument(
-    '--log-save',
-    envvar = 'LOG_SAVE',
-    help = 'Save log to file. If this flag is set, the log will be saved to the file specified in the `--log-path`.',
-    default = False,
-    const = True,
-    nargs = 0,
-    type = bool,
-    required = False,
-    action = EnvDefault,
-)
 
-common_parser = argparse.ArgumentParser(
-    add_help = False,
+# Common parser
+common_parser = argparse.ArgumentParser(add_help=False)
+common_parser.add_argument(
+    "-h", "--help",
+    help = "Show help message and exit",
+    default = argparse.SUPPRESS,
+    action = "help",
 )

app/rag/embedding/client.py

@@ -0,0 +1,70 @@
+import requests
+from langchain_openai.embeddings import OpenAIEmbeddings
+
+import app.rag.config as cfn
+from app.rag.utils import connection_check
+
+
+class EmbeddingClient:
+    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 = OpenAIEmbeddings(
+                    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 embedding 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) -> str:
+        """Generate text from prompt"""
+        if not self._is_connected or self._client is None:
+            return ""
+        return self._client.embed_query(prompt)
+    
+    @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 = EmbeddingClient(
+    base_url = cfn.EMBEDDING_BASE_URL,
+    api_key = cfn.EMBEDDING_API_KEY,
+    model = cfn.EMBEDDING_MODEL,
+)

app/rag/embedding/service.py

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

app/rag/llm/client.py

@@ -0,0 +1,70 @@
+import requests
+from langchain_openai.llms import OpenAI
+
+import app.rag.config as cfn
+from app.rag.utils import connection_check
+
+
+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) -> str:
+        """Generate text from prompt"""
+        if not self._is_connected or self._client is None:
+            return ""
+        return self._client.invoke(prompt)
+    
+    @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/service.py

@@ -0,0 +1,26 @@
+from loguru import logger
+
+import app.rag.config as cfn
+from .client import client
+
+def doctor():
+    # 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/utils.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=5)
+            self._is_connected = True
+            return func(self, *args, **kwargs)
+        except requests.exceptions.ConnectionError:
+            self._is_connected = False
+            return []
+    return wrapper

app/rag/v1/router.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,81 @@
+import requests
+from pymilvus import MilvusClient
+from pymilvus.exceptions import MilvusException
+
+import app.rag.config as cfn
+from app.rag.utils 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
+        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/service.py

@@ -0,0 +1,43 @@
+from loguru import logger
+
+import app.rag.config as cfn
+from .client import client
+
+def doctor():
+    # 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)")
+            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)")
+        else:
+            if not client.has_collection(cfn.MILVUS_COLLECTION):
+                logger.error(f"- ❌ FAILED: Vector store collections (Collection '{cfn.MILVUS_COLLECTION}' not found)")
+            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,10 +1,9 @@
-# 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

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.6.dist-info → pirag-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pirag
-Version: 0.1.6
+Version: 0.2.0
 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,10 +9,11 @@ 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
 Dynamic: license-file

pirag-0.2.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+app/main.py,sha256=4yUp70bM0mn1AwL00-ttPO-wUn8nUgehRstFGQIytSc,1573
+app/requirements.txt,sha256=SVy0-4AaepRwHLga-DaO_HiegjR1IUORWbGHMu3GanE,112
+app/setup.py,sha256=nwUhqn3SLcm6L-WN0saHFisF-K9BpMR3qktszjBJcA4,736
+app/rag/api.py,sha256=68HuxoYMkViFnr4iZKFLt6Y8fCkntrUXcnL3weSWEfw,1101
+app/rag/cli.py,sha256=J4IBNOwi1B_qws3HP5OAHV82X1b56zPJcmR1w-Lkem8,822
+app/rag/config.py,sha256=kHgsy4z8HGXq-zlwTYcgjcvxkly79mb8rTw6DY0zTB8,4369
+app/rag/utils.py,sha256=svN1mEWf9mGrJ67PTwn8KNP2b6OuE08qkdslK4T11bM,510
+app/rag/agent/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/embedding/client.py,sha256=tu5LgZx1QuadYtViUQkLdFJAC99S2iB01jY0wOO5PCc,2159
+app/rag/embedding/service.py,sha256=XC5SYIbwp8eTFu3zY5OYKlpELGpeRp-G2OPYmJWsko4,994
+app/rag/llm/client.py,sha256=pFUsTgsBkPS0m5P0Btv9pgHHR9Os6NxEzM43GQSXwiA,2092
+app/rag/llm/service.py,sha256=HBEnVyek-dz8pwv8wTHXG8d7oBT1uScMcr7omYVoSv0,928
+app/rag/test/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/train/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/v1/router.py,sha256=mE-c-c_vNVN_V7M0-Z8OSGlzWTOa419sfxSV35Qs7DU,133
+app/rag/v1/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/rag/vector_store/client.py,sha256=nFDS3ARTZhojXcFoo6AvCpK_qeTaEYt8WihllPD6ZSM,2613
+app/rag/vector_store/service.py,sha256=xuamcVIHDgPC8XsbsPTRaE3L7hfLTmM1eS9ZOXLdw9c,1919
+pirag-0.2.0.dist-info/licenses/LICENSE,sha256=gBUmwRyDQYI4Q4Ju5S88urvB-B-nqsXN45n8oQ3DZ3Y,1079
+pirag-0.2.0.dist-info/METADATA,sha256=5rnLQ9cQMjNfeDwgxq-WDFoCpnfEiV_hJfYZwmcTBDQ,5563
+pirag-0.2.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+pirag-0.2.0.dist-info/entry_points.txt,sha256=1tHs5rP66AVq5SMEWRRIWRf_XqJo2Gb1TJl9-Kw_MSo,40
+pirag-0.2.0.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+pirag-0.2.0.dist-info/RECORD,,

{pirag-0.1.6.dist-info → pirag-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.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

app/rag/train/config.py

@@ -1,20 +0,0 @@
-import argparse
-
-help = "Train the RAG system."
-
-parser = argparse.ArgumentParser(
-    description = f"{help} Processes documents, extracts knowledge, generates embeddings, and builds a searchable vector database for efficient semantic retrieval and contextual responses",
-    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",
-)

app/rag/train/router.py

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

pirag-0.1.6.dist-info/RECORD

@@ -1,27 +0,0 @@
-app/main.py,sha256=yPDjSCvnbrJBCHKSKmf6-2DhjLOhDd7WalfuMvfuC_s,2235
-app/requirements.txt,sha256=JFEWoQHN7hwDg0bDrWlN0vxZVR3oe8dYgv7mkHrQg1g,128
-app/setup.py,sha256=j9qcfapv_jOW3jORYGfHzKDAcxNRItHcHA34_mMDGj4,744
-app/rag/agent.py,sha256=u1ovyqALsmOMHDCW-hdlkMU72XdlTMiFJ-WRbLHHrYQ,2190
-app/rag/config.py,sha256=Gm4fAHZrlTiRmzRjyzx73TL0J3lxjhjlsFyuGG-8f0o,4914
-app/rag/ask/__init__.py,sha256=41lK4nmvWT2ZZ3G_FMtOiG-0JFJdDVT4zoxkoes8TaE,59
-app/rag/ask/config.py,sha256=tRHOBrEAmTMBaBmYPKPsRJmSaVyKT8-TBSDJQXEndxc,386
-app/rag/ask/router.py,sha256=5nuaaHzWVr2ltYqOuQ30ujmZ-GFyx-22OLVODILd5iE,76
-app/rag/ask/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-app/rag/doctor/__init__.py,sha256=41lK4nmvWT2ZZ3G_FMtOiG-0JFJdDVT4zoxkoes8TaE,59
-app/rag/doctor/config.py,sha256=CW0scwLkRykKLp15szu6Q9i3sG7n70ZJ0eYOtkjuS9Q,765
-app/rag/doctor/router.py,sha256=5nuaaHzWVr2ltYqOuQ30ujmZ-GFyx-22OLVODILd5iE,76
-app/rag/doctor/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-app/rag/test/__init__.py,sha256=41lK4nmvWT2ZZ3G_FMtOiG-0JFJdDVT4zoxkoes8TaE,59
-app/rag/test/config.py,sha256=tk-IM1VspaUPgwWKSwYWagkdYXfOjIAjU3-c0rxMBoc,361
-app/rag/test/router.py,sha256=5nuaaHzWVr2ltYqOuQ30ujmZ-GFyx-22OLVODILd5iE,76
-app/rag/test/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-app/rag/train/__init__.py,sha256=41lK4nmvWT2ZZ3G_FMtOiG-0JFJdDVT4zoxkoes8TaE,59
-app/rag/train/config.py,sha256=PO4iRMmZXViFHOMBbOOhnFHqBu8hRfbI61zGCuksKhI,668
-app/rag/train/router.py,sha256=5nuaaHzWVr2ltYqOuQ30ujmZ-GFyx-22OLVODILd5iE,76
-app/rag/train/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pirag-0.1.6.dist-info/licenses/LICENSE,sha256=gBUmwRyDQYI4Q4Ju5S88urvB-B-nqsXN45n8oQ3DZ3Y,1079
-pirag-0.1.6.dist-info/METADATA,sha256=jNjeKOkfiXZkL8EFdO_lUH7gUqiErbmE6pWMBaraeuM,5537
-pirag-0.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pirag-0.1.6.dist-info/entry_points.txt,sha256=1tHs5rP66AVq5SMEWRRIWRf_XqJo2Gb1TJl9-Kw_MSo,40
-pirag-0.1.6.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
-pirag-0.1.6.dist-info/RECORD,,