Implement API skeleton

.claude/plans/backend_init.md

@@ -21,17 +21,16 @@ src/backend/
     urls.py
     views/
       __init__.py
-      health.py
+      health.py                      # ApiRootView + HealthView
       coins.py
       graph_generation.py
       kg_anomaly.py
     services/
       __init__.py
-      registry.py          # Singleton: loads datasets at startup, scans checkpoints
-      coins_loader.py      # Lightweight KG dataset reader (NOT reusing research Loader)
-      constants.py         # All static/hardcoded data (models, query structures, etc.)
-    pagination.py          # Custom page/page_size pagination helper
-    exceptions.py          # Standardized error envelope
+      registry.py                    # Singleton: download + scan checkpoints, load datasets
+      constants.py                   # All static/hardcoded data (models, query structures, etc.)
+    pagination.py                    # Custom page/page_size pagination helper
+    exceptions.py                    # Standardized error envelope
 ```
 
 ## Key Design Decision: Reuse Research Loaders
@@ -49,8 +48,14 @@ The research `Loader` needs: `igraph`, `pandas`, `numpy`, `torch` (for device ha
 `registry.py` — loaded once via `AppConfig.ready()`:
 
 1. **Downloads checkpoints from Google Drive** if not already present locally
+   - Checks `_all_checkpoint_dirs_populated()` first — skips download if all dirs have files
+   - Uses `gdown.download_folder()` to a `.checkpoint_staging` dir, then `_distribute_checkpoints()` moves files to correct locations
+   - Gracefully handles failures (logs warning, continues with local files)
 2. **Loads all 3 COINs datasets** using the research `Loader`
 3. **Scans checkpoint directories** for `.tar` / `.ckpt` files to determine availability flags (does NOT load model weights)
+   - COINs: parses `{dataset}_{algorithm}.tar` filenames
+   - MultiProxAn: `{dataset}.ckpt` = discrete, `{dataset}_c.ckpt` = continuous
+   - DiGress KG: `{dataset}.ckpt` = generate, `{dataset}_correct.ckpt` = correct
 4. **Generates sample subgraphs** for KG anomaly using the existing research code:
    - `Loader.get_context_subgraph_dataset(max_graph_size, device)` — DFS-based partitioning of the full graph into sized subgraphs
    - Internally calls `Sampler.get_context_subgraph_samples_dfs()` in `graph_completion/graphs/preprocess.py` (line 742)
@@ -64,17 +69,17 @@ Per CLAUDE.md: "backend downloads all files and places them in the `checkpoints`
 
 Source: Google Drive folder `https://drive.google.com/drive/u/0/folders/14Bf8fi4KJn0rDdh9y8EFyA5b8OpQyXWi`
 
-Download logic in `registry.py`:
-1. Use `gdown` library to list and download files from the shared Google Drive folder
-2. For each file, check if it already exists locally (by filename + size) — skip if present
-3. Place `.tar` files into `{COINS_COMPLETION_DIR}/checkpoints/`
-4. Place `.ckpt` files into the appropriate dir based on naming convention:
-   - `{dataset}_c.ckpt` / `{dataset}.ckpt` (MultiProxAn) -> `{MULTIPROXAN_DIR}/checkpoints/`
-   - `{dataset}_correct.ckpt` / `{dataset}.ckpt` (DiGress KG) -> `{DIGRESS_KG_DIR}/checkpoints/`
-5. Log download progress to console
-6. If download fails (no internet, quota exceeded), log warning and continue — models_loaded flags will be false
+Google Drive folder structure (mapped to local dirs via `GDRIVE_SUBFOLDERS` config in `registry.py`):
+- `COINs-KGGeneration/checkpoints_coins/*.tar` -> `{COINS_COMPLETION_DIR}/checkpoints/`
+- `COINs-KGGeneration/checkpoints_kg_generation/*.ckpt` -> `{DIGRESS_KG_DIR}/checkpoints/`
+- `MultiProxAn/checkpoints/*.ckpt` -> `{MULTIPROXAN_DIR}/checkpoints/`
+- `COINs-KGGeneration/data/*` -> data files (also downloaded alongside checkpoints)
 
