napari-nninteractive 2.3.2__tar.gz → 2.4.2__tar.gz

{napari_nninteractive-2.3.2/src/napari_nninteractive.egg-info → napari_nninteractive-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-nninteractive
-Version: 2.3.2
+Version: 2.4.2
 Summary: nnInteractive plugin for Napari
 Author: Lars Krämer, Fabian Isensee, Maximilian Rokuss
 Author-email: lars.kraemer@dkfz-heidelberg.de, f.isensee@dkfz-heidelberg.de, maximilian.rokuss@dkfz-heidelberg.de
@@ -225,14 +225,13 @@ Classifier: Topic :: Scientific/Engineering :: Image Processing
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: torch
 Requires-Dist: numpy
 Requires-Dist: qtpy
 Requires-Dist: napari-nifti
-Requires-Dist: huggingface_hub
-Requires-Dist: hf_transfer
-Requires-Dist: nnInteractive>=2.4.0
 Requires-Dist: napari_toolkit
+Requires-Dist: nninteractive-client>=2.5.0
+Provides-Extra: local
+Requires-Dist: nnInteractive>=2.5.0; extra == "local"
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
@@ -240,8 +239,6 @@ Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-qt; extra == "testing"
 Requires-Dist: napari; extra == "testing"
 Requires-Dist: pyqt5; extra == "testing"
-Provides-Extra: remote
-Requires-Dist: nnInteractive[client]>=2.4.0; extra == "remote"
 Dynamic: license-file
 
 <img src="https://github.com/MIC-DKFZ/napari-nninteractive/raw/main/imgs/nnInteractive_header.png"  width="1200">
@@ -286,57 +283,68 @@ Extensive benchmarking demonstrates that nnInteractive far surpasses existing me
 
 ## Installation
 
-### Prerequisites
+`napari-nninteractive` installs as a **lightweight, torch-free remote client by default** — it can drive a remote `nninteractive-server` straight away, on any machine. **Local (in-process) inference is an opt-in extra** (`[local]`) that adds the full nnInteractive backend (PyTorch + nnU-Net) and needs an Nvidia GPU.
 
-For **local** inference you need a Linux or Windows computer with an Nvidia GPU. 10GB of VRAM is recommended. Small objects should work with \<6GB.
+| Mode | Install | PyTorch? | Hardware |
+|------|---------|----------|----------|
+| **Remote client** (default) | `pip install napari-nninteractive` | **No** (lightweight, torch-free) | anything — laptop, Mac, no GPU |
+| **Local inference** | `pip install "napari-nninteractive[local]"` (+ PyTorch) | **Yes** (large download) | Linux/Windows + Nvidia GPU — 10 GB VRAM recommended, \<6 GB works for small objects |
 
 > [!TIP]
-> **On a Mac, or without a capable Nvidia GPU?** Use [**Remote inference**](#remote-inference-server--client) instead. nnInteractive relies heavily on 3D convolutions, which are prohibitively slow on Apple Silicon (MPS) and CPU hardware — running the model on a remote GPU and driving it from napari is the recommended, and often only practical, way to use nnInteractive on these machines. The napari client itself has no GPU requirements and runs anywhere; only the GPU server needs the hardware above.
+> **On a Mac, or without a capable Nvidia GPU?** The default install is already exactly what you want — stop after Step 2. nnInteractive relies heavily on 3D convolutions, which are prohibitively slow on Apple Silicon (MPS) and CPU hardware, so running the model on a remote GPU and driving it from napari is the recommended, and often only practical, way to use it on these machines. See [Remote inference (server / client)](#remote-inference-server--client) for how to set up and connect to the server.
 
-##### 1. Create a virtual environment:
+### Step 1 — Create a virtual environment
 
-nnInteractive supports Python 3.10+ and works with Conda, pip, or any other virtual environment. Here’s an example using Conda:
+nnInteractive supports Python 3.10+ and works with Conda, pip, or any other virtual environment. Here's an example using Conda:
 
-```
+```bash
 conda create -n nnInteractive python=3.12
 conda activate nnInteractive
 ```
 
-##### 2. Install the correct PyTorch for your system
+Install napari if you don't already have it:
 
-Go to the [PyTorch homepage](https://pytorch.org/get-started/locally/) and pick the right configuration.
-Note that since recently PyTorch needs to be installed via pip. This is fine to do within your conda environment.
+```bash
+pip install napari[all]
+```
 
-For Ubuntu with a Nvidia GPU, pick 'stable', 'Linux', 'Pip', 'Python', 'CUDA12.6' (if all drivers are up to date, otherwise use and older version):
+### Step 2 — Install the plugin (remote client, torch-free)
 
-```
-pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126
+```bash
+pip install napari-nninteractive
 ```
 
-##### 3. Install this repository + dependencies via
+This is the **entire** install if you only drive a remote `nninteractive-server`: no PyTorch, no GPU required. The plugin starts in Remote mode — see [Remote inference (server / client)](#remote-inference-server--client) to connect.
 
-Install napari if necessary
+### Step 3 — (Optional) Enable local inference
+
+Only needed if **this** machine runs the model itself. Requires a Linux or Windows computer with an Nvidia GPU.
+
+**1. Install the correct PyTorch for your system.** Go to the [PyTorch homepage](https://pytorch.org/get-started/locally/) and pick the right configuration. PyTorch must be installed via pip nowadays, which is fine inside a conda environment. For Ubuntu with an Nvidia GPU, pick 'stable', 'Linux', 'Pip', 'Python', CUDA version does not matter (ensure your driver is up to date!). Then execute the command that is displayed, for example:
 
 ```bash
-pip install napari[all]
+pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126
 ```
 
-Install the plugin via pip:
+**2. Add the `[local]` extra** (pulls the full nnInteractive backend + nnU-Net):
 
 ```bash
-pip install napari-nninteractive
+pip install "napari-nninteractive[local]"
 ```
 
-Or clone and install this repository:
+Quote the brackets so your shell does not treat them as a glob (required in zsh / macOS). Model weights are downloaded automatically on first use; this can take a couple of minutes depending on your connection.
+
+You can do this at **any** time: if you started with the default client-only install and the **Local** switch in the plugin is greyed out, just run the command above (after installing PyTorch) and restart napari to unlock local inference.
+
+### Install from source (optional)
 
 ```bash
 git clone https://github.com/MIC-DKFZ/napari-nninteractive
 cd napari-nninteractive
-pip install -e .
+pip install -e .                 # remote client (torch-free) — the default
+pip install -e ".[local]"        # local inference — also install PyTorch first (see Step 3)
 ```
 
-**Note:** Model weights are automatically downloaded on first use. This can take up to a couple of minutes depending on your internet connection
-
 ## Getting Started
 
 Use one of these three options to start napari and activate the plugin.
@@ -401,6 +409,32 @@ Share the printed API key with your users via whatever channel you use for share
 
 The model checkpoint is fixed by the server at startup, so the local checkpoint selector is hidden in Remote mode.
 
+> [!NOTE]
+> The **default install is the torch-free client**, so unless you added the `[local]` extra
+> the plugin starts directly in Remote mode and the **Local** switch is greyed out. Hover the
+> switch (or read the one-line notice printed on start-up) for the reason and the exact
+> command. To unlock local inference, install PyTorch and the extra
+> (`pip install "napari-nninteractive[local]"`; see Step 3 of [Installation](#installation) above),
+> then restart napari.
+
+### …or run the server in Docker
+
+If you'd rather not install the backend on the GPU box, the server is also published as a Docker
+image with the model **baked in** (a GPU host with the
+[NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+is required):
+
+```bash
+docker run --gpus all -p 1527:1527 \
+    -e NN_INTERACTIVE_API_KEY="$(openssl rand -hex 32)" \
+    ghcr.io/mic-dkfz/nninteractive-server:latest
+```
+
+A `lite` tag is also available if you'd rather mount your own checkpoint folder at `/model` (or
+fetch a model by id at startup). See the backend
+[DOCKER.md](https://github.com/MIC-DKFZ/nnInteractive/blob/master/nnInteractive/inference/server/DOCKER.md)
+for both flavours and all configuration options.
+
 ### Things to be aware of
 
 - **Lost connection or idle timeout.** Server-side sessions are reaped after 10 minutes of inactivity (configurable on the server), and a server that goes away (restart, crash, network drop) ends the session too. When this happens the plugin resets the **Connect** button and asks you to reconnect. **Your current segmentation is preserved** on the client: after you reconnect and click **Initialize** again, the image is re-uploaded and the segmentation is restored so you can keep refining where you left off. Only the in-progress prompt markers (the individual points/boxes/scribbles) need to be redone.
@@ -421,7 +455,7 @@ Link: [![arXiv](https://img.shields.io/badge/arXiv-2503.08373-b31b1b.svg)](https
 
 # License
 
-Note that while this repository is available under Apache-2.0 license (see [LICENSE](./LICENSE)), the [model checkpoint](https://huggingface.co/nnInteractive/nnInteractive) is `Creative Commons Attribution Non Commercial Share Alike 4.0`!
+Note that while this repository is available under Apache-2.0 license (see [LICENSE](./LICENSE)), the [model checkpoint](https://huggingface.co/MIC-DKFZ/nnInteractive) is `Creative Commons Attribution Non Commercial Share Alike 4.0`!
 
 ______________________________________________________________________
 

{napari_nninteractive-2.3.2 → napari_nninteractive-2.4.2}/README.md

@@ -40,57 +40,68 @@ Extensive benchmarking demonstrates that nnInteractive far surpasses existing me
 
 ## Installation
 
-### Prerequisites
+`napari-nninteractive` installs as a **lightweight, torch-free remote client by default** — it can drive a remote `nninteractive-server` straight away, on any machine. **Local (in-process) inference is an opt-in extra** (`[local]`) that adds the full nnInteractive backend (PyTorch + nnU-Net) and needs an Nvidia GPU.
 
-For **local** inference you need a Linux or Windows computer with an Nvidia GPU. 10GB of VRAM is recommended. Small objects should work with \<6GB.
+| Mode | Install | PyTorch? | Hardware |
+|------|---------|----------|----------|
+| **Remote client** (default) | `pip install napari-nninteractive` | **No** (lightweight, torch-free) | anything — laptop, Mac, no GPU |
+| **Local inference** | `pip install "napari-nninteractive[local]"` (+ PyTorch) | **Yes** (large download) | Linux/Windows + Nvidia GPU — 10 GB VRAM recommended, \<6 GB works for small objects |
 
 > [!TIP]
-> **On a Mac, or without a capable Nvidia GPU?** Use [**Remote inference**](#remote-inference-server--client) instead. nnInteractive relies heavily on 3D convolutions, which are prohibitively slow on Apple Silicon (MPS) and CPU hardware — running the model on a remote GPU and driving it from napari is the recommended, and often only practical, way to use nnInteractive on these machines. The napari client itself has no GPU requirements and runs anywhere; only the GPU server needs the hardware above.
+> **On a Mac, or without a capable Nvidia GPU?** The default install is already exactly what you want — stop after Step 2. nnInteractive relies heavily on 3D convolutions, which are prohibitively slow on Apple Silicon (MPS) and CPU hardware, so running the model on a remote GPU and driving it from napari is the recommended, and often only practical, way to use it on these machines. See [Remote inference (server / client)](#remote-inference-server--client) for how to set up and connect to the server.
 
-##### 1. Create a virtual environment:
+### Step 1 — Create a virtual environment
 
-nnInteractive supports Python 3.10+ and works with Conda, pip, or any other virtual environment. Here’s an example using Conda:
+nnInteractive supports Python 3.10+ and works with Conda, pip, or any other virtual environment. Here's an example using Conda:
 
-```
+```bash
 conda create -n nnInteractive python=3.12
 conda activate nnInteractive
 ```
 
-##### 2. Install the correct PyTorch for your system
+Install napari if you don't already have it:
 
-Go to the [PyTorch homepage](https://pytorch.org/get-started/locally/) and pick the right configuration.
-Note that since recently PyTorch needs to be installed via pip. This is fine to do within your conda environment.
+```bash
+pip install napari[all]
+```
 
-For Ubuntu with a Nvidia GPU, pick 'stable', 'Linux', 'Pip', 'Python', 'CUDA12.6' (if all drivers are up to date, otherwise use and older version):
+### Step 2 — Install the plugin (remote client, torch-free)
 
-```
-pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126
+```bash
+pip install napari-nninteractive
 ```
 
-##### 3. Install this repository + dependencies via
+This is the **entire** install if you only drive a remote `nninteractive-server`: no PyTorch, no GPU required. The plugin starts in Remote mode — see [Remote inference (server / client)](#remote-inference-server--client) to connect.
 
-Install napari if necessary
+### Step 3 — (Optional) Enable local inference
+
+Only needed if **this** machine runs the model itself. Requires a Linux or Windows computer with an Nvidia GPU.
+
+**1. Install the correct PyTorch for your system.** Go to the [PyTorch homepage](https://pytorch.org/get-started/locally/) and pick the right configuration. PyTorch must be installed via pip nowadays, which is fine inside a conda environment. For Ubuntu with an Nvidia GPU, pick 'stable', 'Linux', 'Pip', 'Python', CUDA version does not matter (ensure your driver is up to date!). Then execute the command that is displayed, for example:
 
 ```bash
-pip install napari[all]
+pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126
 ```
 
-Install the plugin via pip:
+**2. Add the `[local]` extra** (pulls the full nnInteractive backend + nnU-Net):
 
 ```bash
-pip install napari-nninteractive
+pip install "napari-nninteractive[local]"
 ```
 
-Or clone and install this repository:
+Quote the brackets so your shell does not treat them as a glob (required in zsh / macOS). Model weights are downloaded automatically on first use; this can take a couple of minutes depending on your connection.
+
+You can do this at **any** time: if you started with the default client-only install and the **Local** switch in the plugin is greyed out, just run the command above (after installing PyTorch) and restart napari to unlock local inference.
+
+### Install from source (optional)
 
 ```bash
 git clone https://github.com/MIC-DKFZ/napari-nninteractive
 cd napari-nninteractive
-pip install -e .
+pip install -e .                 # remote client (torch-free) — the default
+pip install -e ".[local]"        # local inference — also install PyTorch first (see Step 3)
 ```
 
-**Note:** Model weights are automatically downloaded on first use. This can take up to a couple of minutes depending on your internet connection
-
 ## Getting Started
 
 Use one of these three options to start napari and activate the plugin.
@@ -155,6 +166,32 @@ Share the printed API key with your users via whatever channel you use for share
 
 The model checkpoint is fixed by the server at startup, so the local checkpoint selector is hidden in Remote mode.
 
+> [!NOTE]
+> The **default install is the torch-free client**, so unless you added the `[local]` extra
+> the plugin starts directly in Remote mode and the **Local** switch is greyed out. Hover the
+> switch (or read the one-line notice printed on start-up) for the reason and the exact
+> command. To unlock local inference, install PyTorch and the extra
+> (`pip install "napari-nninteractive[local]"`; see Step 3 of [Installation](#installation) above),
+> then restart napari.
+
+### …or run the server in Docker
+
+If you'd rather not install the backend on the GPU box, the server is also published as a Docker
+image with the model **baked in** (a GPU host with the
+[NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+is required):
+
+```bash
+docker run --gpus all -p 1527:1527 \
+    -e NN_INTERACTIVE_API_KEY="$(openssl rand -hex 32)" \
+    ghcr.io/mic-dkfz/nninteractive-server:latest
+```
+
+A `lite` tag is also available if you'd rather mount your own checkpoint folder at `/model` (or
+fetch a model by id at startup). See the backend
+[DOCKER.md](https://github.com/MIC-DKFZ/nnInteractive/blob/master/nnInteractive/inference/server/DOCKER.md)
+for both flavours and all configuration options.
+
 ### Things to be aware of
 
 - **Lost connection or idle timeout.** Server-side sessions are reaped after 10 minutes of inactivity (configurable on the server), and a server that goes away (restart, crash, network drop) ends the session too. When this happens the plugin resets the **Connect** button and asks you to reconnect. **Your current segmentation is preserved** on the client: after you reconnect and click **Initialize** again, the image is re-uploaded and the segmentation is restored so you can keep refining where you left off. Only the in-progress prompt markers (the individual points/boxes/scribbles) need to be redone.
@@ -175,7 +212,7 @@ Link: [![arXiv](https://img.shields.io/badge/arXiv-2503.08373-b31b1b.svg)](https
 
 # License
 
-Note that while this repository is available under Apache-2.0 license (see [LICENSE](./LICENSE)), the [model checkpoint](https://huggingface.co/nnInteractive/nnInteractive) is `Creative Commons Attribution Non Commercial Share Alike 4.0`!
+Note that while this repository is available under Apache-2.0 license (see [LICENSE](./LICENSE)), the [model checkpoint](https://huggingface.co/MIC-DKFZ/nnInteractive) is `Creative Commons Attribution Non Commercial Share Alike 4.0`!
 
 ______________________________________________________________________
 

{napari_nninteractive-2.3.2 → napari_nninteractive-2.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "napari-nninteractive"
-version = "2.3.2"
+version = "2.4.2"
 description = "nnInteractive plugin for Napari"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -26,17 +26,30 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "torch",
+    # The default install is the lightweight, torch-free REMOTE client: it can drive
+    # a remote nninteractive-server out of the box and pulls no PyTorch. For local
+    # inference install the [local] extra (see below / the README), which adds the
+    # full nnInteractive backend (torch + nnU-Net). pip extras can only ADD
+    # dependencies, never subtract, so local is the opt-in extra rather than
+    # something a remote-only user has to strip out of a torch-heavy base.
     "numpy",
     "qtpy",
     "napari-nifti",
-    "huggingface_hub",
-    "hf_transfer",
-    "nnInteractive>=2.4.0",
     "napari_toolkit",
+    # Torch-free remote client + shared wire protocol (pulls numpy/httpx/blosc2).
+    # Provides nnInteractive.inference.remote; the full nnInteractive package (added
+    # by [local]) depends on this same client, so the two coexist cleanly.
+    "nninteractive-client>=2.5.0",
 ]
 
 [project.optional-dependencies]
+# Local (in-process) inference. Adds the full nnInteractive backend, which pulls
+# PyTorch + nnU-Net and provides model discovery/download. On a GPU machine install
+# the matching CUDA build of torch first (see the README), then:
+#   pip install "napari-nninteractive[local]"
+local = [
+    "nnInteractive>=2.5.0",
+]
 testing = [
     "tox",
     "pytest",  # https://docs.pytest.org/en/latest/contents.html
@@ -45,9 +58,6 @@ testing = [
     "napari",
     "pyqt5",
 ]
-remote = [
-    "nnInteractive[client]>=2.4.0",
-]
 
 [project.entry-points."napari.manifest"]
 napari-nninteractive = "napari_nninteractive:napari.yaml"

{napari_nninteractive-2.3.2 → napari_nninteractive-2.4.2}/src/napari_nninteractive/layers/scribble_layer.py

@@ -48,7 +48,18 @@ class ScribbleLayer(BaseLayerClass, Labels):
         """
         Finalizes the current scribble interaction, updating the label index and marking the layer as free.
         """
-        self.data[self.data == 1] = self.prompt_index + 2
+        # Recolor the just-drawn stroke (value 1 -> committed prompt value) on the
+        # painted slice only. The stroke never spans more than the last painted slice
+        # (on_draw undoes any pending stroke before a new one, and _commit_staged_history
+        # records that slice), so this avoids scanning/writing the whole D×H×W volume.
+        if self._last_slice_id is not None:
+            idx = [slice(None)] * 3
+            idx[self._last_dim_not_displayed] = self._last_slice_id
+            slice_view = self.data[tuple(idx)]  # integer index on one axis -> a view
+            slice_view[slice_view == 1] = self.prompt_index + 2  # in-place, writes back to self.data
+        else:
+            # Defensive fallback: run is normally called only after a commit recorded a slice.
+            self.data[self.data == 1] = self.prompt_index + 2
         self._is_free = True
         self.refresh()
 

{napari_nninteractive-2.3.2 → napari_nninteractive-2.4.2}/src/napari_nninteractive/widget_controls.py

@@ -4,7 +4,6 @@ from pathlib import Path
 from typing import Any, Optional
 
 import numpy as np
-from huggingface_hub import snapshot_download
 from napari._qt.layer_controls.qt_layer_controls_container import layer_to_controls
 from napari.layers import Labels
 from napari.layers.base._base_constants import ActionType
@@ -233,22 +232,25 @@ class LayerControls(BaseGUI):
             self.checkpoint_path = None
             print(f"Using remote model at: {self.server_url_edit.text().strip()}")
         else:
-            model_name = self.model_selection.currentText()
             model_name_local = self.model_selection_local.text()
             if model_name_local != "" and Path(model_name_local).exists():
                 # Use Local Checkpoint
                 model_name = Path(model_name_local).name
                 self.checkpoint_path = model_name_local
             else:
-                # Download Checkpoint
-                repo_id = "nnInteractive/nnInteractive"
-                force_download = False
-                download_path = snapshot_download(
-                    repo_id=repo_id,
-                    allow_patterns=[f"{model_name}/*"],
-                    force_download=force_download,
-                )
-                self.checkpoint_path = Path(download_path).joinpath(model_name)
+                # Resolve the selected official model through the nnInteractive backend.
+                # It downloads the model on first use, reuses it afterwards, and works
+                # offline once a model has been downloaded.
+                from nnInteractive.model_management import ensure_model_available
+
+                idx = self.model_selection.currentIndex()
+                if idx < 0 or idx >= len(self._model_ids):
+                    raise ValueError(
+                        "No model selected. Pick a model from the dropdown or set a local "
+                        "checkpoint path."
+                    )
+                model_name = self._model_ids[idx]
+                self.checkpoint_path = ensure_model_available(model_name)
             print(f"Using Model {model_name} at : {self.checkpoint_path}")
 
         # --- DATA HANDLING --- #

{napari_nninteractive-2.3.2 → napari_nninteractive-2.4.2}/src/napari_nninteractive/widget_gui.py

@@ -1,3 +1,5 @@
+import importlib.util
+import warnings
 from typing import Optional
 
 from napari.layers import Image, Labels
@@ -24,6 +26,7 @@ from qtpy.QtWidgets import (
     QHBoxLayout,
     QLabel,
     QLineEdit,
+    QMessageBox,
     QShortcut,
     QSizePolicy,
     QVBoxLayout,
@@ -32,6 +35,47 @@ from qtpy.QtWidgets import (
 
 from napari_nninteractive._version_check import VersionChecker, _is_outdated
 
+# Shared wording for the Local tooltip, the start-up notice, and the dialog shown
+# when the user clicks the (greyed) Local switch. Kept as a reason + a how-to so the
+# dialog can present them as headline + details without repeating itself; the tooltip
+# and console print use the two joined. The lightweight ``nninteractive-client``
+# distribution is remote-only and torch-free; local inference lives in the full
+# ``nnInteractive`` package.
+_REMOTE_ONLY_REASON = (
+    "Local inference is unavailable: this is a remote-only (client-only) install "
+    "without the local nnInteractive backend, so only a remote nninteractive-server "
+    "can be used."
+)
+_ENABLE_LOCAL_STEPS = (
+    "To enable local inference (needs an Nvidia GPU):\n"
+    "  1. Install PyTorch yourself — it is NOT installed automatically. Pick the build "
+    "matching your GPU/CUDA from https://pytorch.org/get-started/locally/\n"
+    '  2. pip install "napari-nninteractive[local]"\n'
+    "then restart napari. See the README for details."
+)
+_REMOTE_ONLY_HINT = f"{_REMOTE_ONLY_REASON}\n{_ENABLE_LOCAL_STEPS}"
+
+
+def _local_inference_available() -> bool:
+    """Return True if local inference is installed.
+
+    The lightweight ``nninteractive-client`` ships only the remote client; the
+    local engine and its torch / nnU-Net stack live in the full ``nnInteractive``
+    package. We probe for the local inference module *without* importing torch:
+    ``find_spec`` only locates the module. In a client-only environment the full
+    package's last-resort meta-path finder raises ``ModuleNotFoundError`` here
+    (see ``nnInteractive.inference.remote._full_required``), which we treat as
+    "not available".
+    """
+    try:
+        return (
+            importlib.util.find_spec("nnInteractive.inference.inference_session") is not None
+        )
+    except ModuleNotFoundError:
+        return False
+    except Exception:  # noqa: BLE001 - never block the GUI on a capability probe
+        return False
+
 
 class BaseGUI(QWidget):
     """
@@ -49,9 +93,18 @@ class BaseGUI(QWidget):
         self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
         self._viewer = viewer
         self.session_cfg = None
-        self._remote_mode = False
+        # Whether local inference is installed. A remote-only
+        # 'nninteractive-client' install cannot run it, so we start in Remote
+        # mode and disable the Local controls (see _init_model_selection).
+        self._local_available = _local_inference_available()
+        self._remote_mode = not self._local_available
         self._settings = QSettings("MIC-DKFZ", "napari-nninteractive")
 
+        # Be transparent on start-up: tell remote-only users why local inference
+        # is off and how to enable it, so a missing Local button is never a mystery.
+        if not self._local_available:
+            print(f"[napari-nninteractive] {_REMOTE_ONLY_HINT}")
+
         _main_layout = QVBoxLayout()
         self.setLayout(_main_layout)
 
@@ -114,9 +167,14 @@ class BaseGUI(QWidget):
 
         self.version_status_label.setVisible(True)
         if outdated:
+            # Name only the package(s) actually behind PyPI, and build the upgrade
+            # command from those alone. A package whose installed version is newer
+            # than the latest release (e.g. a dev/unreleased build) is never listed,
+            # so we don't wrongly tell the user to "update" something already ahead.
+            names = ", ".join(outdated)
             self.version_status_label.setText(
-                "Update available. Please run:\n"
-                "pip install -U nnInteractive napari-nninteractive"
+                f"Update available for {names}. Please run:\n"
+                f"pip install -U {' '.join(outdated)}"
             )
             self.version_status_label.setStyleSheet("color: #e8830c; font-weight: bold;")  # orange
         else:
@@ -193,16 +251,29 @@ class BaseGUI(QWidget):
         """Initializes the model selection as a combo box."""
         _group_box, _layout = setup_vgroupbox(text="Model Selection:")
 
-        # Local | Remote mode switch
+        # Local | Remote mode switch. Start on Remote when local inference is not
+        # installed, since Local cannot be used in that case.
         self.mode_switch = setup_hswitch(
             _layout,
             options=["Local", "Remote"],
             function=self.on_mode_switched,
-            default=0,
+            default=0 if self._local_available else 1,
             fixed_color="rgb(0,100, 167)",
             tooltips="Run inference locally or on a remote nninteractive-server",
         )
 
+        # Remote-only install: local inference is not installed. Keep the Local
+        # button enabled — a *disabled* button swallows clicks and can show no
+        # feedback — but selecting it pops an explanatory dialog and snaps the
+        # switch back to Remote (handled in on_mode_switched). The tooltip explains
+        # why local is unavailable and how to enable it.
+        if not self._local_available:
+            self.mode_switch.buttons[0].setToolTip(_REMOTE_ONLY_HINT)
+            self.mode_switch.buttons[1].setToolTip(
+                "Run inference on a remote nninteractive-server"
+            )
+            self._grey_local_switch_button()
+
         # --- Local container --- #
         self.local_container = QWidget()
         _local_layout = QVBoxLayout()
@@ -210,11 +281,43 @@ class BaseGUI(QWidget):
         self.local_container.setLayout(_local_layout)
         _layout.addWidget(self.local_container)
 
-        model_options = ["nnInteractive_v1.0"]
+        # Populate the model dropdown from the nnInteractive backend manifest — the
+        # authoritative list of selectable official models, fetched from Hugging Face
+        # (remote-first) with an offline cache fallback. The dropdown shows display
+        # names; self._model_ids keeps the matching manifest ids by position. If the
+        # list can't be loaded at all, the dropdown is left empty and the user can
+        # still point to a local checkpoint below or switch to Remote mode.
+        self._model_ids: list[str] = []
+        model_display_names: list[str] = []
+        default_index = 0
+        # The model dropdown only drives local inference (in Remote mode the server
+        # picks the model), and model discovery lives in the full package. A
+        # remote-only install therefore skips loading the list entirely rather than
+        # triggering the full-package-required error.
+        if self._local_available:
+            try:
+                from nnInteractive.model_management import get_default_model_id, list_models
+
+                models = list_models()
+                self._model_ids = [m["id"] for m in models]
+                model_display_names = [m.get("display_name", m["id"]) for m in models]
+                default_id = get_default_model_id()
+                if default_id in self._model_ids:
+                    default_index = self._model_ids.index(default_id)
+            except Exception as exc:  # noqa: BLE001 - never block the GUI on model discovery
+                warnings.warn(
+                    f"Could not load the nnInteractive model list: {exc}", stacklevel=2
+                )
 
         self.model_selection = setup_combobox(
-            _local_layout, options=model_options, function=self.on_model_selected
+            _local_layout, options=model_display_names, function=self.on_model_selected
         )
+        if model_display_names:
+            # Select the manifest default without firing on_model_selected during init
+            # (the handler touches subclass state that isn't built yet).
+            self.model_selection.blockSignals(True)
+            self.model_selection.setCurrentIndex(default_index)
+            self.model_selection.blockSignals(False)
 
         _boxlayout = QHBoxLayout()
         _local_layout.addLayout(_boxlayout)
@@ -300,8 +403,13 @@ class BaseGUI(QWidget):
         self.remote_status_label.setWordWrap(True)
         _remote_layout.addWidget(self.remote_status_label)
 
-        # Default: Local visible, Remote hidden
-        self.remote_container.setVisible(False)
+        # Show the container for the active mode. A remote-only install starts in
+        # Remote mode; its Local controls are hidden and disabled (the menus that
+        # belong to the now-greyed Local button).
+        self.local_container.setVisible(not self._remote_mode)
+        self.remote_container.setVisible(self._remote_mode)
+        if not self._local_available:
+            self.local_container.setEnabled(False)
 
         # Restore last-used values (blocking signals so we don't trigger
         # on_model_selected / on_remote_settings_changed before the rest of
@@ -349,6 +457,31 @@ class BaseGUI(QWidget):
         _group_box.setLayout(_layout)
         return _group_box
 
+    def _grey_local_switch_button(self) -> None:
+        """Lightly grey the Local switch button so it reads as unavailable while
+        staying clickable (clicking it explains how to enable local inference).
+
+        The switch resets each button's stylesheet whenever it toggles, so this is
+        re-applied after switch changes (see on_mode_switched).
+        """
+        self.mode_switch.buttons[0].setStyleSheet("color: gray;")
+
+    def _show_local_unavailable_dialog(self) -> None:
+        """Explain why Local is unavailable and how to enable local inference.
+
+        Shown when the user clicks the greyed (but still clickable) Local switch.
+        Deliberately offers no one-click install: the correct PyTorch build depends
+        on the user's GPU/CUDA and must be installed manually first (see the steps).
+        """
+        box = QMessageBox(self)
+        box.setIcon(QMessageBox.Information)
+        box.setWindowTitle("Local inference not installed")
+        box.setText(_REMOTE_ONLY_REASON)
+        box.setInformativeText(_ENABLE_LOCAL_STEPS)
+        box.addButton(QMessageBox.Close)
+        box.setDefaultButton(QMessageBox.Close)
+        box.exec()
+
     def _init_image_selection(self) -> QGroupBox:
         """Initializes the image selection combo box in a group box."""
         _group_box, _layout = setup_vgroupbox(text="Image Selection:")