fix: make external services optional

app/database.py

@@ -3,26 +3,46 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, Session
 from app.config import get_settings
 from app.models import Base
+import logging
 
+logger = logging.getLogger(__name__)
 settings = get_settings()
 
-engine = create_engine(
-    settings.DATABASE_URL,
-    pool_pre_ping=True,
-    pool_size=10,
-    max_overflow=20
-)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+# Create engine with connection pooling
+try:
+    engine = create_engine(
+        settings.DATABASE_URL,
+        pool_pre_ping=True,
+        pool_size=10,
+        max_overflow=20
+    )
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    logger.info("Database engine created successfully")
+except Exception as e:
+    logger.warning(f"Failed to create database engine: {e}")
+    engine = None
+    SessionLocal = None
 
 
 def init_db():
     """Initialize database tables."""
-    Base.metadata.create_all(bind=engine)
+    if engine is None:
+        logger.warning("Database not configured - skipping initialization")
+        return
+    
+    try:
+        Base.metadata.create_all(bind=engine)
+        logger.info("Database tables created successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize database: {e}")
+        raise
 
 
 def get_db() -> Session:
     """Dependency for getting database session."""
+    if SessionLocal is None:
+        raise RuntimeError("Database not configured")
+    
     db = SessionLocal()
     try:
         yield db

app/main.py

@@ -42,18 +42,24 @@ async def startup_event():
     """Initialize on startup."""
     logger.info("Starting Ragora API...")
     
-    # Initialize database
-    init_db()
-    logger.info("Database initialized")
+    # Initialize database (optional)
+    try:
+        init_db()
+        logger.info("Database initialized")
+    except Exception as e:
+        logger.warning(f"Database initialization skipped: {e}")
     
-    # Initialize vector DB collection
-    embedder = get_embedder_port()
-    vector_db = get_vector_db_port()
-    await vector_db.initialize_collection(
-        settings.QDRANT_COLLECTION,
-        embedder.get_dimension()
-    )
-    logger.info("Vector DB initialized")
+    # Initialize vector DB collection (optional)
+    try:
+        embedder = get_embedder_port()
+        vector_db = get_vector_db_port()
+        await vector_db.initialize_collection(
+            settings.QDRANT_COLLECTION,
+            embedder.get_dimension()
+        )
+        logger.info("Vector DB initialized")
+    except Exception as e:
+        logger.warning(f"Vector DB initialization skipped: {e}")
 
 
 @app.get("/health")

app/services/storage_adapter.py

@@ -14,14 +14,20 @@ class MinIOStorageAdapter(StoragePort):
     """MinIO implementation of StoragePort."""
     
     def __init__(self):
-        self.client = Minio(
-            settings.MINIO_ENDPOINT,
-            access_key=settings.MINIO_ACCESS_KEY,
-            secret_key=settings.MINIO_SECRET_KEY,
-            secure=settings.MINIO_SECURE
-        )
-        self.bucket = settings.MINIO_BUCKET
-        self._ensure_bucket()
+        try:
+            self.client = Minio(
+                settings.MINIO_ENDPOINT,
+                access_key=settings.MINIO_ACCESS_KEY,
+                secret_key=settings.MINIO_SECRET_KEY,
+                secure=settings.MINIO_SECURE
+            )
+            self.bucket = settings.MINIO_BUCKET
+            self._ensure_bucket()
+            logger.info(f"Connected to MinIO at {settings.MINIO_ENDPOINT}")
+        except Exception as e:
+            logger.warning(f"Failed to connect to MinIO: {e}")
+            self.client = None
+            self.bucket = None
     
     def _ensure_bucket(self):
         """Ensure bucket exists."""

app/services/vector_db_adapter.py

@@ -14,14 +14,23 @@ class QdrantAdapter(VectorDBPort):
     """Qdrant implementation of VectorDBPort."""
     
     def __init__(self):
-        self.client = QdrantClient(
-            host=settings.QDRANT_HOST,
-            port=settings.QDRANT_PORT
-        )
-        logger.info(f"Connected to Qdrant at {settings.QDRANT_HOST}:{settings.QDRANT_PORT}")
+        try:
+            self.client = QdrantClient(
+                host=settings.QDRANT_HOST,
+                port=settings.QDRANT_PORT,
+                timeout=5.0
+            )
+            logger.info(f"Connected to Qdrant at {settings.QDRANT_HOST}:{settings.QDRANT_PORT}")
+        except Exception as e:
+            logger.warning(f"Failed to connect to Qdrant: {e}")
+            self.client = None
     
     async def initialize_collection(self, collection_name: str, dimension: int) -> None:
         """Initialize vector collection."""
+        if self.client is None:
+            logger.warning("Qdrant client not available - skipping collection initialization")
+            return
+        
         try:
             collections = self.client.get_collections().collections
             exists = any(c.name == collection_name for c in collections)