-Add `gdown` to `requirements.txt`.
+Download logic in `registry.py`:
+1. Check if all checkpoint dirs already have files — skip entire download if so
+2. Use `gdown.download_folder()` to staging dir with `resume=True`
+3. `_distribute_checkpoints()` moves files, comparing size to skip already-present files
+4. Log download progress; on failure, log warning and continue
 
 ### Checkpoint Scanning (after download)
 
@@ -82,23 +87,40 @@ Add `gdown` to `requirements.txt`.
 - MultiProxAn (graph generation): glob `{MULTIPROXAN_DIR}/checkpoints/{dataset}.ckpt` and `{dataset}_c.ckpt`
 - DiGress KG (anomaly correction): glob `{DIGRESS_KG_DIR}/checkpoints/{dataset}.ckpt` and `{dataset}_correct.ckpt`
 
-## Constants (hardcoded from API spec)
+## Django Settings
 
-`constants.py` contains all static data:
-- `METHODS` — 3 research methods (id, name, thesis_section, description)
-- `COINS_DATASET_META` — dataset id -> {name, description, data_dir}
-- `COINS_MODELS` — 6 algorithms with supported_query_structures and available_datasets
-  - TransE, DistMult, ComplEx, RotatE, KBGAT: 1p only
-  - Q2B: all query structures (1p, 2p, 3p, 2i, 3i, ip, pi)
-- `QUERY_STRUCTURES` — 7 query graph templates (nodes + edges arrays)
-- `GRAPHGEN_DATASETS` — QM9 (molecular) + Community20 (synthetic)
-- `GRAPHGEN_SAMPLING_MODES` — standard (T, chain_frames) + multiprox (T, m, t, t_prime)
-- `KG_ANOMALY_DATASET_META` — freebase, wordnet, nell
+- `DATABASES = {}` — no database
+- `INSTALLED_APPS`: `corsheaders`, `rest_framework`, `api`
+- `MIDDLEWARE`: `CorsMiddleware` + `CommonMiddleware` only
+- `CORS_ALLOWED_ORIGINS`: `["https://bani57.pythonanywhere.com"]` (+ `CORS_ALLOW_ALL_ORIGINS = True` in DEBUG)
+- `REST_FRAMEWORK`: JSON renderer/parser only, no default pagination, custom exception handler (`api.exceptions.api_exception_handler`)
+- `SECRET_KEY` from env var `DJANGO_SECRET_KEY` with dev fallback
+- `DEBUG` from env var `DJANGO_DEBUG`
+- `ALLOWED_HOSTS` from env var `DJANGO_ALLOWED_HOSTS`
+- Custom research path settings (all as `pathlib.Path` resolved from `PROJECT_ROOT`):
+  - `COINS_DATA_DIR` -> `src/research/COINs-KGGeneration/data/`
+  - `COINS_COMPLETION_DIR` -> `src/research/COINs-KGGeneration/graph_completion/`
+  - `DIGRESS_KG_DIR` -> `src/research/COINs-KGGeneration/graph_generation/` (DiGress model applied to KG data)
+  - `MULTIPROXAN_DIR` -> `src/research/MultiProxAn/`
+- Each has its own checkpoints subdirectory:
+  - COINs (link prediction): `{COINS_COMPLETION_DIR}/checkpoints/`
+  - DiGress KG (anomaly correction): `{DIGRESS_KG_DIR}/checkpoints/`
+  - MultiProxAn (graph generation): `{MULTIPROXAN_DIR}/checkpoints/`
+
+## Error Handling
+
+Custom DRF exception handler (`api/exceptions.py`) wrapping all errors in:
+```json
+{"error": {"code": "NOT_FOUND", "message": "...", "details": {}}}
+```
+
+`ApiError` base class with `NotFoundError`, `InvalidRequestError` subclasses. Falls back to standard DRF handler for non-ApiError exceptions, still wrapping in the error envelope.
 
-## Endpoints (12 total)
+## Endpoints (13 total)
 
 | Method | Path | View Class | Data Source |
 |--------|------|-----------|-------------|
+| `GET` | `/` (api root) | `ApiRootView` | API name, version, description, endpoint directory |
 | `GET` | `/health` | `HealthView` | Registry availability flags |
 | `GET` | `/methods` | `MethodsView` | `METHODS` constant |
 | `GET` | `/coins/datasets` | `CoinsDatasetsView` | Registry + `COINS_DATASET_META` |
