Upload 7 files

.dockerignore

@@ -0,0 +1,9 @@
+frontend/node_modules
+frontend/dist
+**/__pycache__
+*.pyc
+.git
+.env
+*.db
+qdrant_data/
+.venv

Dockerfile

@@ -0,0 +1,50 @@
+# ---- Frontend build stage (React -> static files) ----
+FROM node:20-slim AS frontend
+WORKDIR /frontend
+# Copy only manifest first for layer caching
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+# Produces /frontend/dist (Vite) — change to build/ if you use CRA
+RUN npm run build
+
+# ---- Runtime stage (CUDA for imaging models on T4) ----
+FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
+
+# System deps as root BEFORE creating the non-root user
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        python3.11 python3-pip python3.11-venv \
+        build-essential curl git ffmpeg libgl1 libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.11 /usr/bin/python
+
+# Spaces runs your container as UID 1000 — create the matching user
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    # Model/cache dir. Ephemeral on free tier — fine, models re-download on boot.
+    HF_HOME=/home/user/.cache/huggingface \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Python deps (do NOT run any GPU/nvidia-smi command here — no GPU at build time)
+COPY --chown=user requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# App code
+COPY --chown=user backend/ ./backend/
+COPY --chown=user startup.sh ./startup.sh
+
+# Built React static files from stage 1
+COPY --chown=user --from=frontend /frontend/dist ./static
+
+RUN chmod +x ./startup.sh && chown -R user:user /app
+USER user
+
+# Spaces exposes a single public port; must match app_port in README
+EXPOSE 7860
+
+CMD ["./startup.sh"]

README.md

@@ -1,11 +1,41 @@
 ---
-title: MultiagentMedicalAssistant
-emoji: 👀
-colorFrom: indigo
-colorTo: purple
+title: Multi-Agent Medical Assistant
+emoji: 🩺
+colorFrom: blue
+colorTo: indigo
 sdk: docker
-pinned: false
-license: mit
+app_port: 7860
+suggested_hardware: t4-small
+short_description: Multi-agent clinical assistant with RAG and imaging analysis
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Multi-Agent Medical Assistant
+
+Multi-agent clinical assistant: diagnosis, retrieval, reasoning, and imaging
+agents behind a FastAPI backend with a React frontend, deployed as a single
+Docker Space.
+
+## Architecture on Spaces
+
+Everything runs in one container on port 7860:
+
+- **FastAPI** — single entrypoint, serves both the API and the built React app.
+- **React** — built to static files at image-build time, served by FastAPI.
+- **Embedded Qdrant** — local path, no separate server. Rebuilt on each boot.
+- **SQLite** — file-based, no Postgres server.
+- **Imaging models** — loaded lazily on the T4 GPU on first request.
+- **LLM agents** — call a hosted API; keys come from Space secrets.
+
+## Configuration
+
+Set these under **Settings → Variables & secrets**:
+
+- `LLM_API_KEY` — your hosted LLM provider key
+- `ELEVENLABS_API_KEY` — for voice output (optional)
+
+## Notes
+
+- Free tier disk is ephemeral: the vector store is rebuilt from seed docs on
+  every restart. User uploads do not persist across restarts.
+- Requires a paid GPU tier (t4-small) for imaging inference. Pause the Space
+  when not in use to control cost.

backend/ingest.py

@@ -0,0 +1,27 @@
+"""
+Rebuilds the embedded Qdrant vector store on each boot (free tier = no persistence).
+Run as: python -m backend.ingest
+
+Keep this idempotent and fast — it runs on every cold start. Point it at seed
+documents baked into the image (e.g. backend/seed_docs/) rather than user uploads,
+since uploads won't survive a restart anyway.
+"""
+import os
+
+
+def main():
+    qdrant_path = os.environ.get("QDRANT_PATH", "/home/user/qdrant_data")
+
+    # Embedded Qdrant — no server process, just a local path.
+    # from qdrant_client import QdrantClient
+    # client = QdrantClient(path=qdrant_path)
+    #
+    # 1. read seed docs (Docling parse)
+    # 2. chunk + embed (your HF embedding model)
+    # 3. client.recreate_collection(...) then client.upsert(...)
+
+    print(f"[ingest] Would rebuild collection at {qdrant_path}")
+
+
+if __name__ == "__main__":
+    main()

backend/main.py

