Refactor for HF Spaces: single-container, SQLite shim, ChromaDB on /data

Mirrors the deployment shape used by the working HF Spaces deploys CCAI-Vibe-Demo and CU-Student-AIProject-Helper:

* multi-stage Dockerfile (Node CRA build -> python:3.12-slim + bundle), non-root uid 1000, port 7860, REACT_APP_API_URL='' so the SPA shares the FastAPI origin via a static mount at /.

* MongoDB replaced with a drop-in SQLite shim at app/core/db.py (aiosqlite on \/cybersecurity_panel.db). The shim emulates the pymongo/motor idioms the routers already call (find_one, find/sort/limit, insert_one, update_one/many, delete_one/many, replace_one, count_documents, find_one_and_delete, aggregate \/\/\) so router code is untouched.

* app/core/database.py keeps its public API (connect_to_mongo, close_mongo_connection, get_database) but now wraps the shim. canvas_database.py is now a no-op (schema lives in the shim's \_init_schema).

* requirements.txt: + aiosqlite~=0.20, - motor~=3.7. pymongo kept for bson.ObjectId and the error types the shim raises.

* RAGManager / EnhancedRAGManager / chroma_client now resolve their persist directories via _default_chroma_path('<subdir>') -> \/chroma/<subdir> when DATA_DIR is set, falling back to the historical relative paths for local installs. ChromaDB embeddings now survive HF Space rebuilds.

* Avatar URL fallback in config.py defaults to '' (relative) instead of http://localhost:8000 so single-origin deployments serve avatars off the same host as the SPA.

* GET / in api/routes/root.py moved to GET /api/info so the SPA owns the root path; main.py mounts ./static at / when present, otherwise keeps the JSON banner.

* docker-compose.yml rewritten as a single-service wrapper around the same image used on HF, with a cybersecurity_data named volume mounted at /data so SQLite + ChromaDB survive 'docker compose down'. Default host port is 7861 (override via CYBERPANEL_HOST_PORT) to avoid clashing with the CCAI demo on 3002/8002.

* README.md gains HF Space frontmatter (sdk: docker, app_port: 7860, title: Cybersecurity Panel) and a deployment section listing required Space secrets (JWT_SECRET_KEY, GEMINI_API_KEY, optional OPENAI_API_KEY / VLLM_API_KEY).

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

Dockerfile

@@ -1,45 +1,78 @@
-# syntax=docker/dockerfile:1
-FROM node:24-bookworm AS base
+# syntax=docker/dockerfile:1.7
+# ---------------------------------------------------------------------------
+# Cybersecurity Panel — single-container HuggingFace Spaces image.
+#
+# Mirrors the structural choices used by the working HF Spaces deployments
+# CCAI-Vibe-Demo and CU-Student-AIProject-Helper:
+#   * multi-stage Node frontend build → Python+SPA bundle
+#   * non-root user uid 1000, port 7860 (HF Spaces convention)
+#   * persistence on the HF Storage Bucket mount at /data (SQLite shim)
+#   * REACT_APP_API_URL is set to the empty string at build time so the SPA
+#     issues relative URLs and shares the FastAPI origin
+#
+# Build context: repo root (this file).
+# ---------------------------------------------------------------------------
 
-LABEL vendor=neon.ai \
-    ai.neon.name="CCAI-Demo"
+# ---- 1. Frontend build (CRA) ----------------------------------------------
+FROM node:20-bookworm AS frontend-build
+WORKDIR /app/frontend
 
-ENV OVOS_CONFIG_BASE_FOLDER=neon
-ENV OVOS_CONFIG_FILENAME=neon.yaml
-ENV XDG_CONFIG_HOME=/config
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-    python3 \
-    python3-pip \
-    && rm -rf /var/lib/apt/lists/*
-
-# ---- Python dependencies (cached unless requirements.txt changes) ----------
-WORKDIR /ccai/multi_llm_chatbot_backend
-COPY multi_llm_chatbot_backend/requirements.txt ./
-RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --break-system-packages -r requirements.txt
-
-# ---- Node dependencies (cached unless package.json changes) ----------------
-WORKDIR /ccai/phd-advisor-frontend
 COPY phd-advisor-frontend/package.json phd-advisor-frontend/package-lock.json* ./
 RUN --mount=type=cache,target=/root/.npm \
-    npm install
+    npm ci
+
+COPY phd-advisor-frontend/ ./
 
-# ---- Copy the rest of the source code (this layer changes often) -----------
-WORKDIR /ccai
-COPY . .
+# Empty REACT_APP_API_URL → CRA inlines '' so every fetch() hits the same
+# origin as the SPA (the FastAPI server below).
+ENV REACT_APP_API_URL=""
+RUN npm run build
 
-# ---- Backend target --------------------------------------------------------
-FROM base AS backend
-# Required for /api/voice/transcribe (browser WebM/Opus → WAV for Whisper).
+# ---- 2. Python runtime + SPA bundle ---------------------------------------
+FROM python:3.12-slim-bookworm
+
+# ffmpeg is required by the /api/voice/transcribe endpoint
+# (browser WebM/Opus → WAV for Whisper). Kept on the runtime image only,
+# not on the build image, so we don't pay the apt cost during incremental
+# code rebuilds.
 RUN apt-get update && \
     apt-get install -y --no-install-recommends ffmpeg && \
     rm -rf /var/lib/apt/lists/*
-WORKDIR /ccai/multi_llm_chatbot_backend
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
 
-# ---- Frontend target -------------------------------------------------------
-FROM base AS frontend
-WORKDIR /ccai/phd-advisor-frontend
-CMD [ "npm", "start" ]
+# HF Spaces runs the container as uid 1000 and expects the app to do the
+# same; with a non-root user we cannot bind privileged ports, but :7860 is
+# fine.
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1 \
+    CORS_ORIGINS=* \
+    DATA_DIR=/data \
+    CONFIG_PATH=/home/user/app/cybersecurity_config.yaml
+
+WORKDIR $HOME/app
+
+# ---- Python deps (cached unless requirements.txt changes) -----------------
+COPY --chown=user multi_llm_chatbot_backend/requirements.txt ./
+RUN --mount=type=cache,target=/home/user/.cache/pip,uid=1000,gid=1000 \
+    pip install --no-cache-dir --user -r requirements.txt
+
+# ---- Backend source -------------------------------------------------------
+COPY --chown=user multi_llm_chatbot_backend/ ./
+
+# ---- Top-level configuration files (config.yaml + persona definitions) ----
+COPY --chown=user cybersecurity_config.yaml ./cybersecurity_config.yaml
+COPY --chown=user phd_config.yaml ./phd_config.yaml
+COPY --chown=user undergrad_config.yaml ./undergrad_config.yaml
+COPY --chown=user personas/ ./personas/
+
+# ---- Frontend bundle ------------------------------------------------------
+# main.py mounts $HOME/app/static at "/" so the SPA is served same-origin
+# with the API.
+COPY --chown=user --from=frontend-build /app/frontend/build ./static
+
+ENV PYTHONPATH=$HOME/app
+
+EXPOSE 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,6 +1,35 @@
-# PhD Advisory Panel
+---
+title: Cybersecurity Panel
+emoji: 🛡️
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# Cybersecurity Panel
+
+An AI-powered cybersecurity guidance system that provides expert advice through a panel of specialized advisor personas. Ask about threats, compliance, incident response, architecture, and career growth and get diverse perspectives from multiple AI advisors. Built on Neon AI's Collaborative Conversational AI (CCAI) framework.
+
+## Hugging Face Spaces deployment
+
+This Space ships as a single Docker image built from the repository root [`Dockerfile`](Dockerfile). The container does three things:
+
+1. Builds the React frontend (CRA) at image-build time with `REACT_APP_API_URL=""` so every `fetch` issues a relative URL.
+2. Serves the bundled SPA from FastAPI at `/`, with the API exposed on `/api/...`, `/auth/...`, etc., on the same `:7860` origin.
+3. Persists user data (auth, profiles, chat sessions, onboarding, canvas state) in **SQLite via `aiosqlite`** at `${DATA_DIR}/cybersecurity_panel.db`. Mount a Hugging Face Storage Bucket at `/data` to make the database survive Space rebuilds — there is **no MongoDB**, **no Atlas**, no third-party data plane (the persistence pattern follows [`CU-Student-AIProject-Helper`](https://github.com/NeonClary/CU-Student-AIProject-Helper)).
+
+### Required Space secrets
+
+| Secret | Purpose |
+|--------|---------|
+| `JWT_SECRET_KEY` | Signs auth tokens. Set this to a long random string. |
+| `GEMINI_API_KEY` | Powers the default Gemini provider (model: `gemini-2.5-flash`). |
+| `OPENAI_API_KEY` | Optional — only required if you switch to the OpenAI provider. |
+| `VLLM_API_KEY` | Optional — only required if you point the orchestrator/advisors at a Neon vLLM endpoint. |
+
 
-An AI-powered academic guidance system that provides personalized advice through specialized advisor personas. Get diverse perspectives on your PhD journey from multiple AI advisors, each bringing unique expertise in methodology, theory, and practical guidance.
 
 ## Features
 

docker-compose.yml

@@ -1,52 +1,39 @@
+# ---------------------------------------------------------------------------
+# Local-dev wrapper around the single-container HuggingFace Spaces image.
+#
+# This file used to spin up three services (FastAPI backend, CRA dev server,
+# MongoDB). The HF deployment shape (single-container, SQLite on the bucket)
+# is now also the local-dev shape — same image you push to the Space — so
+# this is a one-service compose with a named volume that emulates the HF
+# Storage Bucket mount.
+#
+# Override CYBERPANEL_HOST_PORT via .env (or shell) if 7861 conflicts; the
+# in-container port is fixed at 7860 to mirror HF Spaces.
+# ---------------------------------------------------------------------------
+
 services:
-  backend:
+  app:
     build:
       context: .
       dockerfile: Dockerfile
-      target: backend
+    image: cybersecurity-panel:dev
     ports:
-      - "8000:8000"
-    networks:
-      - application
-    depends_on:
-      - database
+      - "${CYBERPANEL_HOST_PORT:-7861}:7860"
     environment:
-      MONGODB_CONNECTION_STRING: "mongodb://database:27017"
-      MONGODB_DATABASE: cybersecurity_advisor
       JWT_SECRET_KEY: ${JWT_SECRET_KEY:-CHANGEME-by-overriding-in-dot-env-file}
-      GEMINI_API_KEY: ${GEMINI_API_KEY:-?}
-      VLLM_API_KEY: ${VLLM_API_KEY:-}
-      CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3010,http://localhost:3000}
-      GEMINI_MODEL: gemini-2.5-flash
-      CONFIG_PATH: ${CONFIG_PATH:-/ccai/cybersecurity_config.yaml}
+      GEMINI_API_KEY: ${GEMINI_API_KEY:-}
       OPENAI_API_KEY: ${OPENAI_API_KEY:-}
-  frontend:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      target: frontend
-    ports:
-      - "3010:3010"
-    networks:
-      - application
-    depends_on:
-      - backend
-    environment:
-      REACT_APP_API_URL: ${REACT_APP_API_URL:-http://localhost:8000}
-      PORT: "3010"
-      HOST: "0.0.0.0"
-      WDS_SOCKET_PORT: "3010"
-      BROWSER: "none"
-  database:
-    image: mongo:8.0
+      VLLM_API_KEY: ${VLLM_API_KEY:-}
+      VLLM_API_USERNAME: ${VLLM_API_USERNAME:-}
+      GEMINI_MODEL: ${GEMINI_MODEL:-gemini-2.5-flash}
+      CONFIG_PATH: ${CONFIG_PATH:-/home/user/app/cybersecurity_config.yaml}
+      # Same-origin in single-container; only relevant for cross-origin dev.
+      CORS_ORIGINS: ${CORS_ORIGINS:-*}
+      # SQLite + ChromaDB persistence both land here. The named volume below
+      # mirrors the HF Storage Bucket mount so user data survives rebuilds.
+      DATA_DIR: /data
     volumes:
-      - mongo_data:/data/db
-    networks:
-      - application
+      - cybersecurity_data:/data
+
 volumes:
-  mongo_data:
-networks:
-  application:
-    driver: bridge
-    driver_opts:
-      com.docker.network.bridge.host_binding_ipv4: "0.0.0.0"
+  cybersecurity_data:

multi_llm_chatbot_backend/app/api/routes/root.py

@@ -7,8 +7,11 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
-@router.get("/")
-def root():
+@router.get("/api/info")
+def info():
+    # Moved from "/" so the React SPA can own the root path when the bundle
+    # is mounted in single-container (HF Spaces) deployments. The banner is
+    # still useful as a quick liveness check for ops.
     title = get_settings().app.title
     return {
         "message": f"{title} Backend is up and running",

multi_llm_chatbot_backend/app/config.py

@@ -157,7 +157,11 @@ class PersonaItemConfig(_IconValidatorMixin):
                 self.avatar, self.id,
             )
             return f"icon://{self.icon}"
-        base = os.getenv("REACT_APP_API_URL", "http://localhost:8000").rstrip("/")
+        # Default to empty string (→ relative URL) so single-origin Spaces
+        # deployments serve avatars off the same host as the SPA. Local
+        # ``npm start`` development setups can still set REACT_APP_API_URL
+        # explicitly to point at the backend on a different port.
+        base = os.getenv("REACT_APP_API_URL", "").rstrip("/")
         return f"{base}/api/avatars/bundled/{self.avatar}"
 
     def to_frontend_config(self) -> dict:

multi_llm_chatbot_backend/app/core/canvas_database.py

@@ -1,68 +1,35 @@
+"""PhD Canvas database setup — SQLite-shim aware.
+
+The original implementation was a Mongo-only module that created compound
+indexes and a TTL index on the ``phd_canvases`` collection at startup. With
+the SQLite-on-HF-bucket persistence shim, the schema (including the
+``user_id`` index) is declared once at connection time inside
+``app.core.db``, so this module becomes a compatibility no-op.
+
+We keep the function signatures so any caller that still imports
+``setup_canvas_collections`` or ``cleanup_old_canvas_data`` keeps working.
+"""
+
 import logging
-from motor.motor_asyncio import AsyncIOMotorDatabase
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
-async def setup_canvas_collections(db: AsyncIOMotorDatabase):
-    """Setup MongoDB collections and indexes for PhD Canvas"""
-    try:
-        collection = db.phd_canvases
-        
-        # Create simple indexes
-        await collection.create_index("user_id")
-        logger.info("Created index on user_id")
-        
-        await collection.create_index("last_updated", background=True)
-        logger.info("Created index on last_updated")
-        
-        # Create compound indexes
-        await collection.create_index([("user_id", 1), ("last_updated", -1)])
-        logger.info("Created compound index on user_id and last_updated")
-        
-        await collection.create_index([("user_id", 1), ("created_at", -1)])
-        logger.info("Created compound index on user_id and created_at")
-        
-        # Ensure TTL index for old canvases (optional cleanup after 2 years)
-        await collection.create_index(
-            "created_at", 
-            expireAfterSeconds=63072000  # 2 years in seconds
-        )
-        logger.info("Created TTL index for canvas cleanup")
-        
-        logger.info("PhD Canvas database setup completed successfully")
-        
-    except Exception as e:
-        logger.error("Error setting up canvas collections: %s", str(e))
-        raise
 
-async def cleanup_old_canvas_data(db: AsyncIOMotorDatabase):
-    """Cleanup old or orphaned canvas data (maintenance function)"""
-    try:
-        # Find canvases with no corresponding users (orphaned data)
-        pipeline = [
-            {
-                "$lookup": {
-                    "from": "users",
-                    "localField": "user_id", 
-                    "foreignField": "_id",
-                    "as": "user_data"
-                }
-            },
-            {
-                "$match": {
-                    "user_data": {"$size": 0}  # No matching user found
-                }
-            }
-        ]
-        
-        orphaned_canvases = await db.phd_canvases.aggregate(pipeline).to_list(length=100)
-        
-        if orphaned_canvases:
-            orphaned_ids = [canvas["_id"] for canvas in orphaned_canvases]
-            result = await db.phd_canvases.delete_many({"_id": {"$in": orphaned_ids}})
-            logger.info("Cleaned up %d orphaned canvas records", result.deleted_count)
-        else:
-            logger.info("No orphaned canvas records found")
-            
-    except Exception as e:
-        logger.error("Error during canvas cleanup: %s", str(e))
+async def setup_canvas_collections(db: Any) -> None:
+    """No-op on the SQLite shim — indexes are created by ``app.core.db``."""
+    logger.info(
+        "PhD Canvas setup: schema and indexes are managed by the SQLite shim; "
+        "skipping legacy Mongo index creation."
+    )
+
+
+async def cleanup_old_canvas_data(db: Any) -> None:
+    """Maintenance helper — disabled on the SQLite shim.
+
+    The original used a Mongo ``$lookup`` aggregation against the ``users``
+    collection, which the in-process aggregation runner doesn't support. If
+    you need the orphan cleanup, run it via a separate script that does two
+    passes (``users``, then ``phd_canvases``) and calls ``delete_many``.
+    """
+    logger.info("cleanup_old_canvas_data is a no-op on the SQLite shim.")

multi_llm_chatbot_backend/app/core/database.py

@@ -1,86 +1,50 @@
-import os
-from motor.motor_asyncio import AsyncIOMotorClient
-from pymongo.errors import ConnectionFailure
+"""Database connection facade.
+
+Used to wrap pymongo / motor against a real MongoDB instance. For Hugging
+Face Spaces deployment we now back the same public API with SQLite on a HF
+Storage Bucket mount (see ``app.core.db``). The shim emulates the Mongo
+idioms the routers and services use, so this module simply forwards to it
+and keeps the legacy ``connect_to_mongo`` / ``close_mongo_connection`` /
+``get_database`` API intact for ``main.py`` and the route files.
+"""
+
 import logging
 
-from app.config import get_settings
+from app.core.db import _close, _open, get_database as _get_database
 
 logger = logging.getLogger(__name__)
 
-class Database:
-    client: AsyncIOMotorClient = None
-    database = None
 
-db = Database()
-
-async def connect_to_mongo():
-    """Create database connection"""
+async def connect_to_mongo() -> None:
+    """Open the SQLite-backed database and run schema bootstrap."""
+    await _open()
+    logger.info("SQLite-backed database ready (Mongo API shim active).")
+    # Legacy hook: previously called ``setup_canvas_collections`` here.
+    # The phd_canvases table is already declared in the shim's schema, so
+    # the call below is a no-op but kept for symmetry with the original
+    # startup path.
     try:
-        settings = get_settings()
+        from app.core.canvas_database import setup_canvas_collections
 
-        # Connection string: config.yaml → env var fallback (handled by Pydantic validator)
-        mongo_url = settings.mongodb.connection_string
-        if not mongo_url:
-            # Last-resort fallback to raw env var (backwards compat)
-            mongo_url = os.getenv("MONGODB_CONNECTION_STRING", "")
-        if not mongo_url:
-            raise ValueError(
-                "MongoDB connection string not set. "
-                "Provide it in config.yaml (mongodb.connection_string) "
-                "or as the MONGODB_CONNECTION_STRING environment variable."
-            )
+        await setup_canvas_collections(_get_database())
+        logger.info("Canvas database initialization completed (no-op on SQLite shim).")
+    except Exception as canvas_error:  # pragma: no cover
+        logger.error(f"Canvas database initialization failed: {canvas_error}")
 
-        db_name = settings.mongodb.database_name
-        
-        db.client = AsyncIOMotorClient(mongo_url)
-        db.database = db.client[db_name]
-        
-        # Test connection
-        await db.client.admin.command('ping')
 
-        logger.info(f"Successfully connected to MongoDB database: {db_name}")
-        
-        # Create indexes for better performance
-        await create_indexes()
-        try:
-            from app.core.canvas_database import setup_canvas_collections
-            await setup_canvas_collections(db.database)  # Pass db directly
-            logger.info("Canvas database initialization completed")
-        except Exception as canvas_error:
-            logger.error(f"Canvas database initialization failed: {canvas_error}")
-        
-    except ConnectionFailure as e:
-        logger.error(f"Failed to connect to MongoDB: {e}")
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected error connecting to MongoDB: {e}")
-        raise
+async def close_mongo_connection() -> None:
+    """Best-effort connection close on FastAPI shutdown."""
+    await _close()
+    logger.info("Disconnected from SQLite-backed database.")
 
-async def close_mongo_connection():
-    """Close database connection"""
-    if db.client:
-        db.client.close()
-        logger.info("Disconnected from MongoDB")
 
-async def create_indexes():
-    """Create database indexes for performance"""
-    try:
-        # Index for users collection
-        await db.database.users.create_index("email", unique=True)
-        await db.database.users.create_index("created_at")
-        
-        # Indexes for chat_sessions collection
-        await db.database.chat_sessions.create_index("user_id")
-        await db.database.chat_sessions.create_index("created_at")
-        await db.database.chat_sessions.create_index([("user_id", 1), ("created_at", -1)])
+async def create_indexes() -> None:
+    """Index creation is handled by the shim's schema bootstrap; kept for
+    backwards compatibility so any out-of-process maintenance script that
+    imports this name keeps working."""
+    return None
 
-        await db.database.user_profiles.create_index("user_id", unique=True)
-        await db.database.onboarding_conversations.create_index("user_id", unique=True)
-        
-        logger.info("Database indexes created successfully")
-    except Exception as e:
-        logger.warning(f"Error creating indexes: {e}")
 
 def get_database():
-    """Get database instance"""
-    return db.database
+    """Return the SQLite-backed Mongo-API-compatible Database object."""
+    return _get_database()

multi_llm_chatbot_backend/app/core/db.py

@@ -0,0 +1,688 @@
+"""Persistent storage facade backed by SQLite + filesystem on a Hugging Face
+Storage Bucket mount.
+
+Background
+----------
+This Space used to require MongoDB (via Motor / GridFS). On Hugging Face
+Spaces the container has no Mongo, the legacy ``/data`` Persistent Storage
+was retired, and the user does not want to use Atlas (or any paid third
+party). The replacement is a single Hugging Face Storage Bucket mounted into
+the Space at ``$DATA_DIR`` (default ``/data``). Everything durable lives
+there:
+
+  ${DATA_DIR}/cybersecurity_panel.db   — SQLite database (users, chat
+                                          sessions, profiles, onboarding,
+                                          PhD canvases)
+
+A single ``hf buckets sync hf://buckets/<org>/<bucket> ./backup`` therefore
+captures the full state and can be restored before the next redeploy.
+
+Design
+------
+This module exposes the **subset** of the Motor / pymongo API that the
+existing routers and services already call (``find_one``, ``find``,
+``insert_one``, ``update_one``, ``update_many``, ``delete_one``,
+``delete_many``, ``replace_one``, ``count_documents``,
+``find_one_and_delete``, ``aggregate`` with ``$match``/``$group``/``$in``).
+The on-disk format is plain JSON-encoded documents in SQLite tables (one row
+per document, with an indexed ``_id`` primary key, optional ``email`` UNIQUE
+column on ``users``, and an indexed/UNIQUE ``user_id`` column on the user
+scoped collections).
+
+Why not full SQL? The router code uses Mongo idioms (``$in``, ``$set``,
+``find_one_and_delete``, an aggregation pipeline) and ``bson.ObjectId`` IDs.
+A small in-process query engine over JSON dicts keeps the routers untouched
+while still benefiting from SQLite's durability and crash safety on the
+bucket mount.
+
+Why SQLite and not pure JSON files? Atomic commit, crash-consistent writes,
+unique constraints (email, user-scoped profile/onboarding), and one
+mongodump-style salvage file. WAL mode is *attempted* but if the bucket
+FUSE doesn't support the required fcntl/mmap semantics SQLite falls back to
+the default rollback journal automatically and this module logs a warning.
+
+Errors from the underlying storage are re-raised as
+``pymongo.errors.PyMongoError`` (or ``DuplicateKeyError`` for unique-index
+violations) so the existing 5xx / DuplicateKey handlers keep working
+unchanged.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, AsyncIterator, Mapping, Sequence
+
+import aiosqlite
+from bson import ObjectId
+from pymongo.errors import DuplicateKeyError, PyMongoError
+
+LOG = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Schema
+# ---------------------------------------------------------------------------
+
+# Each entry: (table name, has_unique_email_column, user_id_unique).
+# users have a UNIQUE email column. user_profiles and onboarding_conversations
+# have a UNIQUE user_id column (one record per user). chat_sessions and
+# phd_canvases keep user_id only as an index (many records per user).
+_TABLES: tuple[tuple[str, bool, bool], ...] = (
+    ("users",                       True,  False),
+    ("chat_sessions",               False, False),
+    ("user_profiles",               False, True),
+    ("onboarding_conversations",    False, True),
+    ("phd_canvases",                False, False),
+)
+
+_TABLE_NAMES = {t[0] for t in _TABLES}
+
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+def _data_dir() -> Path:
+    raw = os.environ.get("DATA_DIR") or "/data"
+    p = Path(raw).expanduser()
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _db_path() -> Path:
+    return _data_dir() / "cybersecurity_panel.db"
+
+
+# ---------------------------------------------------------------------------
+# JSON (de)serialization that round-trips ObjectId / datetime
+# ---------------------------------------------------------------------------
+
+def _enc(o: Any) -> Any:
+    if isinstance(o, ObjectId):
+        return {"$oid": str(o)}
+    if isinstance(o, datetime):
+        if o.tzinfo is None:
+            o = o.replace(tzinfo=timezone.utc)
+        return {"$date": o.isoformat()}
+    raise TypeError(f"Type {type(o)!r} is not JSON serialisable")
+
+
+def _hook(d: dict) -> Any:
+    if len(d) == 1:
+        if "$oid" in d:
+            return ObjectId(d["$oid"])
+        if "$date" in d:
+            return datetime.fromisoformat(d["$date"])
+    return d
+
+
+def _dumps(doc: Mapping) -> str:
+    return json.dumps(dict(doc), default=_enc)
+
+
+def _loads(text: str) -> dict:
+    return json.loads(text, object_hook=_hook)
+
+
+def _id_str(v: Any) -> str:
+    if isinstance(v, ObjectId):
+        return str(v)
+    if isinstance(v, str):
+        return v
+    return str(v)
+
+
+# ---------------------------------------------------------------------------
+# Connection management (single shared aiosqlite connection)
+# ---------------------------------------------------------------------------
+
+_conn: aiosqlite.Connection | None = None
+_open_lock = asyncio.Lock()
+
+
+async def _open() -> aiosqlite.Connection:
+    global _conn
+    if _conn is not None:
+        return _conn
+    async with _open_lock:
+        if _conn is not None:
+            return _conn
+        path = _db_path()
+        try:
+            conn = await aiosqlite.connect(str(path))
+        except (aiosqlite.OperationalError, OSError) as exc:
+            raise PyMongoError(f"Cannot open database at {path}: {exc}") from exc
+
+        # WAL gives concurrent readers; if the bucket FUSE doesn't support the
+        # mmap/lock semantics WAL needs, SQLite stays in the default rollback
+        # journal which still works on every filesystem we care about.
+        try:
+            cur = await conn.execute("PRAGMA journal_mode=WAL")
+            row = await cur.fetchone()
+            mode = (row[0] if row else "?")
+            if str(mode).lower() != "wal":
+                LOG.warning(
+                    "Could not enable WAL mode on %s (got %r); using rollback journal",
+                    path, mode,
+                )
+        except aiosqlite.OperationalError as exc:
+            LOG.warning("PRAGMA journal_mode=WAL failed (%s); using rollback journal", exc)
+
+        try:
+            await conn.execute("PRAGMA synchronous=NORMAL")
+            await conn.execute("PRAGMA foreign_keys=ON")
+        except aiosqlite.OperationalError:
+            pass
+
+        await _init_schema(conn)
+        await conn.commit()
+        LOG.info("SQLite ready at %s", path)
+        _conn = conn
+        return _conn
+
+
+async def _init_schema(conn: aiosqlite.Connection) -> None:
+    parts: list[str] = []
+    for name, has_email, user_id_unique in _TABLES:
+        if has_email:
+            parts.append(
+                f"""
+                CREATE TABLE IF NOT EXISTS {name} (
+                    _id TEXT PRIMARY KEY,
+                    email TEXT UNIQUE,
+                    doc TEXT NOT NULL
+                );
+                """
+            )
+        else:
+            uniq = "UNIQUE" if user_id_unique else ""
+            parts.append(
+                f"""
+                CREATE TABLE IF NOT EXISTS {name} (
+                    _id TEXT PRIMARY KEY,
+                    user_id TEXT {uniq},
+                    doc TEXT NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_{name}_user_id ON {name}(user_id);
+                """
+            )
+    await conn.executescript("\n".join(parts))
+
+
+async def _close() -> None:
+    """Best-effort connection close (called from FastAPI lifespan teardown)."""
+    global _conn
+    if _conn is not None:
+        try:
+            await _conn.close()
+        except Exception:  # pragma: no cover - shutdown path
+            pass
+        _conn = None
+
+
+# ---------------------------------------------------------------------------
+# Filter matching (only the Mongo operators the routers actually use)
+# ---------------------------------------------------------------------------
+
+def _match_value(actual: Any, want: Any) -> bool:
+    if isinstance(want, dict) and len(want) == 1:
+        op, arg = next(iter(want.items()))
+        if op == "$in":
+            return actual in arg
+    return actual == want
+
+
+def _matches(doc: Mapping, query: Mapping) -> bool:
+    for k, v in query.items():
+        if not _match_value(doc.get(k), v):
+            return False
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Result types (shaped like pymongo's so existing ``res.inserted_id`` etc. works)
+# ---------------------------------------------------------------------------
+
+class _InsertOneResult:
+    def __init__(self, inserted_id: ObjectId) -> None:
+        self.inserted_id = inserted_id
+
+
+class _UpdateResult:
+    def __init__(self, matched: int, modified: int, upserted_id: ObjectId | None = None) -> None:
+        self.matched_count = matched
+        self.modified_count = modified
+        self.upserted_id = upserted_id
+
+
+class _DeleteResult:
+    def __init__(self, deleted: int) -> None:
+        self.deleted_count = deleted
+
+
+# ---------------------------------------------------------------------------
+# Cursor / aggregation
+# ---------------------------------------------------------------------------
+
+def _sort_key_factory(field: str):
+    def keyfn(d: Mapping):
+        v = d.get(field)
+        return (v is None, v)
+    return keyfn
+
+
+class _Cursor:
+    """Lazy cursor: docs are fetched the first time you await iteration / to_list."""
+
+    def __init__(self, fetch):
+        self._fetch = fetch
+        self._sort_field: str | None = None
+        self._sort_dir: int = 1
+        self._limit: int | None = None
+        self._skip: int = 0
+
+    def sort(self, field: str | list[tuple[str, int]], direction: int = 1) -> "_Cursor":
+        # Routers also call .sort([("created_at", -1)]) — accept that form too,
+        # honoring only the first key (Mongo allows compound sort; for the
+        # routers we have, single-key sort is sufficient).
+        if isinstance(field, list) and field:
+            f, d = field[0]
+            self._sort_field = f
+            self._sort_dir = d
+        else:
+            self._sort_field = field  # type: ignore[assignment]
+            self._sort_dir = direction
+        return self
+
+    def limit(self, n: int) -> "_Cursor":
+        self._limit = int(n)
+        return self
+
+    def skip(self, n: int) -> "_Cursor":
+        self._skip = int(n)
+        return self
+
+    async def _materialize(self) -> list[dict]:
+        items = await self._fetch()
+        if self._sort_field is not None:
+            items.sort(key=_sort_key_factory(self._sort_field), reverse=self._sort_dir < 0)
+        if self._skip:
+            items = items[self._skip:]
+        if self._limit is not None:
+            items = items[: self._limit]
+        return items
+
+    async def to_list(self, length: int | None = None) -> list[dict]:
+        items = await self._materialize()
+        return items if length is None else items[:length]
+
+    def __aiter__(self) -> AsyncIterator[dict]:
+        async def _gen():
+            for d in await self._materialize():
+                yield d
+        return _gen()
+
+
+class _Aggregate:
+    """Tiny aggregation runner — supports the pipeline shapes the routers use:
+    ``$match`` and ``$group`` with ``_id: None`` plus ``$sum``.
+
+    More exotic shapes (``$lookup``) raise NotImplementedError; the only
+    caller is a maintenance ``cleanup_old_canvas_data`` function that isn't
+    on the request path, so this is safe.
+    """
+
+    def __init__(self, fetch, pipeline: Sequence[Mapping]):
+        self._fetch = fetch
+        self._pipeline = list(pipeline)
+
+    async def to_list(self, length: int | None = None) -> list[dict]:
+        items = await self._fetch()
+        for stage in self._pipeline:
+            if "$match" in stage:
+                items = [d for d in items if _matches(d, stage["$match"])]
+            elif "$group" in stage:
+                spec = stage["$group"]
+                gid = spec.get("_id")
+                if gid is not None:
+                    raise NotImplementedError("Only $group with _id: None is supported")
+                bucket: dict[str, Any] = {"_id": None}
+                for k, v in spec.items():
+                    if k == "_id":
+                        continue
+                    if not (isinstance(v, dict) and len(v) == 1):
+                        raise NotImplementedError(f"Unsupported $group field: {k}={v!r}")
+                    op, arg = next(iter(v.items()))
+                    if op == "$sum" and isinstance(arg, str) and arg.startswith("$"):
+                        field = arg[1:]
+                        bucket[k] = sum(int(d.get(field) or 0) for d in items)
+                    else:
+                        raise NotImplementedError(f"Unsupported $group op: {op}")
+                items = [bucket]
+            else:
+                raise NotImplementedError(f"Unsupported aggregation stage: {stage}")
+        return items if length is None else items[:length]
+
+
+# ---------------------------------------------------------------------------
+# Collection
+# ---------------------------------------------------------------------------
+
+class Collection:
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._has_email = name == "users"
+
+    # ----- low-level helpers ------------------------------------------------
+
+    async def _all(self, conn: aiosqlite.Connection) -> list[dict]:
+        cur = await conn.execute(f"SELECT doc FROM {self._name}")
+        rows = await cur.fetchall()
+        return [_loads(r[0]) for r in rows]
+
+    def _insert_params(self, _id: str, email: str | None, user_id: str | None, doc_json: str):
+        if self._has_email:
+            return (
+                "INSERT INTO users (_id, email, doc) VALUES (?, ?, ?)",
+                (_id, email, doc_json),
+            )
+        return (
+            f"INSERT INTO {self._name} (_id, user_id, doc) VALUES (?, ?, ?)",
+            (_id, user_id, doc_json),
+        )
+
+    async def _update_row(
+        self,
+        conn: aiosqlite.Connection,
+        _id: str,
+        email: str | None,
+        user_id: str | None,
+        doc_json: str,
+    ) -> None:
+        if self._has_email:
+            await conn.execute(
+                "UPDATE users SET email=?, doc=? WHERE _id=?",
+                (email, doc_json, _id),
+            )
+        else:
+            await conn.execute(
+                f"UPDATE {self._name} SET user_id=?, doc=? WHERE _id=?",
+                (user_id, doc_json, _id),
+            )
+
+    def _apply_update(self, doc: dict, update: Mapping) -> None:
+        for op, fields in update.items():
+            if op == "$set":
+                for k, v in fields.items():
+                    doc[k] = v
+            elif op == "$unset":
+                for k in fields:
+                    doc.pop(k, None)
+            elif op == "$inc":
+                for k, v in fields.items():
+                    doc[k] = (doc.get(k) or 0) + v
+            else:
+                raise NotImplementedError(f"Unsupported update operator: {op}")
+
+    # ----- public API -------------------------------------------------------
+
+    async def find_one(self, query: Mapping | None = None, projection: Mapping | None = None) -> dict | None:
+        query = dict(query or {})
+        try:
+            conn = await _open()
+            # Fast paths for primary-key / unique-index lookups.
+            if list(query.keys()) == ["_id"] and isinstance(query["_id"], (ObjectId, str)):
+                cur = await conn.execute(
+                    f"SELECT doc FROM {self._name} WHERE _id = ?",
+                    (_id_str(query["_id"]),),
+                )
+                row = await cur.fetchone()
+                return _loads(row[0]) if row else None
+            if self._has_email and list(query.keys()) == ["email"]:
+                cur = await conn.execute(
+                    "SELECT doc FROM users WHERE email = ?",
+                    (query["email"],),
+                )
+                row = await cur.fetchone()
+                return _loads(row[0]) if row else None
+            for d in await self._all(conn):
+                if _matches(d, query):
+                    return d
+            return None
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"find_one({self._name}) failed: {exc}") from exc
+
+    def find(self, query: Mapping | None = None, projection: Mapping | None = None) -> _Cursor:
+        q = dict(query or {})
+
+        async def _go() -> list[dict]:
+            try:
+                conn = await _open()
+                docs = await self._all(conn)
+                return [d for d in docs if _matches(d, q)]
+            except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+                raise PyMongoError(f"find({self._name}) failed: {exc}") from exc
+
+        return _Cursor(_go)
+
+    def aggregate(self, pipeline: Sequence[Mapping]) -> _Aggregate:
+        async def _go() -> list[dict]:
+            try:
+                conn = await _open()
+                return await self._all(conn)
+            except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+                raise PyMongoError(f"aggregate({self._name}) failed: {exc}") from exc
+
+        return _Aggregate(_go, pipeline)
+
+    async def count_documents(self, filter: Mapping | None = None) -> int:
+        f = dict(filter or {})
+        try:
+            conn = await _open()
+            if not f:
+                cur = await conn.execute(f"SELECT COUNT(*) FROM {self._name}")
+                row = await cur.fetchone()
+                return int(row[0]) if row else 0
+            return sum(1 for d in await self._all(conn) if _matches(d, f))
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"count_documents({self._name}) failed: {exc}") from exc
+
+    async def insert_one(self, doc: Mapping) -> _InsertOneResult:
+        d = dict(doc)
+        if "_id" not in d or d["_id"] is None:
+            d["_id"] = ObjectId()
+        oid = d["_id"]
+        try:
+            conn = await _open()
+            email = d.get("email") if self._has_email else None
+            user_id = _id_str(d["user_id"]) if "user_id" in d else None
+            sql, params = self._insert_params(_id_str(oid), email, user_id, _dumps(d))
+            await conn.execute(sql, params)
+            await conn.commit()
+            return _InsertOneResult(oid)
+        except aiosqlite.IntegrityError as exc:
+            raise DuplicateKeyError(str(exc)) from exc
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"insert_one({self._name}) failed: {exc}") from exc
+
+    async def update_one(
+        self,
+        filter: Mapping,
+        update: Mapping,
+        upsert: bool = False,
+    ) -> _UpdateResult:
+        try:
+            conn = await _open()
+            doc = await self.find_one(filter)
+            if doc is None and not upsert:
+                return _UpdateResult(0, 0)
+            if doc is None and upsert:
+                base: dict[str, Any] = {}
+                for k, v in filter.items():
+                    if not (isinstance(v, dict) and any(str(kk).startswith("$") for kk in v)):
+                        base[k] = v
+                if "_id" not in base:
+                    base["_id"] = ObjectId()
+                self._apply_update(base, update)
+                res = await self.insert_one(base)
+                return _UpdateResult(0, 0, upserted_id=res.inserted_id)
+            self._apply_update(doc, update)
+            email = doc.get("email") if self._has_email else None
+            user_id = _id_str(doc["user_id"]) if "user_id" in doc else None
+            await self._update_row(conn, _id_str(doc["_id"]), email, user_id, _dumps(doc))
+            await conn.commit()
+            return _UpdateResult(1, 1)
+        except aiosqlite.IntegrityError as exc:
+            raise DuplicateKeyError(str(exc)) from exc
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"update_one({self._name}) failed: {exc}") from exc
+
+    async def update_many(
+        self,
+        filter: Mapping,
+        update: Mapping,
+    ) -> _UpdateResult:
+        try:
+            conn = await _open()
+            docs = [d for d in await self._all(conn) if _matches(d, filter)]
+            if not docs:
+                return _UpdateResult(0, 0)
+            for doc in docs:
+                self._apply_update(doc, update)
+                email = doc.get("email") if self._has_email else None
+                user_id = _id_str(doc["user_id"]) if "user_id" in doc else None
+                await self._update_row(conn, _id_str(doc["_id"]), email, user_id, _dumps(doc))
+            await conn.commit()
+            return _UpdateResult(len(docs), len(docs))
+        except aiosqlite.IntegrityError as exc:
+            raise DuplicateKeyError(str(exc)) from exc
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"update_many({self._name}) failed: {exc}") from exc
+
+    async def replace_one(
+        self,
+        filter: Mapping,
+        replacement: Mapping,
+        upsert: bool = False,
+    ) -> _UpdateResult:
+        try:
+            conn = await _open()
+            existing = await self.find_one(filter)
+            new_doc = dict(replacement)
+            if existing is None and not upsert:
+                return _UpdateResult(0, 0)
+            if existing is None and upsert:
+                if "_id" not in new_doc or new_doc["_id"] is None:
+                    new_doc["_id"] = ObjectId()
+                res = await self.insert_one(new_doc)
+                return _UpdateResult(0, 0, upserted_id=res.inserted_id)
+            # Preserve the existing _id so the replacement updates the same row.
+            new_doc["_id"] = existing["_id"]
+            email = new_doc.get("email") if self._has_email else None
+            user_id = _id_str(new_doc["user_id"]) if "user_id" in new_doc else None
+            await self._update_row(conn, _id_str(existing["_id"]), email, user_id, _dumps(new_doc))
+            await conn.commit()
+            return _UpdateResult(1, 1)
+        except aiosqlite.IntegrityError as exc:
+            raise DuplicateKeyError(str(exc)) from exc
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"replace_one({self._name}) failed: {exc}") from exc
+
+    async def delete_one(self, filter: Mapping) -> _DeleteResult:
+        try:
+            conn = await _open()
+            doc = await self.find_one(filter)
+            if doc is None:
+                return _DeleteResult(0)
+            await conn.execute(
+                f"DELETE FROM {self._name} WHERE _id=?",
+                (_id_str(doc["_id"]),),
+            )
+            await conn.commit()
+            return _DeleteResult(1)
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"delete_one({self._name}) failed: {exc}") from exc
+
+    async def delete_many(self, filter: Mapping) -> _DeleteResult:
+        try:
+            conn = await _open()
+            docs = [d for d in await self._all(conn) if _matches(d, filter)]
+            for d in docs:
+                await conn.execute(
+                    f"DELETE FROM {self._name} WHERE _id=?",
+                    (_id_str(d["_id"]),),
+                )
+            if docs:
+                await conn.commit()
+            return _DeleteResult(len(docs))
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"delete_many({self._name}) failed: {exc}") from exc
+
+    async def find_one_and_delete(self, filter: Mapping) -> dict | None:
+        try:
+            conn = await _open()
+            doc = await self.find_one(filter)
+            if doc is None:
+                return None
+            await conn.execute(
+                f"DELETE FROM {self._name} WHERE _id=?",
+                (_id_str(doc["_id"]),),
+            )
+            await conn.commit()
+            return doc
+        except (aiosqlite.OperationalError, aiosqlite.DatabaseError, OSError) as exc:
+            raise PyMongoError(f"find_one_and_delete({self._name}) failed: {exc}") from exc
+
+    async def create_index(self, keys: Any, unique: bool = False, **_: Any) -> str:
+        # The schema already declares the indexes the routers rely on
+        # (PK on _id, UNIQUE on users.email and on user_profiles.user_id /
+        # onboarding_conversations.user_id, plain index on user_id elsewhere).
+        # Stays a no-op so legacy main.py / canvas_database.py calls keep
+        # working without changes.
+        return "ok"
+
+
+# ---------------------------------------------------------------------------
+# Database
+# ---------------------------------------------------------------------------
+
+class Database:
+    def __init__(self) -> None:
+        self._collections: dict[str, Collection] = {}
+
+    def _coll(self, name: str) -> Collection:
+        c = self._collections.get(name)
+        if c is None:
+            c = Collection(name)
+            self._collections[name] = c
+        return c
+
+    def __getattr__(self, name: str) -> Collection:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return self._coll(name)
+
+    def __getitem__(self, name: str) -> Collection:
+        return self._coll(name)
+
+
+_database: Database | None = None
+
+
+def get_database() -> Database:
+    global _database
+    if _database is None:
+        _database = Database()
+    return _database
+
+
+__all__ = [
+    "Collection",
+    "Database",
+    "get_database",
+]

multi_llm_chatbot_backend/app/core/rag_manager.py

@@ -12,6 +12,20 @@ from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+
+def _default_chroma_path(subdir: str) -> str:
+    """Resolve the default ChromaDB persistence directory.
+
+    On HF Spaces (and any deployment that sets ``DATA_DIR``) the embeddings
+    must live on the bucket mount so they survive Space rebuilds. In local
+    dev DATA_DIR is unset, so we keep the historical working-directory path
+    so existing local installs and tests don't move their data.
+    """
+    data_dir = os.environ.get("DATA_DIR", "").strip()
+    if data_dir:
+        return str(Path(data_dir) / "chroma" / subdir)
+    return f"./{subdir}"
+
 # Download required NLTK data
 try:
     nltk.data.find('tokenizers/punkt')
@@ -177,14 +191,16 @@ class RAGManager:
     Handles document storage, embedding, and retrieval using ChromaDB
     """
     
-    def __init__(self, embedding_model: str = None, persist_directory: str = "./chroma_db"):
+    def __init__(self, embedding_model: str = None, persist_directory: str = None):
         from app.config import get_settings
         settings = get_settings()
         if embedding_model is None:
             embedding_model = settings.rag.embedding_model
         self.embedding_model_name = embedding_model
+        if persist_directory is None:
+            persist_directory = _default_chroma_path("chroma_db")
         self.persist_directory = Path(persist_directory)
-        self.persist_directory.mkdir(exist_ok=True)
+        self.persist_directory.mkdir(parents=True, exist_ok=True)
         
         # Initialize embedding model
         logger.info(f"Loading embedding model: {embedding_model}")
@@ -459,13 +475,15 @@ class RAGManager:
 
 
 class EnhancedRAGManager:
-    def __init__(self, persist_directory: str = "./chromadb_storage"):
+    def __init__(self, persist_directory: str = None):
         """Initialize enhanced RAG manager with improved document handling"""
         from app.config import get_settings
         settings = get_settings()
 
+        if persist_directory is None:
+            persist_directory = _default_chroma_path("chromadb_storage")
         self.persist_directory = persist_directory
-        Path(persist_directory).mkdir(exist_ok=True)
+        Path(persist_directory).mkdir(parents=True, exist_ok=True)
         
         # Initialize ChromaDB client
         self.client = chromadb.PersistentClient(

multi_llm_chatbot_backend/app/main.py

@@ -83,17 +83,34 @@ def get_public_config():
     """Return the public (non-secret) application configuration."""
     return settings.get_frontend_config()
 
-@app.get("/")
-def root():
-    return {
-        "message": f"{settings.app.title} Backend",
-        "version": "2.0.0",
-        "features": [
-            "User Authentication", 
-            "Persistent Chat Sessions",
-            "MongoDB Integration",
-            "Ollama Support", 
-            "Gemini API Support",
-            "Configurable Personas"
-        ]
-    }
+
+# ---------------------------------------------------------------------------
+# Static SPA mount — Hugging Face Spaces / single-container deployment
+# ---------------------------------------------------------------------------
+# When the Docker build copies the React production bundle into ``./static``
+# (sibling of this app/ directory), expose it at "/" so the API and the
+# SPA share the FastAPI origin. In local development the static dir is
+# absent and a JSON banner is returned at "/" instead.
+_static_dir = Path(__file__).resolve().parent.parent / "static"
+_should_mount_static = _static_dir.is_dir()
+
+if _should_mount_static:
+    app.mount(
+        "/",
+        StaticFiles(directory=str(_static_dir), html=True),
+        name="spa",
+    )
+else:
+    @app.get("/")
+    def root():
+        return {
+            "message": f"{settings.app.title} Backend",
+            "version": "2.0.0",
+            "features": [
+                "User Authentication",
+                "Persistent Chat Sessions (SQLite via aiosqlite)",
+                "Ollama Support",
+                "Gemini API Support",
+                "Configurable Personas",
+            ],
+        }

multi_llm_chatbot_backend/app/utils/chroma_client.py

@@ -1,8 +1,29 @@
+import os
+from pathlib import Path
+
 import chromadb
 from chromadb.config import Settings
+
 from app.llm.embedding_client import get_embedding
 
-client = chromadb.PersistentClient(path="./chroma_storage")
+
+def _persona_knowledge_path() -> str:
+    """Resolve the persona-knowledge ChromaDB path.
+
+    Mirrors ``app.core.rag_manager._default_chroma_path``: when ``DATA_DIR``
+    is set (HF Spaces, any bucket-mounted deployment) the embeddings live
+    under ``${DATA_DIR}/chroma/persona_knowledge`` so they survive Space
+    rebuilds. Local installs keep the historical relative path.
+    """
+    data_dir = os.environ.get("DATA_DIR", "").strip()
+    if data_dir:
+        return str(Path(data_dir) / "chroma" / "persona_knowledge")
+    return "./chroma_storage"
+
+
+_path = _persona_knowledge_path()
+Path(_path).mkdir(parents=True, exist_ok=True)
+client = chromadb.PersistentClient(path=_path)
 
 collection = client.get_or_create_collection("persona_knowledge")
 

multi_llm_chatbot_backend/requirements.txt

@@ -32,9 +32,11 @@ markdown~=3.0
 # PDF generation and export
 reportlab~=4.4
 
-# Database (MongoDB)
+# Persistence: SQLite via aiosqlite on the HF Storage Bucket mount (no MongoDB).
+# pymongo is kept *only* for bson.ObjectId and the DuplicateKeyError /
+# PyMongoError types that the existing routers and the SQLite shim raise.
+aiosqlite~=0.20
 pymongo~=4.16
-motor~=3.7
 
 # Authentication and security
 passlib[bcrypt]~=1.7