@@ -112,30 +134,18 @@ Add `gdown` to `requirements.txt`.
 | `GET` | `/kg-anomaly/datasets` | `KgAnomalyDatasetsView` | `KG_ANOMALY_DATASET_META` |
 | `GET` | `/kg-anomaly/datasets/{id}/sample-subgraphs` | `KgAnomalySampleSubgraphsView` | Registry pre-computed subgraphs |
 
-## Django Settings
-
-- `DATABASES = {}` — no database
-- `INSTALLED_APPS`: `rest_framework`, `corsheaders`, `api`
-- `CORS_ALLOWED_ORIGINS`: `["https://bani57.pythonanywhere.com"]`
-- `REST_FRAMEWORK`: JSON renderer only, no default pagination, custom exception handler
-- Custom research path settings:
-  - `COINS_DATA_DIR` -> `src/research/COINs-KGGeneration/data/`
-  - `COINS_COMPLETION_DIR` -> `src/research/COINs-KGGeneration/graph_completion/`
-  - `DIGRESS_KG_DIR` -> `src/research/COINs-KGGeneration/graph_generation/` (DiGress model applied to KG data)
-  - `MULTIPROXAN_DIR` -> `src/research/MultiProxAn/`
-- Each has its own checkpoints subdirectory:
-  - COINs (link prediction): `{COINS_COMPLETION_DIR}/checkpoints/`
-  - DiGress KG (anomaly correction): `{DIGRESS_KG_DIR}/checkpoints/`
-  - MultiProxAn (graph generation): `{MULTIPROXAN_DIR}/checkpoints/`
-
-## Error Handling
-
-Custom DRF exception handler wrapping all errors in:
-```json
-{"error": {"code": "NOT_FOUND", "message": "...", "details": {}}}
-```
+## Constants (hardcoded from API spec)
 
-`ApiError` base class with `NotFoundError`, `InvalidRequestError` subclasses.
+`constants.py` contains all static data:
+- `METHODS` — 3 research methods (id, name, thesis_section, description)
+- `COINS_DATASET_META` — dataset id -> {name, description, data_dir}
+- `COINS_MODELS` — 6 algorithms with supported_query_structures and available_datasets
+  - TransE, DistMult, ComplEx, RotatE, KBGAT: 1p only
+  - Q2B: all query structures (1p, 2p, 3p, 2i, 3i, ip, pi)
+- `QUERY_STRUCTURES` — 7 query graph templates (nodes + edges arrays)
+- `GRAPHGEN_DATASETS` — QM9 (molecular) + Community20 (synthetic)
+- `GRAPHGEN_SAMPLING_MODES` — standard (T, chain_frames) + multiprox (T, m, t, t_prime)
+- `KG_ANOMALY_DATASET_META` — freebase, wordnet, nell
 
 ## Dependencies
 
@@ -191,9 +201,11 @@ pip install -e .
 cd src/analysis/orca && g++ -O2 -std=c++11 -o orca orca.cpp
 ```
 
+### Backend environment — `website_c` mamba env (Python 3.9)
+
 ### Backend requirements.txt
 
-The backend must unify both into one Python 3.9 environment. Since the COINs `Loader` is the only part reused for init, we pin to the DiGress/MultiProxAn versions and ensure COINs code runs under them. For PythonAnywhere (CPU only), use CPU torch wheels.
+The backend unifies both into one Python 3.9 environment. Since the COINs `Loader` is the only part reused for init, we pin to the DiGress/MultiProxAn versions and ensure COINs code runs under them. For PythonAnywhere (CPU only), use CPU torch wheels.
 
 ```
 # Django
@@ -237,37 +249,40 @@ tqdm==4.65.0
 
 ## Implementation Sequence
 
-1. Write `requirements.txt` and install dependencies (django, DRF, cors-headers, torch, igraph, scipy, pandas, numpy)
+1. Write `requirements.txt` and install dependencies (django, DRF, cors-headers, torch, igraph, scipy, pandas, numpy, gdown)
 2. Create Django project scaffolding (`manage.py`, `research_api/` settings/urls/wsgi)
 3. Configure settings — CORS, DRF, research paths (`COINS_DATA_DIR`, `COINS_COMPLETION_DIR`, `DIGRESS_KG_DIR`, `MULTIPROXAN_DIR`), add research dirs to `sys.path`
 4. Create `api` app skeleton (`apps.py`, `urls.py`)
