fix: complete HF startup — libmagic, single worker, lazy models

Install libmagic in the Docker image, add MIME fallback detection, use one Uvicorn worker for HF memory limits, and defer ML model loading until first request.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -6,6 +6,7 @@ FROM python:3.11-slim AS builder
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     libpq-dev \
+    libmagic1 \
     curl \
     git \
     && rm -rf /var/lib/apt/lists/*
@@ -22,6 +23,7 @@ FROM python:3.11-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
     libpq5 \
+    libmagic1 \
     curl \
     redis-server \
     && rm -rf /var/lib/apt/lists/*
@@ -48,13 +50,16 @@ RUN adduser --disabled-password --gecos "" --uid 1000 appuser && \
     chown -R appuser:appuser /app /data
 USER appuser
 
-# Pre-download models
+# Pre-download models at build time (avoids cold-start delays)
 RUN python -c "from sentence_transformers import CrossEncoder; CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')" || true
 RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')" || true
 
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+# Verify the app imports cleanly before deployment
+RUN python -c "from app.main import app; print('App import OK:', app.title)"
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=5 \
     CMD curl -f http://localhost:8080/health || exit 1
 
 EXPOSE 8080
 
-CMD ["sh", "-c", "mkdir -p /data/chroma /data/uploads /data/redis && redis-server /app/redis-hf.conf && sleep 1 && alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8080 --workers 2 --loop uvloop --http httptools"]
+CMD ["sh", "-c", "mkdir -p /data/chroma /data/uploads /data/redis && redis-server /app/redis-hf.conf && sleep 1 && alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8080 --workers 1 --loop uvloop --http httptools"]

backend/app/main.py

@@ -30,16 +30,7 @@ logger = structlog.get_logger(__name__)
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """Handle application startup and shutdown lifecycle."""
     logger.info("Starting AuthorBot API", env=get_settings().APP_ENV)
-    # Startup: warm up local ML models (lazy-loaded via their modules)
-    from app.core.rag.intent import get_intent_classifier
-    from app.core.rag.reranker import get_reranker
-    from app.core.rag.guardrails import get_nli_model
-    await get_intent_classifier()
-    await get_reranker()
-    await get_nli_model()
-    logger.info("Local ML models warmed up successfully")
     yield
-    # Shutdown: close any open connections
     logger.info("AuthorBot API shutting down")
 
 

backend/app/utils/file_utils.py

@@ -6,9 +6,9 @@ RULE: Always validate by magic bytes, NEVER by file extension alone.
 
 import hashlib
 import os
+import zipfile
 from pathlib import Path
 
-import magic
 import structlog
 
 from app.config import get_settings
@@ -31,32 +31,70 @@ _SUPPORTED_MIME_TYPES: dict[str, str] = {
 }
 
 
-def compute_sha256(file_path: str) -> str:
-    """Compute SHA-256 hash of a file.
+def _detect_mime_from_signature(file_path: str) -> str | None:
+    """Detect MIME type from file signatures when libmagic is unavailable."""
+    with open(file_path, "rb") as handle:
+        header = handle.read(8)
+
+    if header.startswith(b"%PDF-"):
+        return "application/pdf"
+
+    if zipfile.is_zipfile(file_path):
+        with zipfile.ZipFile(file_path) as archive:
+            names = archive.namelist()
+            if any(name.startswith("word/") for name in names):
+                return "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            if "mimetype" in names:
+                with archive.open("mimetype") as mime_file:
+                    if b"epub" in mime_file.read().lower():
+                        return "application/epub+zip"
+            if any("META-INF/container.xml" in name for name in names):
+                return "application/epub+zip"
+
+    with open(file_path, "rb") as handle:
+        sample = handle.read(8192)
+    try:
+        sample.decode("utf-8")
+        return "text/plain"
+    except UnicodeDecodeError:
+        return None
+
+
+def detect_mime_type(file_path: str) -> str:
+    """Detect MIME type by inspecting file magic bytes.
 
     Args:
         file_path: Absolute path to the file.
 
     Returns:
-        Hex string of the SHA-256 hash (64 characters).
+        MIME type string (e.g., 'application/pdf').
     """
-    sha256 = hashlib.sha256()
-    with open(file_path, "rb") as f:
-        for chunk in iter(lambda: f.read(65536), b""):
-            sha256.update(chunk)
-    return sha256.hexdigest()
+    try:
+        import magic
 
+        return magic.from_file(file_path, mime=True)
+    except (ImportError, OSError) as exc:
+        logger.warning("libmagic unavailable, using signature fallback", error=str(exc))
+        mime_type = _detect_mime_from_signature(file_path)
+        if mime_type is None:
+            raise UnsupportedFormatError(extension=Path(file_path).suffix.lstrip(".")) from exc
+        return mime_type
 
-def detect_mime_type(file_path: str) -> str:
-    """Detect MIME type by inspecting file magic bytes.
+
+def compute_sha256(file_path: str) -> str:
+    """Compute SHA-256 hash of a file.
 
     Args:
         file_path: Absolute path to the file.
 
     Returns:
-        MIME type string (e.g., 'application/pdf').
+        Hex string of the SHA-256 hash (64 characters).
     """
-    return magic.from_file(file_path, mime=True)
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            sha256.update(chunk)
+    return sha256.hexdigest()
 
 
 def get_file_extension_from_mime(mime_type: str) -> str | None:
@@ -68,6 +106,8 @@ def get_file_extension_from_mime(mime_type: str) -> str | None:
     Returns:
         Extension label ('pdf', 'epub', 'docx', 'txt') or None if unsupported.
     """
+    if mime_type == "application/zip":
+        return None
     return _SUPPORTED_MIME_TYPES.get(mime_type)