Merge branch 'main' into devops

Author: Locatelli-Flor

DocsManager/.env.example

@@ -11,12 +11,16 @@ RABBITMQ_PASSWORD=guest
 RABBITMQ_HOST=localhost
 RABBITMQ_PORT=5672
 RABBITMQ_MANAGEMENT_PORT=15672
+RABBITMQ_QUEUE_NAME=document.process
+RABBITMQ_EXCHANGE_NAME=minio-events
+
 
 # MinIO Configuration
 MINIO_ENDPOINT=localhost:9000
 MINIO_ACCESS_KEY=minioadmin
 MINIO_SECRET_KEY=minioadmin
 MINIO_BUCKET=goland-bucket
+MINIO_FOLDER=rag-docs
 MINIO_USE_SSL=false
 
 # OpenAI Configuration

DocsManager/app/api/routes/admin.py

@@ -12,8 +12,6 @@
 from app.core.db_connection import get_db
 from app.models.document import Document as DocumentModel
 from app.services.minio_service import minio_service
-from app.core.rabbitmq import rabbitmq
-from app.core.config import settings
 
 logger = logging.getLogger(__name__)
 
@@ -31,10 +29,12 @@ async def upload_document(file: UploadFile = File(...), db: Session = Depends(ge
 
     Flow:
     1. Validate file
-    2. Save to MinIO
+    2. Save to MinIO (in the folder specified by MINIO_FOLDER)
     3. Save metadata to PostgreSQL
-    4. Publish message to RabbitMQ
-    5. Return immediate response
+    4. Return immediate response
+    
+    Note: MinIO events will automatically publish a message to RabbitMQ
+    when a file is created in the configured folder.
     """
     try:
         # 1. Validate file
@@ -105,21 +105,9 @@ async def upload_document(file: UploadFile = File(...), db: Session = Depends(ge
                 detail=f"Failed to save document metadata: {str(e)}"
             )
 
-        # 4. Publish message to RabbitMQ (only after successful DB commit)
-        message = {
-            "document_id": document_id,
-            "minio_path": minio_path,
-            "filename": file.filename,
-        }
-
-        try:
-            rabbitmq.publish_message(settings.queue_name, message)
-        except Exception as e:
-            logger.error(f"Failed to publish message to RabbitMQ: {e}")
-            # Don't fail the request, but log the error
-            # The document is already saved, it can be processed manually
-
-        # 5. Return response
+        # 4. Return response
+        # Note: MinIO events will automatically publish a message to RabbitMQ
+        # when the file is created in the configured folder
         return DocumentUploadResponse(
             id=document_id,
             filename=file.filename,

DocsManager/app/core/config.py

@@ -29,13 +29,15 @@ class Settings(BaseSettings):
     minio_access_key: str
     minio_secret_key: str
     minio_bucket: str = "documents"
+    minio_folder: str = "rag-docs"
     minio_use_ssl: bool = True
 
     # Database Configuration (for SQLAlchemy)
     database_url: str = ""
 
-    # Application
-    queue_name: str = "document.process"
+    # RabbitMQ Queue/Exchange
+    rabbitmq_queue_name: str = "document.process"
+    rabbitmq_exchange_name: str = "minio-events"
 
     model_config = SettingsConfigDict(
         env_file=".env",
@@ -53,13 +55,6 @@ def normalize_rabbitmq_host(cls, v: str) -> str:
             logger.warning("RABBITMQ_HOST is empty, using 'localhost' as default")
             return "localhost"
 
-        # Replace Docker service name with localhost
-        if v.strip() == "rabbitmq":
-            logger.warning(
-                "RABBITMQ_HOST='rabbitmq' detected. Changing to 'localhost' because app runs outside Docker"
-            )
-            return "localhost"
-        
         return v
 
     @model_validator(mode='after')

DocsManager/app/core/rabbitmq.py

@@ -46,12 +46,32 @@ def close(self):
             self.connection.close()
             logger.info("RabbitMQ connection closed")
 
-    def declare_queue(self, queue_name: str, durable: bool = True):
-        """Declares a queue"""
+    def declare_exchange(self, exchange_name: str, exchange_type: str = "direct", durable: bool = True):
+        """Declares an exchange"""
+        if not self.channel:
+            self.connect()
+        self.channel.exchange_declare(
+            exchange=exchange_name,
+            exchange_type=exchange_type,
+            durable=durable
+        )
+        logger.info(f"Exchange '{exchange_name}' declared")
+
+    def declare_queue(self, queue_name: str, exchange_name: str = None, durable: bool = True):
+        """Declares a queue and optionally binds it to an exchange"""
         if not self.channel:
             self.connect()
         self.channel.queue_declare(queue=queue_name, durable=durable)
         logger.info(f"Queue '{queue_name}' declared")
+        
+        # Bind to exchange if provided
+        if exchange_name:
+            self.channel.queue_bind(
+                queue=queue_name,
+                exchange=exchange_name,
+                routing_key=queue_name
+            )
+            logger.info(f"Queue '{queue_name}' bound to exchange '{exchange_name}'")
 
     def publish_message(self, queue_name: str, message: dict):
         """Publishes a message to the queue"""

DocsManager/app/services/minio_service.py

@@ -66,7 +66,9 @@ def upload_file(self, file_data: bytes, filename: str, content_type: str = "appl
         try:
             # Generate a unique name for the file
             file_extension = filename.split(".")[-1] if "." in filename else "pdf"
-            object_name = f"{uuid.uuid4()}.{file_extension}"
+            # Use MINIO_FOLDER to organize files in a specific folder
+            folder = settings.minio_folder.rstrip("/")  # Remove trailing slash if present
+            object_name = f"{folder}/{uuid.uuid4()}.{file_extension}"
 
             file_stream = BytesIO(file_data)
             file_size = len(file_data)

DocsManager/main.py

@@ -25,9 +25,13 @@ async def startup_event():
         init_db()
         logging.info("Database initialized successfully")
 
-        # Initialize RabbitMQ connection (will be used when publishing messages)
+        # Initialize RabbitMQ connection, exchange and queue
         from app.core.rabbitmq import rabbitmq
-        logging.info("RabbitMQ module loaded")
+        from app.core.config import settings
+        rabbitmq.connect()
+        rabbitmq.declare_exchange(settings.rabbitmq_exchange_name)
+        rabbitmq.declare_queue(settings.rabbitmq_queue_name, settings.rabbitmq_exchange_name)
+        logging.info(f"RabbitMQ initialized: exchange='{settings.rabbitmq_exchange_name}', queue='{settings.rabbitmq_queue_name}'")
     except Exception as e:
         logging.error(f"Failed to initialize services: {e}")
         raise

DocsManager/scripts/README.md

@@ -0,0 +1,175 @@
+# Scripts de Configuración
+
+## Orden de Ejecución
+
+**IMPORTANTE:** Los scripts deben ejecutarse en este orden:
+
+1. **setup_rabbitmq.sh** - Configura RabbitMQ (exchange, queue y binding)
+2. **setup_minio_events.sh** - Configura MinIO para enviar eventos a RabbitMQ
+
+## setup_rabbitmq.sh
+
+Script para configurar RabbitMQ con el exchange, queue y binding necesarios para recibir eventos de MinIO.
+
+### Requisitos Previos
+
+1. **rabbitmqadmin instalado** (el script intentará descargarlo automáticamente si no está disponible)
+2. **RabbitMQ corriendo** con el plugin de management habilitado
+
+### Uso
+
+```bash
+cd DocsManager/scripts
+./setup_rabbitmq.sh
+```
+
+### Qué hace el script
+
+1. Verifica/descarga `rabbitmqadmin` si no está instalado
+2. Crea el exchange `minio-events` (tipo: direct, durable)
+3. Crea la queue `document.process` (durable)
+4. Crea el binding entre el exchange y la queue
+5. Muestra la configuración resultante
+
+## setup_minio_events.sh
+
+Script para configurar eventos de MinIO hacia RabbitMQ. Cuando se crea un archivo en el bucket `goland-bucket` dentro de la carpeta especificada en `MINIO_FOLDER` (por defecto `rag-docs/`), MinIO publicará automáticamente un mensaje en la cola de RabbitMQ.
+
+### Requisitos Previos
+
+1. **MinIO Client (mc) instalado:**
+   ```bash
+   # macOS
+   brew install minio/stable/mc
+   
+   # Linux
+   wget https://dl.min.io/client/mc/release/linux-amd64/mc
+   chmod +x mc
+   sudo mv mc /usr/local/bin/
+   ```
+
+2. **MinIO corriendo** y accesible
+3. **RabbitMQ corriendo** y accesible
+4. **RabbitMQ ya configurado** (ejecutar `setup_rabbitmq.sh` primero)
+
+### Uso
+
+#### Opción 1: Usando variables de entorno del archivo .env
+
+El script automáticamente carga las variables del archivo `.env` en el directorio raíz de DocsManager:
+
+```bash
+cd DocsManager
+./scripts/setup_minio_events.sh
+```
+
+#### Opción 2: Usando variables de entorno directamente
+
+```bash
+export MINIO_ENDPOINT=localhost:9000
+export MINIO_ACCESS_KEY=minioadmin
+export MINIO_SECRET_KEY=minioadmin
+export MINIO_BUCKET=goland-bucket
+export MINIO_FOLDER=rag-docs
+export RABBITMQ_HOST=rabbitmq
+export RABBITMQ_USER=guest
+export RABBITMQ_PASSWORD=guest
+export QUEUE_NAME=document.process
+
+./scripts/setup_minio_events.sh
+```
+
+### Variables de Entorno
+
+El script utiliza las siguientes variables (con valores por defecto):
+
+| Variable | Descripción | Valor por Defecto |
+|----------|-------------|-------------------|
+| `MINIO_ENDPOINT` | Endpoint de MinIO (host:puerto) | `localhost:9000` |
+| `MINIO_ACCESS_KEY` | Clave de acceso de MinIO | `minioadmin` |
+| `MINIO_SECRET_KEY` | Clave secreta de MinIO | `minioadmin` |
+| `MINIO_BUCKET` | Nombre del bucket | `goland-bucket` |
+| `MINIO_FOLDER` | Carpeta dentro del bucket donde se monitorean los eventos | `rag-docs` |
+| `MINIO_USE_SSL` | Usar SSL para MinIO | `false` |
+| `RABBITMQ_HOST` | Host de RabbitMQ | `rabbitmq` |
+| `RABBITMQ_PORT` | Puerto de RabbitMQ | `5672` |
+| `RABBITMQ_USER` | Usuario de RabbitMQ | `guest` |
+| `RABBITMQ_PASSWORD` | Contraseña de RabbitMQ | `guest` |
+| `QUEUE_NAME` | Nombre de la cola | `document.process` |
+
+### Qué hace el script
+
+1. Verifica que `mc` esté instalado
+2. Carga variables de entorno desde `.env` (si existe)
+3. Configura un alias de MinIO
+4. Verifica la conexión a MinIO
+5. Crea el bucket si no existe
+6. Configura la notificación AMQP hacia RabbitMQ
+7. Reinicia MinIO para aplicar cambios
+8. Configura eventos para archivos en la carpeta especificada en `MINIO_FOLDER` dentro del bucket
+9. Muestra un resumen de la configuración
+
+### Formato del Mensaje
+
+Cuando MinIO detecta un nuevo archivo en la carpeta especificada en `MINIO_FOLDER` (por defecto `rag-docs/`), publica un mensaje JSON en RabbitMQ con el siguiente formato:
+
+```json
+{
+  "EventName": "s3:ObjectCreated:Put",
+  "Key": "rag-docs/uuid.pdf",
+  "Records": [
+    {
+      "eventVersion": "2.0",
+      "eventSource": "minio:s3",
+      "awsRegion": "",
+      "eventTime": "2025-01-XX...",
+      "eventName": "s3:ObjectCreated:Put",
+      "s3": {
+        "bucket": {
+          "name": "goland-bucket"
+        },
+        "object": {
+          "key": "rag-docs/uuid.pdf",
+          "size": 12345
+        }
+      }
+    }
+  ]
+}
+```
+
+### Verificar la Configuración
+
+Para verificar que los eventos están configurados:
+
+```bash
+mc event list myminio/goland-bucket
+```
+
+### Solución de Problemas
+
+1. **Error: "mc: command not found"**
+   - Instala MinIO Client siguiendo las instrucciones en "Requisitos Previos"
+
+2. **Error: "No se pudo conectar a MinIO"**
+   - Verifica que MinIO esté corriendo
+   - Verifica que el endpoint y las credenciales sean correctas
+   - Si MinIO está en Docker, usa `localhost` o el nombre del servicio
+
+3. **Error: "RabbitMQ connection failed"**
+   - Verifica que RabbitMQ esté corriendo
+   - Verifica que el host y puerto sean correctos
+   - Si RabbitMQ está en Docker, usa el nombre del servicio (`rabbitmq`) en lugar de `localhost`
+
+4. **Los eventos no se disparan**
+   - Verifica que los archivos se suban a la ruta especificada en `MINIO_FOLDER` dentro del bucket
+   - Verifica que la cola `document.process` exista en RabbitMQ
+   - Revisa los logs de MinIO para ver si hay errores
+
+### Notas
+
+- El script reinicia MinIO, lo que puede causar una breve interrupción del servicio
+- Los eventos solo se disparan para archivos nuevos (PUT), no para actualizaciones
+- El prefijo especificado en `MINIO_FOLDER` es obligatorio - los archivos fuera de esta carpeta no generarán eventos
+- Por defecto, `MINIO_FOLDER` está configurado como `rag-docs`, pero puedes cambiarlo usando la variable de entorno
+