-5. Write `constants.py` — all static data from API spec (methods, models, query structures, dataset metadata, sampling modes)
-6. Write `registry.py` — `ModelRegistry` singleton: Google Drive checkpoint download, research `Loader` for COINs datasets, checkpoint scanning across all 3 dirs
-7. Write `pagination.py` — `paginate_list()` helper
-8. Write `exceptions.py` — custom error envelope formatting
-9. Write views — one class per endpoint, using registry + constants
-10. Wire URL routing (`research_api/urls.py` -> `api/urls.py`)
-11. Hook `ModelRegistry.initialize()` in `AppConfig.ready()`
+5. Write `exceptions.py` — custom error envelope formatting (`ApiError`, `NotFoundError`, `InvalidRequestError`)
+6. Write `registry.py` — `ModelRegistry` singleton: Google Drive checkpoint download (with skip-if-present), checkpoint scanning across all 3 dirs
+7. Write `constants.py` — all static data from API spec (methods, models, query structures, dataset metadata, sampling modes)
+8. Write `pagination.py` — `paginate_list()` helper
+9. Write `health.py` — `ApiRootView` (endpoint directory) + `HealthView` (status + models_loaded flags)
+10. Write remaining views (`coins.py`, `graph_generation.py`, `kg_anomaly.py`) — one class per endpoint, using registry + constants
+11. Wire URL routing (`research_api/urls.py` -> `api/urls.py`)
+12. Hook `ModelRegistry.initialize()` in `AppConfig.ready()`
+13. Add research `Loader` integration to registry for dataset loading + subgraph generation
 
 ## Verification
 
-1. `pip install -r requirements.txt` — all dependencies install cleanly
-2. `python manage.py check` — Django system check passes (no DB warnings expected since `DATABASES = {}`)
-3. `python manage.py runserver` — registry downloads checkpoints from Google Drive (or skips if present), loads 3 COINs datasets via research `Loader`, scans all 3 checkpoint dirs, prints entity/relation counts
-4. `GET /api/v1/health` — returns `{"status": "ok", "models_loaded": {"coins": true/false, "multiproxan": true/false, "kg_anomaly": true/false}}` based on checkpoint scan
-5. `GET /api/v1/methods` — returns 3 methods
-6. `GET /api/v1/coins/datasets` — returns 3 datasets with correct entity/relation counts (FB15k-237: ~14541 entities, 237 relations; WN18RR: ~40943 entities, 11 relations; NELL-995: from entity2id.txt/relation2id.txt)
-7. `GET /api/v1/coins/datasets/freebase/entities?q=location&page=1&page_size=10` — filtered, paginated results
-8. `GET /api/v1/coins/datasets/freebase/relations?q=country` — substring search on relation names
-9. `GET /api/v1/coins/datasets/freebase/sample-triples?count=5` — 5 random triples with resolved entity/relation names
-10. `GET /api/v1/coins/datasets/unknown/entities` — `{"error": {"code": "NOT_FOUND", ...}}`
-11. `GET /api/v1/coins/models` — 6 algorithms, filtered by actually available checkpoints
-12. `GET /api/v1/coins/query-structures` — 7 templates (1p, 2p, 3p, 2i, 3i, ip, pi) matching API spec
-13. `GET /api/v1/graph-generation/datasets` — QM9 + Community20 with model type availability from MultiProxAn checkpoint scan
-14. `GET /api/v1/graph-generation/sampling-modes` — standard + multiprox with parameter specs
-15. `GET /api/v1/kg-anomaly/datasets` — 3 datasets with availability from DiGress KG checkpoint scan
-16. `GET /api/v1/kg-anomaly/datasets/freebase/sample-subgraphs?count=3` — 3 pre-computed subgraphs with entity/relation names
-17. Import `docs/postman/collection.json` into Postman, set environment, run all GET requests against running server
+1. `pip install -r requirements.txt` — all dependencies install cleanly into `website_c` env
+2. `python manage.py check` — Django system check passes, 0 issues
+3. `python manage.py runserver` — registry downloads checkpoints from Google Drive (or skips if present), scans all 3 checkpoint dirs, logs entity/relation counts
+4. `GET /api/v1/` — returns API name, version, description, full endpoint directory with absolute URLs
+5. `GET /api/v1/health` — returns `{"status": "ok", "models_loaded": {"coins": bool, "multiproxan": bool, "kg_anomaly": bool}}`
+6. `GET /api/v1/methods` — returns 3 methods
+7. `GET /api/v1/coins/datasets` — returns 3 datasets with correct entity/relation counts
+8. `GET /api/v1/coins/datasets/freebase/entities?q=location&page=1&page_size=10` — filtered, paginated results
+9. `GET /api/v1/coins/datasets/freebase/relations?q=country` — substring search on relation names
+10. `GET /api/v1/coins/datasets/freebase/sample-triples?count=5` — 5 random triples with resolved names
+11. `GET /api/v1/coins/datasets/unknown/entities` — `{"error": {"code": "NOT_FOUND", ...}}`
+12. `GET /api/v1/coins/models` — 6 algorithms, filtered by actually available checkpoints
+13. `GET /api/v1/coins/query-structures` — 7 templates (1p, 2p, 3p, 2i, 3i, ip, pi) matching API spec
+14. `GET /api/v1/graph-generation/datasets` — QM9 + Community20 with model type availability from MultiProxAn checkpoint scan
+15. `GET /api/v1/graph-generation/sampling-modes` — standard + multiprox with parameter specs
+16. `GET /api/v1/kg-anomaly/datasets` — 3 datasets with availability from DiGress KG checkpoint scan
+17. `GET /api/v1/kg-anomaly/datasets/freebase/sample-subgraphs?count=3` — 3 pre-computed subgraphs with entity/relation names
+18. Import `docs/postman/collection.json` into Postman, set environment, run all GET requests against running server
 
 ## Critical Source Files
 