@@ -0,0 +1,82 @@
+"""
+Single-port entrypoint for the Multi-Agent Medical Assistant on HF Spaces.
+
+Everything is served from one FastAPI app on port 7860:
+  - /api/*        your agent + RAG + imaging routes
+  - /health       liveness probe
+  - /*            the React single-page app (static build)
+
+Design constraints baked in:
+  - Hosted LLM API (keys read from Space Secrets via env vars)
+  - Embedded Qdrant + SQLite (no external DB servers)
+  - Imaging models loaded lazily on first request (no GPU work at import time)
+"""
+import os
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+# ---- Secrets / config (set these in Space Settings -> Variables & secrets) ----
+# e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY, ELEVENLABS_API_KEY
+LLM_API_KEY = os.environ.get("LLM_API_KEY")  # rename to match your provider
+ELEVENLABS_API_KEY = os.environ.get("ELEVENLABS_API_KEY")
+
+STATIC_DIR = Path(__file__).resolve().parent.parent / "static"
+
+app = FastAPI(title="Multi-Agent Medical Assistant")
+
+# Frontend is served from the same origin, so CORS is mostly a no-op here,
+# but keep it permissive if you ever call the API from elsewhere.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+# ---------------------------------------------------------------------------
+# API ROUTES
+# Import your existing routers here. Keep heavy imports (torch, imaging models)
+# INSIDE the route handlers or a lazy loader — never at module top level, so the
+# container starts fast and the build never touches the GPU.
+# ---------------------------------------------------------------------------
+# from backend.agents.router import router as agents_router
+# app.include_router(agents_router, prefix="/api")
+
+
+# ---- Lazy imaging-model loader example (T4 GPU) ----------------------------
+_models = {}
+
+def get_imaging_model(name: str):
+    """Load a model once, on first use, onto the GPU."""
+    if name not in _models:
+        import torch  # imported lazily so build stage never needs CUDA
+        # _models[name] = load_your_model(name).to(
+        #     "cuda" if torch.cuda.is_available() else "cpu"
+        # )
+        raise NotImplementedError("Wire up your imaging model loader here.")
+    return _models[name]
+
+
+# ---------------------------------------------------------------------------
+# STATIC FRONTEND (mounted LAST so it doesn't shadow /api and /health)
+# ---------------------------------------------------------------------------
+if STATIC_DIR.exists():
+    app.mount("/assets", StaticFiles(directory=STATIC_DIR / "assets"), name="assets")
+
+    @app.get("/{full_path:path}")
+    def serve_spa(full_path: str):
+        # Serve real files if they exist, else fall back to index.html (SPA routing)
+        candidate = STATIC_DIR / full_path
+        if full_path and candidate.is_file():
+            return FileResponse(candidate)
+        return FileResponse(STATIC_DIR / "index.html")

requirements.txt

@@ -0,0 +1,25 @@
+# --- Web / serving ---
+fastapi>=0.110
+uvicorn[standard]>=0.29
+python-multipart>=0.0.9
+
+# --- Agents / RAG ---
+langchain>=0.2
+qdrant-client>=1.9          # embedded mode via path=
+docling                     # document parsing
+sentence-transformers       # embeddings (or your HF embedding model)
+
+# --- Imaging (GPU T4) ---
+# Pin torch to a CUDA 12.x wheel compatible with the base image.
+torch>=2.2
+torchvision>=0.17
+opencv-python-headless
+nibabel
+monai
+
+# --- Voice (optional) ---
+# elevenlabs
+
+# --- Hosted LLM client (pick the one you use) ---
+# openai
+# anthropic

startup.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Free tier = ephemeral disk. Everything under these paths is wiped on restart,
+# so we rebuild the vector store on every boot. Keep this idempotent.
+export QDRANT_PATH="${QDRANT_PATH:-/home/user/qdrant_data}"
+export SQLITE_PATH="${SQLITE_PATH:-/home/user/app.db}"
+mkdir -p "$QDRANT_PATH"
+
+echo "[startup] Rebuilding vector store (ephemeral disk, no persistence)..."
+# This should ingest your seed docs into embedded Qdrant. Make it safe to re-run.
+python -m backend.ingest || {
+    echo "[startup] Ingestion failed — starting app anyway (empty index)."
+}
+
+echo "[startup] Launching FastAPI on 0.0.0.0:7860"
+exec uvicorn backend.main:app --host 0.0.0.0 --port 7860 --workers 1