Upload folder using huggingface_hub

.env

@@ -17,3 +17,6 @@ R2_BUCKET_NAME=bioflow-raw-responses
 
 # Demo mode (optional — returns cached results for known sequences)
 DEMO_MODE=false
+
+# Hugging Face CLI (for `hf upload` deploys only, not read by the app)
+HF_TOKEN=

.env.deploy

@@ -17,3 +17,6 @@ R2_BUCKET_NAME=bioflow-raw-responses
 
 # Demo mode (optional — returns cached results for known sequences)
 DEMO_MODE=false
+
+# Sentry (optional — error monitoring)
+SENTRY_DSN=

Dockerfile

@@ -1,7 +1,7 @@
 FROM python:3.11-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential gcc wget ca-certificates && \
+    build-essential gcc wget ca-certificates openbabel && \
     rm -rf /var/lib/apt/lists/*
 
 # Download pre-compiled PhyML binary from bioconda
@@ -12,6 +12,10 @@ RUN wget -qO /tmp/phyml.tar.bz2 \
     chmod +x /usr/local/bin/phyml && \
     rm -rf /tmp/phyml.tar.bz2 /tmp/bin
 
+# Download pre-compiled AutoDock Vina binary from GitHub releases
+RUN wget -q "https://github.com/autodock/autodock-vina/releases/download/v1.2.5/vina_1.2.5_linux_x86_64" -O /usr/local/bin/vina && \
+    chmod +x /usr/local/bin/vina
+
 WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

app/config.py

@@ -24,6 +24,7 @@ class Settings:
     NCBI_EMAIL: str = os.getenv("NCBI_EMAIL", "bioflow@example.com")
     DEMO_MODE: bool = os.getenv("DEMO_MODE", "false").lower() in ("true", "1", "yes")
     CORS_ORIGIN: str = os.getenv("CORS_ORIGIN", "https://bioai-platform.vercel.app")
+    SENTRY_DSN: str = os.getenv("SENTRY_DSN", "")
 
 
 settings = Settings()

app/main.py

@@ -1,4 +1,7 @@
 import logging
+import os
+
+import sentry_sdk
 from dotenv import load_dotenv
 load_dotenv()
 
@@ -9,7 +12,7 @@ from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.util import get_remote_address
 from slowapi.errors import RateLimitExceeded
 from app.config import settings
-from app.routers import pipelines, pipeline_v2, ai, jobs, share, profile, sequences, uniprot, alignment, structures, pathways, domains, interactions, primers, structure_analysis, phylo, export, api_keys
+from app.routers import pipelines, pipeline_v2, ai, jobs, share, profile, sequences, uniprot, alignment, structures, pathways, domains, interactions, primers, structure_analysis, phylo, export, api_keys, cache_stats, docking
 from app.services.cache import init_redis
 
 logger = logging.getLogger(__name__)
@@ -53,6 +56,8 @@ app.include_router(structure_analysis.router)
 app.include_router(phylo.router)
 app.include_router(export.router, prefix="/api/export", tags=["export"])
 app.include_router(api_keys.router, prefix="/api/keys", tags=["api_keys"])
+app.include_router(cache_stats.router)
+app.include_router(docking.router)
 
 TERMINAL_STATUSES = {"complete", "failed"}
 NON_TERMINAL_STATUSES = {
@@ -96,13 +101,20 @@ async def _fail_stuck_jobs():
 
 @app.on_event("startup")
 async def startup():
+    sentry_sdk.init(
+        dsn=settings.SENTRY_DSN,
+        environment=os.getenv("ENVIRONMENT", "development"),
+        traces_sample_rate=0.1,
+    )
     init_redis()
     await _fail_stuck_jobs()
 
 
 @app.get("/health")
 async def health():
-    return {"status": "ok"}
+    from app.services.cache import get_cache_stats
+    stats = get_cache_stats()
+    return {"status": "ok", "cache": stats}
 
 
 @app.exception_handler(Exception)

app/routers/cache_stats.py

@@ -0,0 +1,18 @@
+import logging
+from fastapi import APIRouter, Request
+from app.services.cache import get_cache_stats, reset_cache_stats
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/admin", tags=["admin"])
+
+
+@router.get("/cache-stats")
+async def cache_stats():
+    return get_cache_stats()
+
+
+@router.post("/cache-stats/reset")
+async def reset_stats():
+    reset_cache_stats()
+    return {"status": "ok"}

app/routers/docking.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import logging
+import threading
+import time
+import uuid
+from typing import Optional
+
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/docking", tags=["docking"])
+
+# ─── In-memory store ──────────────────────────────────────────────────────────
+
+_jobs: dict[str, dict] = {}
+_lock = threading.Lock()
+
+
+class DockingRequest(BaseModel):
+    pdb_id: str
+    smiles: str
+
+
+class DockingJob(BaseModel):
+    job_id: str
+    pdb_id: str
+    smiles: str
+    status: str = "queued"
+    result: Optional[dict] = None
+    error: Optional[str] = None
+    created_at: float = 0.0
+    done_at: Optional[float] = None
+
+
+def _init(job_id: str, req: DockingRequest) -> None:
+    with _lock:
+        _jobs[job_id] = {
+            "job_id":    job_id,
+            "pdb_id":    req.pdb_id,
+            "smiles":    req.smiles,
+            "status":    "queued",
+            "result":    None,
+            "error":     None,
+            "created_at": time.time(),
+            "done_at":   None,
+        }
+
+
+def _patch(job_id: str, **kw) -> None:
+    with _lock:
+        if job_id in _jobs:
+            _jobs[job_id].update(kw)
+
+
+def _read(job_id: str) -> dict | None:
+    with _lock:
+        return dict(_jobs[job_id]) if job_id in _jobs else None
+
+
+async def _worker(job_id: str) -> None:
+    job = _read(job_id)
+    if not job:
+        return
+    _patch(job_id, status="preparing")
+
+    from app.tools.docking import DockingTool
+
+    tool = DockingTool()
+    result = await tool.run({
+        "pdb_id": job["pdb_id"],
+        "smiles": job["smiles"],
+    })
+
+    if "error" in result and not result.get("poses"):
+        _patch(job_id, status="failed", error=result["error"], done_at=time.time())
+    else:
+        _patch(job_id, status="complete", result=result, done_at=time.time())
+
+
+@router.post("/run")
+async def run_docking(req: DockingRequest, background_tasks: BackgroundTasks):
+    if not req.pdb_id.strip():
+        raise HTTPException(400, detail="pdb_id is required")
+    if not req.smiles.strip():
+        raise HTTPException(400, detail="smiles is required")
+
+    job_id = str(uuid.uuid4())
+    _init(job_id, req)
+    background_tasks.add_task(_worker, job_id)
+    return {"job_id": job_id, "status": "queued"}
+
+
+@router.get("/status/{job_id}")
+async def get_status(job_id: str):
+    job = _read(job_id)
+    if not job:
+        raise HTTPException(404, detail=f"Job {job_id} not found")
+    return job

app/services/cache.py

@@ -9,6 +9,7 @@ from app.config import settings
 logger = logging.getLogger(__name__)
 
 _redis = None
+_cache_stats = {"hits": 0, "misses": 0}
 
 
 def init_redis():
@@ -29,7 +30,11 @@ def get_redis():
 def cache_get(key: str) -> str | None:
     r = get_redis()
     if r:
-        return r.get(key)
+        val = r.get(key)
+        if val is not None:
+            _cache_stats["hits"] += 1
+            return val
+        _cache_stats["misses"] += 1
     return None
 
 
@@ -39,6 +44,15 @@ def cache_set(key: str, value: str, ttl: int = 86400):
         r.setex(key, ttl, value)
 
 
+def get_cache_stats() -> dict:
+    return {**_cache_stats, "redis_connected": _redis is not None}
+
+
+def reset_cache_stats():
+    _cache_stats["hits"] = 0
+    _cache_stats["misses"] = 0
+
+
 def ttl_cache(ttl: int = 86400, prefix: str = "cache"):
     def decorator(func: Callable) -> Callable:
         @functools.wraps(func)
@@ -50,7 +64,10 @@ def ttl_cache(ttl: int = 86400, prefix: str = "cache"):
             cached = cache_get(cache_key)
             if cached is not None:
                 try:
-                    return json.loads(cached)
+                    result = json.loads(cached)
+                    if isinstance(result, dict):
+                        result["from_cache"] = True
+                    return result
                 except (json.JSONDecodeError, TypeError):
                     pass
 
@@ -59,6 +76,8 @@ def ttl_cache(ttl: int = 86400, prefix: str = "cache"):
                 cache_set(cache_key, json.dumps(result), ttl=ttl)
             except (TypeError, ValueError):
                 pass
+            if isinstance(result, dict):
+                result["from_cache"] = False
             return result
 
         return wrapper

app/services/ncbi_service.py

@@ -77,6 +77,7 @@ class NCBIService:
         except Exception as e:
             return {"error": str(e)}
 
+    @ttl_cache(ttl=86400, prefix="ncbi_search")
     async def search_by_name(self, term: str, db: str = "protein", max_results: int = 10) -> dict:
         try:
             handle = Entrez.esearch(db=db, term=term, retmax=max_results)

app/services/pathway_enrichment.py

@@ -1,12 +1,29 @@
 import httpx
+import json
+import hashlib
 import logging
 
+from app.services.cache import cache_get, cache_set
+
 logger = logging.getLogger(__name__)
 
 ANALYSIS_BASE = "https://reactome.org/AnalysisService"
 
 
 async def run_enrichment(identifiers: list[str]) -> dict | None:
+    raw = json.dumps(sorted(identifiers), sort_keys=True)
+    key_hash = hashlib.sha256(raw.encode()).hexdigest()[:16]
+    cache_key = f"enrichment:{key_hash}"
+
+    cached = cache_get(cache_key)
+    if cached is not None:
+        try:
+            result = json.loads(cached)
+            if isinstance(result, dict):
+                result["from_cache"] = True
+            return result
+        except (json.JSONDecodeError, TypeError):
+            pass
     try:
         body = "\n".join(identifiers)
         async with httpx.AsyncClient(timeout=30) as client:
@@ -48,10 +65,16 @@ async def run_enrichment(identifiers: list[str]) -> dict | None:
 
             pathways.sort(key=lambda p: p["entitiesFDR"])
 
-            return {
+            result = {
                 "token": token,
                 "pathways": pathways,
             }
+            try:
+                cache_set(cache_key, json.dumps(result), ttl=86400)
+            except (TypeError, ValueError):
+                pass
+            result["from_cache"] = False
+            return result
     except Exception as e:
         logger.warning(f"Pathway enrichment failed: {e}")
         return None

app/tools/docking.py

@@ -0,0 +1,237 @@
+import asyncio
+import logging
+import os
+import re
+import shutil
+import tempfile
+import time
+from typing import Any
+
+import httpx
+
+from app.tools.base import BaseTool
+
+logger = logging.getLogger(__name__)
+
+PDB_DOWNLOAD = "https://files.rcsb.org/download/{pdb_id}.pdb"
+VINA_CMD = shutil.which("vina") or "/usr/local/bin/vina"
+
+
+def _find_ligand_center(pdb_content: str) -> tuple[float, float, float] | None:
+    """Find the geometric center of the largest HETATM ligand (non-water)."""
+    het_atoms: list[list[tuple[float, float, float]]] = []
+    current_het: list[tuple[float, float, float]] = []
+    current_resname = ""
+    for line in pdb_content.splitlines():
+        if line.startswith("HETATM"):
+            resname = line[17:20].strip()
+            if resname == "HOH":
+                continue
+            try:
+                x = float(line[30:38].strip())
+                y = float(line[38:46].strip())
+                z = float(line[46:54].strip())
+            except ValueError:
+                continue
+            if resname != current_resname:
+                if current_het:
+                    het_atoms.append(current_het)
+                current_het = [(x, y, z)]
+                current_resname = resname
+            else:
+                current_het.append((x, y, z))
+        elif line.startswith("ATOM") or line.startswith("TER"):
+            if current_het:
+                het_atoms.append(current_het)
+                current_het = []
+                current_resname = ""
+    if current_het:
+        het_atoms.append(current_het)
+
+    if not het_atoms:
+        return None
+
+    largest = max(het_atoms, key=len)
+    cx = sum(a[0] for a in largest) / len(largest)
+    cy = sum(a[1] for a in largest) / len(largest)
+    cz = sum(a[2] for a in largest) / len(largest)
+    return cx, cy, cz
+
+
+def _find_protein_center(pdb_content: str) -> tuple[float, float, float]:
+    xs, ys, zs = [], [], []
+    for line in pdb_content.splitlines():
+        if line.startswith("ATOM") and len(line) >= 54:
+            try:
+                xs.append(float(line[30:38].strip()))
+                ys.append(float(line[38:46].strip()))
+                zs.append(float(line[46:54].strip()))
+            except ValueError:
+                continue
+    if not xs:
+        return 0.0, 0.0, 0.0
+    return sum(xs) / len(xs), sum(ys) / len(ys), sum(zs) / len(zs)
+
+
+def _clean_protein(pdb_content: str) -> str:
+    """Keep only ATOM records (protein), strip HETATM, waters, ANISOU, CONECT."""
+    lines: list[str] = []
+    for line in pdb_content.splitlines():
+        if line.startswith("ATOM") and len(line) >= 54:
+            lines.append(line)
+        elif line.startswith("TER"):
+            lines.append(line)
+        elif line.startswith("END"):
+            lines.append(line)
+    return "\n".join(lines)
+
+
+def _parse_vina_pdbqt(pdbqt: str) -> list[dict[str, Any]]:
+    """Parse Vina output PDBQT into individual pose dicts."""
+    models = re.split(r"^MODEL\s+(\d+)", pdbqt, flags=re.MULTILINE)
+    poses: list[dict[str, Any]] = []
+    current_atoms: list[dict[str, Any]] = []
+    current_model = 0
+
+    for chunk in models:
+        chunk = chunk.strip()
+        if chunk.isdigit():
+            current_model = int(chunk)
+            current_atoms = []
+        elif chunk and current_model > 0:
+            for line in chunk.splitlines():
+                if line.startswith("ATOM") or line.startswith("HETATM"):
+                    try:
+                        x = float(line[30:38].strip())
+                        y = float(line[38:46].strip())
+                        z = float(line[46:54].strip())
+                        elem = line[76:78].strip()
+                        current_atoms.append({"x": x, "y": y, "z": z, "element": elem})
+                    except ValueError:
+                        continue
+            if current_atoms:
+                energy_match = re.search(r"REMARK VINA RESULT:\s*([-\d.]+)", chunk)
+                poses.append({
+                    "model": current_model,
+                    "atoms": len(current_atoms),
+                    "affinity": float(energy_match.group(1)) if energy_match else None,
+                })
+                current_atoms = []
+    return poses
+
+
+class DockingTool(BaseTool):
+    name = "docking"
+
+    async def run(self, input: dict) -> dict:
+        pdb_id = input.get("pdb_id", "").strip().upper()
+        smiles = input.get("smiles", "").strip()
+
+        if not pdb_id or not smiles:
+            return {"error": "pdb_id and smiles are required"}
+
+        tmpdir = tempfile.mkdtemp(prefix="docking_")
+        try:
+            # 1. Fetch PDB
+            pdb_url = PDB_DOWNLOAD.format(pdb_id=pdb_id)
+            async with httpx.AsyncClient(timeout=30) as client:
+                r = await client.get(pdb_url)
+                if r.status_code != 200:
+                    return {"error": f"PDB {pdb_id} not found at RCSB"}
+                pdb_content = r.text
+
+            pdb_path = os.path.join(tmpdir, "protein.pdb")
+            with open(pdb_path, "w") as f:
+                f.write(pdb_content)
+
+            # 2. Clean protein (strip waters, heteroatoms)
+            cleaned = _clean_protein(pdb_content)
+            clean_path = os.path.join(tmpdir, "cleaned.pdb")
+            with open(clean_path, "w") as f:
+                f.write(cleaned)
+
+            # 3. Convert protein to PDBQT via obabel
+            protein_pdbqt = os.path.join(tmpdir, "protein.pdbqt")
+            proc = await asyncio.create_subprocess_exec(
+                "obabel", clean_path, "-O", protein_pdbqt, "-xr",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await proc.communicate()
+            if proc.returncode != 0 or not os.path.exists(protein_pdbqt):
+                err = stderr.decode() if stderr else "obabel failed"
+                return {"error": f"Protein PDBQT preparation failed: {err}"}
+
+            # 4. Convert SMILES to 3D PDBQT via obabel
+            ligand_pdbqt = os.path.join(tmpdir, "ligand.pdbqt")
+            proc = await asyncio.create_subprocess_exec(
+                "obabel", f"-:{smiles}", "-O", ligand_pdbqt, "--gen3d", "-h",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await proc.communicate()
+            if proc.returncode != 0 or not os.path.exists(ligand_pdbqt):
+                err = stderr.decode() if stderr else "obabel failed"
+                return {"error": f"Ligand PDBQT preparation failed: {err}"}
+
+            # 5. Determine binding site box
+            center = _find_ligand_center(pdb_content)
+            if center:
+                cx, cy, cz = center
+                sx = sy = sz = 20
+            else:
+                cx, cy, cz = _find_protein_center(pdb_content)
+                sx = sy = sz = 30
+
+            # 6. Run Vina
+            out_pdbqt = os.path.join(tmpdir, "out.pdbqt")
+            vina_cmd = await asyncio.create_subprocess_exec(
+                VINA_CMD,
+                "--receptor", protein_pdbqt,
+                "--ligand", ligand_pdbqt,
+                "--out", out_pdbqt,
+                "--center_x", str(cx),
+                "--center_y", str(cy),
+                "--center_z", str(cz),
+                "--size_x", str(sx),
+                "--size_y", str(sy),
+                "--size_z", str(sz),
+                "--exhaustiveness", "8",
+                "--num_modes", "9",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            try:
+                stdout, stderr = await asyncio.wait_for(vina_cmd.communicate(), timeout=600)
+            except asyncio.TimeoutError:
+                vina_cmd.kill()
+                await vina_cmd.communicate()
+                return {"error": "Docking timed out after 10 minutes"}
+
+            if vina_cmd.returncode != 0 or not os.path.exists(out_pdbqt):
+                err = stderr.decode("utf-8", errors="replace")[:500] if stderr else ""
+                return {"error": f"Vina failed (exit {vina_cmd.returncode}): {err}"}
+
+            # 7. Parse results
+            with open(out_pdbqt) as f:
+                out_content = f.read()
+
+            poses = _parse_vina_pdbqt(out_content)
+            log = stdout.decode() if stdout else ""
+
+            return {
+                "pdb_id": pdb_id,
+                "smiles": smiles,
+                "poses": poses,
+                "num_poses": len(poses),
+                "box_center": {"x": cx, "y": cy, "z": cz},
+                "box_size": {"x": sx, "y": sy, "z": sz},
+                "vina_log": log[:2000],
+                "from_cache": False,
+            }
+
+        except Exception as e:
+            logger.exception("Docking run failed")
+            return {"error": f"Docking failed: {e}"}
+        finally:
+            shutil.rmtree(tmpdir, ignore_errors=True)

requirements.txt

@@ -6,6 +6,7 @@ httpx
 aiohttp
 biopython
 litellm
+sentry-sdk
 python-dotenv
 supabase
 reportlab