@@ -276,6 +291,7 @@ tqdm==4.65.0
 | `docs/api.yaml` | Authoritative API contract for all response schemas |
 | `src/research/COINs-KGGeneration/graph_completion/graphs/load_graph.py` | Research `Loader` class reused for dataset loading |
 | `src/research/COINs-KGGeneration/graph_data/load_data.py` | Dataset classes (FreeBase, WordNet, NELL) with file formats |
+| `src/research/COINs-KGGeneration/graph_completion/graphs/preprocess.py` | `Sampler.get_context_subgraph_samples_dfs()` for KG anomaly sample subgraphs |
 | `src/research/COINs-KGGeneration/data/` | Actual data files (train/valid/test.txt, entity2id.txt, relation2id.txt) |
 | `src/research/MultiProxAn/checkpoints/` | MultiProxAn checkpoint dir (scanned for availability) |
 | `src/research/COINs-KGGeneration/graph_generation/checkpoints/` | DiGress KG checkpoint dir (scanned for availability) |

.gitignore

@@ -4,3 +4,4 @@ __pycache__
 src/research/COINs-KGGeneration/graph_completion/checkpoints/
 src/research/COINs-KGGeneration/graph_generation/checkpoints/
 src/research/MultiProxAn/checkpoints/
+src/backend/.checkpoint_staging/

docs/postman/collection.json

@@ -14,6 +14,19 @@
     {
       "name": "Health",
       "item": [
+        {
+          "name": "GET / (API root)",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{base_url}}/",
+              "host": ["{{base_url}}"],
+              "path": [""]
+            },
+            "description": "API root. Returns name, version, description, and full endpoint directory."
+          }
+        },
         {
           "name": "GET /health",
           "request": {

src/backend/api/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    name = "api"
+    default_auto_field = "django.db.models.BigAutoField"
+
+    def ready(self):
+        from api.services.registry import ModelRegistry
+
+        ModelRegistry.initialize()

src/backend/api/exceptions.py

@@ -0,0 +1,38 @@
+from rest_framework.exceptions import APIException
+from rest_framework.response import Response
+from rest_framework.views import exception_handler
+
+
+class ApiError(APIException):
+    def __init__(self, code, message, status_code=400, details=None):
+        self.code = code
+        self.detail = message
+        self.status_code = status_code
+        self.details = details or {}
+
+
+class NotFoundError(ApiError):
+    def __init__(self, message, details=None):
+        super().__init__("NOT_FOUND", message, status_code=404, details=details)
+
+
+class InvalidRequestError(ApiError):
+    def __init__(self, message, details=None):
+        super().__init__("INVALID_REQUEST", message, status_code=400, details=details)
+
+
+def api_exception_handler(exc, context):
+    if isinstance(exc, ApiError):
+        return Response(
+            {"error": {"code": exc.code, "message": str(exc.detail), "details": exc.details}},
+            status=exc.status_code,
+        )
+    response = exception_handler(exc, context)
+    if response is not None:
+        code = "UNKNOWN_ERROR"
+        if response.status_code == 404:
+            code = "NOT_FOUND"
+        elif response.status_code == 400:
+            code = "INVALID_REQUEST"
+        response.data = {"error": {"code": code, "message": str(response.data), "details": {}}}
+    return response

src/backend/api/services/registry.py

@@ -0,0 +1,171 @@
+import logging
+import os
+from pathlib import Path
+
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+GDRIVE_FOLDER_ID = "14Bf8fi4KJn0rDdh9y8EFyA5b8OpQyXWi"
+
+# Subfolder IDs within the Google Drive folder (from gdown listing)
+GDRIVE_SUBFOLDERS = {
+    "coins": {
+        "folder_name": "COINs-KGGeneration/checkpoints_coins",
+        "local_dir_setting": "COINS_COMPLETION_DIR",
+        "local_subdir": "checkpoints",
+    },
+    "kg_generation": {
+        "folder_name": "COINs-KGGeneration/checkpoints_kg_generation",
+        "local_dir_setting": "DIGRESS_KG_DIR",
+        "local_subdir": "checkpoints",
+    },
+    "multiproxan": {
+        "folder_name": "MultiProxAn/checkpoints",
+        "local_dir_setting": "MULTIPROXAN_DIR",
+        "local_subdir": "checkpoints",
+    },
+}
+
+
+class ModelRegistry:
+    _instance = None
+
+    def __init__(self):
+        self.coins_checkpoints_available = {}
+        self.graphgen_checkpoints_available = {}
+        self.kg_anomaly_checkpoints_available = {}
+
+    @classmethod
+    def get(cls):
+        if cls._instance is None:
+            raise RuntimeError("ModelRegistry not initialized. Call initialize() first.")
+        return cls._instance
+
+    @classmethod
+    def initialize(cls):
+        if cls._instance is not None:
+            return
+        instance = cls()
+        instance._download_checkpoints()
+        instance._scan_checkpoints()
+        cls._instance = instance
+        logger.info(
+            "ModelRegistry initialized: coins=%s, multiproxan=%s, kg_anomaly=%s",
+            instance.is_coins_loaded(),
+            instance.is_graphgen_loaded(),
+            instance.is_kg_anomaly_loaded(),
+        )
+
+    def _download_checkpoints(self):
+        """Download checkpoints from Google Drive if not already present locally."""
+        if self._all_checkpoint_dirs_populated():
+            logger.info("All checkpoint directories already populated, skipping Google Drive download")
+            return
+
+        try:
+            import gdown
+        except ImportError:
+            logger.warning("gdown not installed, skipping checkpoint download")
+            return
+
+        gdrive_url = f"https://drive.google.com/drive/folders/{GDRIVE_FOLDER_ID}"
+        logger.info("Downloading checkpoints from Google Drive: %s", gdrive_url)
+
+        try:
+            staging_dir = Path(settings.BASE_DIR) / ".checkpoint_staging"
+            staging_dir.mkdir(exist_ok=True)
+
+            gdown.download_folder(
+                gdrive_url, output=str(staging_dir), quiet=False, resume=True,
+            )
+
+            self._distribute_checkpoints(staging_dir)
+        except Exception:
+            logger.exception("Failed to download checkpoints from Google Drive, continuing with local files")
+
+    def _all_checkpoint_dirs_populated(self):
+        """Check if all checkpoint dirs already have at least one checkpoint file."""
+        for config in GDRIVE_SUBFOLDERS.values():
+            dest_dir = Path(getattr(settings, config["local_dir_setting"])) / config["local_subdir"]
+            if not dest_dir.exists():
+                return False
+            ckpt_files = list(dest_dir.glob("*.tar")) + list(dest_dir.glob("*.ckpt"))
+            if not ckpt_files:
+                return False
+        return True
+
+    def _distribute_checkpoints(self, staging_dir):
+        """Move downloaded files from staging into the correct checkpoint directories."""
+        for group, config in GDRIVE_SUBFOLDERS.items():
+            src_dir = staging_dir / config["folder_name"]
+            if not src_dir.exists():
+                logger.warning("Expected staging subfolder not found: %s", src_dir)
+                continue
+
+            dest_dir = Path(getattr(settings, config["local_dir_setting"])) / config["local_subdir"]
+            dest_dir.mkdir(parents=True, exist_ok=True)
+
+            for src_file in src_dir.iterdir():
+                if not src_file.is_file():
+                    continue
+                dest_file = dest_dir / src_file.name
+                if dest_file.exists() and dest_file.stat().st_size == src_file.stat().st_size:
+                    logger.debug("Checkpoint already present, skipping: %s", dest_file.name)
+                    continue
+                logger.info("Installing checkpoint: %s -> %s", src_file.name, dest_dir)
+                src_file.replace(dest_file)
+
+    def _scan_checkpoints(self):
+        self._scan_coins_checkpoints()
+        self._scan_graphgen_checkpoints()
+        self._scan_kg_anomaly_checkpoints()
+
+    def _scan_coins_checkpoints(self):
+        ckpt_dir = Path(settings.COINS_COMPLETION_DIR) / "checkpoints"
+        if not ckpt_dir.exists():
+            logger.warning("COINs checkpoint dir not found: %s", ckpt_dir)
+            return
+        for path in ckpt_dir.glob("*.tar"):
+            parts = path.stem.rsplit("_", 1)
+            if len(parts) == 2:
+                dataset_id, algorithm = parts
+                self.coins_checkpoints_available.setdefault(dataset_id, []).append(algorithm)
+        logger.info("COINs checkpoints: %s", self.coins_checkpoints_available)
+
+    def _scan_graphgen_checkpoints(self):
+        ckpt_dir = Path(settings.MULTIPROXAN_DIR) / "checkpoints"
+        if not ckpt_dir.exists():
+            logger.warning("MultiProxAn checkpoint dir not found: %s", ckpt_dir)
+            return
+        for path in ckpt_dir.glob("*.ckpt"):
+            name = path.stem
+            if name.endswith("_c"):
+                dataset_id = name[:-2]
+                self.graphgen_checkpoints_available.setdefault(dataset_id, []).append("continuous")
+            else:
+                self.graphgen_checkpoints_available.setdefault(name, []).append("discrete")
+        logger.info("MultiProxAn checkpoints: %s", self.graphgen_checkpoints_available)
+
+    def _scan_kg_anomaly_checkpoints(self):
+        ckpt_dir = Path(settings.DIGRESS_KG_DIR) / "checkpoints"
+        if not ckpt_dir.exists():
+            logger.warning("DiGress KG checkpoint dir not found: %s", ckpt_dir)
+            return
+        for path in ckpt_dir.glob("*.ckpt"):
+            name = path.stem
+            if name.endswith("_correct"):
+                dataset_id = name[:-8]
+                self.kg_anomaly_checkpoints_available.setdefault(dataset_id, []).append("correct")
+            else:
+                self.kg_anomaly_checkpoints_available.setdefault(name, []).append("generate")
+        logger.info("DiGress KG checkpoints: %s", self.kg_anomaly_checkpoints_available)
+
+    def is_coins_loaded(self):
+        return bool(self.coins_checkpoints_available)
+
+    def is_graphgen_loaded(self):
+        return bool(self.graphgen_checkpoints_available)
+
+    def is_kg_anomaly_loaded(self):
+        return bool(self.kg_anomaly_checkpoints_available)

src/backend/api/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+
+from api.views.health import ApiRootView, HealthView
+
+urlpatterns = [
+    path("", ApiRootView.as_view()),
+    path("health", HealthView.as_view()),
+]

src/backend/api/views/health.py

@@ -0,0 +1,52 @@
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+
+from api.services.registry import ModelRegistry
+
+
+class ApiRootView(APIView):
+    def get(self, request):
+        return Response({
+            "name": "Scalable Graph ML Research API",
+            "version": "1.0.0",
+            "description": (
+                "REST API for testing PhD research methods from "
+                "\"Scalable Methods for Knowledge Graph Reasoning and Generation\" "
+                "(Andrej Janchevski, EPFL, 2025)"
+            ),
+            "endpoints": {
+                "health": request.build_absolute_uri("health"),
+                "methods": request.build_absolute_uri("methods"),
+                "coins": {
+                    "datasets": request.build_absolute_uri("coins/datasets"),
+                    "models": request.build_absolute_uri("coins/models"),
+                    "query_structures": request.build_absolute_uri("coins/query-structures"),
+                    "predict": request.build_absolute_uri("coins/predict"),
+                },
+                "graph_generation": {
+                    "datasets": request.build_absolute_uri("graph-generation/datasets"),
+                    "sampling_modes": request.build_absolute_uri("graph-generation/sampling-modes"),
+                    "generate": request.build_absolute_uri("graph-generation/generate"),
+                    "continue": request.build_absolute_uri("graph-generation/continue"),
+                },
+                "kg_anomaly": {
+                    "datasets": request.build_absolute_uri("kg-anomaly/datasets"),
+                    "correct": request.build_absolute_uri("kg-anomaly/correct"),
+                    "continue": request.build_absolute_uri("kg-anomaly/continue"),
+                },
+            },
+        })
+
+
+class HealthView(APIView):
+    def get(self, request):
+        registry = ModelRegistry.get()
+        return Response({
+            "status": "ok",
+            "models_loaded": {
+                "coins": registry.is_coins_loaded(),
+                "multiproxan": registry.is_graphgen_loaded(),
+                "kg_anomaly": registry.is_kg_anomaly_loaded(),
+            },
+        })

src/backend/manage.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "research_api.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

src/backend/research_api/settings.py

@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+PROJECT_ROOT = BASE_DIR.parent.parent  # Website root
+
+SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY", "dev-insecure-key-change-in-production")
+DEBUG = os.environ.get("DJANGO_DEBUG", "True").lower() in ("true", "1")
+ALLOWED_HOSTS = os.environ.get("DJANGO_ALLOWED_HOSTS", "localhost,127.0.0.1").split(",")
+
+INSTALLED_APPS = [
+    "corsheaders",
+    "rest_framework",
+    "api",
+]
+
+MIDDLEWARE = [
+    "corsheaders.middleware.CorsMiddleware",
+    "django.middleware.common.CommonMiddleware",
+]
+
+ROOT_URLCONF = "research_api.urls"
+WSGI_APPLICATION = "research_api.wsgi.application"
+
+DATABASES = {}
+
+REST_FRAMEWORK = {
+    "DEFAULT_RENDERER_CLASSES": ["rest_framework.renderers.JSONRenderer"],
+    "DEFAULT_PARSER_CLASSES": ["rest_framework.parsers.JSONParser"],
+    "DEFAULT_PAGINATION_CLASS": None,
+    "DEFAULT_AUTHENTICATION_CLASSES": [],
+    "DEFAULT_PERMISSION_CLASSES": ["rest_framework.permissions.AllowAny"],
+    "EXCEPTION_HANDLER": "api.exceptions.api_exception_handler",
+    "UNAUTHENTICATED_USER": None,
+}
+
+CORS_ALLOWED_ORIGINS = [
+    "https://bani57.pythonanywhere.com",
+]
+if DEBUG:
+    CORS_ALLOW_ALL_ORIGINS = True
+
+# Research code paths
+COINS_DATA_DIR = PROJECT_ROOT / "src" / "research" / "COINs-KGGeneration" / "data"
+COINS_COMPLETION_DIR = PROJECT_ROOT / "src" / "research" / "COINs-KGGeneration" / "graph_completion"
+DIGRESS_KG_DIR = PROJECT_ROOT / "src" / "research" / "COINs-KGGeneration" / "graph_generation"
+MULTIPROXAN_DIR = PROJECT_ROOT / "src" / "research" / "MultiProxAn"
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

src/backend/research_api/urls.py

@@ -0,0 +1,5 @@
+from django.urls import include, path
+
+urlpatterns = [
+    path("api/v1/", include("api.urls")),
+]

src/backend/research_api/wsgi.py

@@ -0,0 +1,6 @@
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "research_api.settings")
+application = get_wsgi_application()