Sync from GitHub Actions (skip png)

.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.gradio/
+flagged/
+else/
+data/
+.devcontainer/

README.md

@@ -4,7 +4,7 @@ emoji: 🧠
 colorFrom: indigo
 colorTo: blue
 sdk: gradio
-sdk_version: 5.25.1
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 tags:
@@ -12,12 +12,13 @@ tags:
   - registration
   - pystackreg
 ---
+
 # 🧠 Stack Image Registration Web App  
 A web-based application for image stack registration powered by **Gradio** and **pystackreg**.  
 This tool allows users to align and stabilize multi-frame TIFF images using a variety of transformation models.
 
 <p align="center">
-    <img src="images/app.png" height="500">
+    <img src="https://raw.githubusercontent.com/qchapp/pystackreg-app/master/images/app.png" height="500">
 </p>
 
 ---
@@ -122,6 +123,106 @@ https://huggingface.co/spaces/qchapp/pystackreg-app?file_url_1=https://github.co
 
 ---
 
+## 🤖 MCP Server
+
+This app doubles as a **Model Context Protocol (MCP) server**, exposing the three core registration workflows as callable MCP tools that any MCP-compatible client (e.g. Claude Desktop, GitHub Copilot in VS Code) can invoke programmatically.
+
+### Running the app as an MCP server
+
+```sh
+python app.py
+```
+
+The human-facing Gradio UI is available at [http://localhost:7860](http://localhost:7860) as usual.  
+The MCP endpoint is available at:
+
+- **MCP server**: `http://localhost:7860/gradio_api/mcp/sse`
+- **MCP schema**: `http://localhost:7860/gradio_api/mcp/schema`
+
+### Available MCP tools
+
+#### 1. `align_stack_to_reference`
+Align every frame in a TIFF stack to a chosen reference frame (intra-stack alignment).
+
+| Argument | Type | Default | Description |
+|---|---|---|---|
+| `stack_file` | `str` | — | Path to the input TIFF stack |
+| `reference_index` | `int` | `0` | Zero-based index of the reference frame inside the stack |
+| `mode` | `str` | `"RIGID_BODY"` | Transformation mode (see below) |
+| `external_reference_file` | `str \| None` | `None` | Optional path to an external reference TIFF stack |
+| `external_reference_index` | `int` | `0` | Frame index inside the external reference stack |
+
+**Returns**: path to the aligned output TIFF file.
+
+**Example arguments:**
+```json
+{
+  "stack_file": "/data/pc12-unreg.tif",
+  "reference_index": 0,
+  "mode": "RIGID_BODY"
+}
+```
+
+---
+
+#### 2. `align_stack_to_stack`
+Align every frame in a moving TIFF stack to the first frame of a reference TIFF stack.
+
+| Argument | Type | Default | Description |
+|---|---|---|---|
+| `reference_stack_file` | `str` | — | Path to the reference TIFF stack |
+| `moving_stack_file` | `str` | — | Path to the moving TIFF stack |
+| `mode` | `str` | `"RIGID_BODY"` | Transformation mode (see below) |
+
+**Returns**: path to the aligned output TIFF file.
+
+**Example arguments:**
+```json
+{
+  "reference_stack_file": "/data/pc12-unreg.tif",
+  "moving_stack_file": "/data/pc12-reg-translation.tif",
+  "mode": "TRANSLATION"
+}
+```
+
+---
+
+#### 3. `align_frame_to_frame`
+Align a single moving frame to a reference frame within the same TIFF stack.
+
+| Argument | Type | Default | Description |
+|---|---|---|---|
+| `stack_file` | `str` | — | Path to the TIFF stack containing both frames |
+| `reference_index` | `int` | — | Zero-based index of the reference frame |
+| `moving_index` | `int` | — | Zero-based index of the frame to align |
+| `mode` | `str` | `"RIGID_BODY"` | Transformation mode (see below) |
+
+**Returns**: path to the aligned single-frame output TIFF file.
+
+**Example arguments:**
+```json
+{
+  "stack_file": "/data/pc12-unreg.tif",
+  "reference_index": 0,
+  "moving_index": 5,
+  "mode": "AFFINE"
+}
+```
+
+---
+
+### Supported transformation modes
+
+| Mode | Description |
+|---|---|
+| `TRANSLATION` | Translation only (x/y shift) |
+| `RIGID_BODY` | Translation + rotation (default) |
+| `SCALED_ROTATION` | Translation + rotation + uniform scaling |
+| `AFFINE` | Full affine transformation |
+| `BILINEAR` | Bilinear (non-linear) transformation |
+
+---
+
 ### 📚 Credits
 
 - **App Author**: [Quentin Chappuis](https://github.com/qchapp)  

app.py

@@ -1,116 +1,162 @@
 import gradio as gr
-import numpy as np
 from PIL import Image
-from pystackreg import StackReg
-import imageio.v2 as iio
 import tifffile
 import tempfile
-import urllib.request
 import os
+from typing import Optional
 
 from core.utils import (
-    get_sr_mode, normalize_stack, upscale, load_stack,
-    _is_demo_url, _demo_path_for_url,
+    WORK_DIR, DEMO_DIR, upscale, load_stack,
     _start_cleaner, citation_markdown, documentation_markdown
 )
+from core.registration import (
+    align_stack_to_reference,
+    align_stack_to_stack,
+    align_frame_to_frame,
+    _run_align_to_reference,
+    _run_align_to_stack,
+    _resolve_path,
+)
 
 _start_cleaner()
 
-# Globals
-original_frames, aligned_frames = [], []
-ref_frames, mov_frames, reg_frames = [], [], []
-custom_stack, reg_result = [], None
+def _stage_for_backend(src: str) -> str:
+    """Return a sandbox-safe path for *src*.
+
+    Files already in WORK_DIR or DEMO_DIR are returned as-is. Files that
+    Gradio placed in its own upload staging area are hard-linked into WORK_DIR
+    (zero-copy on the same filesystem) so the backend sandbox accepts them.
+    Falls back to a regular copy if the hard link fails (cross-device).
+    """
+    import shutil
+    real = os.path.realpath(src)
+    sandboxes = (os.path.realpath(WORK_DIR), os.path.realpath(DEMO_DIR))
+    if any(real == s or real.startswith(s + os.sep) for s in sandboxes):
+        return src
+    suffix = os.path.splitext(src)[-1] or ".tif"
+    fd, dst = tempfile.mkstemp(suffix=suffix, dir=WORK_DIR)
+    os.close(fd)
+    os.unlink(dst)  # remove placeholder so os.link can create the entry
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+    return dst
 
-# Reset functions
 def reset_intra_stack():
-    global original_frames, aligned_frames
-    original_frames, aligned_frames = [], []
     return [None, gr.update(value=0, minimum=0, maximum=0), None, gr.update(value=0, minimum=0, maximum=0),
-            None, gr.update(value=0, minimum=0, maximum=0), None, gr.update(value=0, minimum=0, maximum=0), None]
+            None, gr.update(value=0, minimum=0, maximum=0), None, gr.update(value=0, minimum=0, maximum=0), None,
+            None, None]
 
 def reset_reference_based():
-    global ref_frames, mov_frames, reg_frames
-    ref_frames, mov_frames, reg_frames = [], [], []
     return [None, None, None, gr.update(value=0, minimum=0, maximum=0),
-            None, gr.update(value=0, minimum=0, maximum=0), None]
+            None, gr.update(value=0, minimum=0, maximum=0), None,
+            None, None]
 
 def reset_frame_to_frame():
-    global custom_stack, reg_result
-    custom_stack, reg_result = [], None
     return [None, gr.update(value=0, minimum=0, maximum=0),
             gr.update(value=0, minimum=0, maximum=0), None, None]
 
-# Registration logic
+# Registration logic — UI wrappers that call the pure backend functions
 def intra_stack_align(f, ref_idx, ext_file, ext_idx, mode):
-    global original_frames, aligned_frames
-    stack = load_stack(f)
-    original_frames = [Image.fromarray(fr) for fr in stack]
-    sr = StackReg(get_sr_mode(mode))
-
-    ref = load_stack(ext_file)[ext_idx] if ext_file else stack[ref_idx]
-    aligned = [sr.register_transform(ref, fr) for fr in stack]
-    aligned = normalize_stack(np.stack(aligned))
-    aligned_frames = [upscale(Image.fromarray(fr)) for fr in aligned]
-
-    path = tempfile.NamedTemporaryFile(suffix=".tif", delete=False).name
-    tifffile.imwrite(path, aligned, photometric='minisblack')
-
+    if not f:
+        raise gr.Error("Please upload a TIFF stack before running alignment.")
+    f = _stage_for_backend(f)
+    # Load and normalise once — reused for both the UI preview and registration
+    orig_stack = load_stack(f)
+    fd, orig_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(orig_path, orig_stack, photometric="minisblack")
+    n_orig = len(orig_stack)
+
+    if ext_file:
+        ref_frame = load_stack(_stage_for_backend(ext_file))[int(ext_idx)]
+    else:
+        ref_frame = orig_stack[int(ref_idx)]
+    aligned = _run_align_to_reference(orig_stack, ref_frame, mode)
+
+    fd, path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(path, aligned, photometric="minisblack")
     return (
-        original_frames[0], gr.update(value=0, maximum=len(original_frames)-1),
-        aligned_frames[0], gr.update(value=0, maximum=len(aligned_frames)-1), path
+        Image.fromarray(orig_stack[0]), gr.update(value=0, maximum=n_orig - 1),
+        upscale(Image.fromarray(aligned[0])), gr.update(value=0, maximum=len(aligned) - 1), path,
+        orig_path, path,
     )
 
 def reference_align(ref_file, mov_file, mode):
-    global ref_frames, mov_frames, reg_frames
+    if not ref_file:
+        raise gr.Error("Please upload a reference stack.")
+    if not mov_file:
+        raise gr.Error("Please upload a moving stack.")
+    ref_file = _stage_for_backend(ref_file)
+    mov_file = _stage_for_backend(mov_file)
+    # Load both stacks once — reference reused for preview and registration
     ref_stack = load_stack(ref_file)
     mov_stack = load_stack(mov_file)
-    ref_frames = [Image.fromarray(f) for f in ref_stack]
-    mov_frames = [Image.fromarray(f) for f in mov_stack]
+    fd, ref_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(ref_path, ref_stack, photometric="minisblack")
+    n_ref = len(ref_stack)
 
-    sr = StackReg(get_sr_mode(mode))
-    aligned = [sr.register_transform(ref_stack[0], f) for f in mov_stack]
-    aligned = normalize_stack(np.stack(aligned))
-    reg_frames = [upscale(Image.fromarray(f)) for f in aligned]
+    aligned = _run_align_to_stack(ref_stack, mov_stack, mode)
 
-    path = tempfile.NamedTemporaryFile(suffix=".tif", delete=False).name
-    tifffile.imwrite(path, aligned, photometric='minisblack')
-    return ref_frames[0], gr.update(value=0, maximum=len(ref_frames)-1), \
-           reg_frames[0], gr.update(value=0, maximum=len(reg_frames)-1), path
+    fd, path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(path, aligned, photometric="minisblack")
+    return (
+        Image.fromarray(ref_stack[0]), gr.update(value=0, maximum=n_ref - 1),
+        upscale(Image.fromarray(aligned[0])), gr.update(value=0, maximum=len(aligned) - 1), path,
+        ref_path, path,
+    )
 
 def frame_to_frame_align(file, ref_idx, mov_idx, mode):
-    global custom_stack, reg_result
-    stack = load_stack(file)
-    custom_stack = [Image.fromarray(f) for f in stack]
-
-    sr = StackReg(get_sr_mode(mode))
-    aligned = sr.register_transform(stack[ref_idx], stack[mov_idx])
-    aligned = normalize_stack(np.stack([aligned]))[0]
-    reg_result = Image.fromarray(aligned)
-
-    path = tempfile.NamedTemporaryFile(suffix=".tif", delete=False).name
-    tifffile.imwrite(path, aligned[np.newaxis, ...], photometric='minisblack')
-    return reg_result, path
-
-# URL loading
-def load_from_url(request: gr.Request):
-    params = request.query_params
-    if "file_url" in params:
-        try:
-            url = params["file_url"]
-            if _is_demo_url(url):
-                tmp_path = _demo_path_for_url(url)
-                if not os.path.exists(tmp_path):
-                    urllib.request.urlretrieve(url, tmp_path)
-            else:
-                tmp_path = tempfile.mktemp(suffix=".tif")  # goes to WORK_DIR
-                urllib.request.urlretrieve(url, tmp_path)
-            return [gr.update(value=tmp_path)]
-        except Exception as e:
-            print(f"[URL load failed] {e}")
-    return [None]
+    if not file:
+        raise gr.Error("Please upload a TIFF stack before running alignment.")
+    file = _stage_for_backend(file)
+    # Delegate to pure backend
+    path = align_frame_to_frame(
+        stack_file=file,
+        reference_index=int(ref_idx),
+        moving_index=int(mov_idx),
+        mode=mode,
+    )
+
+    # Load aligned frame for UI preview (already normalised — read raw to avoid double-normalisation)
+    result_stack = tifffile.imread(path)
+    return Image.fromarray(result_stack[0]), path
+
+def _read_frame(path, idx, scale=False):
+    """Read a single frame from a TIFF file by index, return a PIL Image."""
+    if not path:
+        return None
+    try:
+        frame = tifffile.imread(path, key=int(idx))
+        img = Image.fromarray(frame)
+        return upscale(img) if scale else img
+    except Exception:
+        return None
+
+def _count_frames(path: str) -> int:
+    """Return the number of frames in a TIFF file without loading pixel data."""
+    if not path or not os.path.exists(path):
+        return 0
+    try:
+        with tifffile.TiffFile(path) as tf:
+            return len(tf.pages)
+    except Exception as exc:
+        raise gr.Error("Unable to read the uploaded TIFF file. Please upload a valid, non-corrupt TIFF stack.") from exc
 
 # Interface
 with gr.Blocks() as demo:
+    # Per-session state — one independent copy per connected user.
+    # Avoids the shared-globals race condition where concurrent users
+    # would overwrite each other's frame lists and see wrong previews.
+    original_path_state = gr.State(None)
+    aligned_path_state = gr.State(None)
+    ref_path_state = gr.State(None)
+    reg_path_state = gr.State(None)
+
     gr.Markdown("# 🧠 Pystackreg Web Application")
     gr.Markdown(citation_markdown)
 
@@ -131,7 +177,7 @@ with gr.Blocks() as demo:
         )
 
         with gr.Row():
-            ref_slider = gr.Slider(label="Reference Frame (from uploaded stack)", minimum=0, maximum=0, value=0, step=1, visible=True)
+            reference_frame_slider = gr.Slider(label="Reference Frame (from uploaded stack)", minimum=0, maximum=0, value=0, step=1, visible=True)
             ext_ref_file = gr.File(label="Upload External Reference Stack (.tif)", visible=False)
             ext_ref_slider = gr.Slider(label="Reference Frame (from external stack)", minimum=0, maximum=0, value=0, step=1, visible=False)
 
@@ -142,13 +188,15 @@ with gr.Blocks() as demo:
                 gr.update(visible=v)
             ),
             use_ext_ref,
-            [ref_slider, ext_ref_file, ext_ref_slider]
+            [reference_frame_slider, ext_ref_file, ext_ref_slider],
+            show_api=False,
         )
 
         ext_ref_file.change(
-            lambda f: gr.update(value=0, maximum=len(iio.mimread(f)) - 1) if f else gr.update(value=0, maximum=0),
+            lambda f: gr.update(value=0, maximum=_count_frames(f) - 1) if f else gr.update(value=0, maximum=0),
             ext_ref_file,
-            ext_ref_slider
+            ext_ref_slider,
+            show_api=False,
         )
 
         with gr.Row():
@@ -156,7 +204,7 @@ with gr.Blocks() as demo:
             mode_dropdown = gr.Dropdown(["TRANSLATION", "RIGID_BODY", "SCALED_ROTATION", "AFFINE", "BILINEAR"],
                                         value="RIGID_BODY", visible=False, label="Transformation Mode")
 
-        show_adv.change(lambda v: gr.update(visible=v), show_adv, mode_dropdown)
+        show_adv.change(lambda v: gr.update(visible=v), show_adv, mode_dropdown, show_api=False)
         run_btn = gr.Button("▶️ Align Stack")
 
         with gr.Row():
@@ -170,28 +218,37 @@ with gr.Blocks() as demo:
         download = gr.File(label="Download")
 
         file_input.change(
-            lambda f: gr.update(value=0, maximum=len(iio.mimread(f)) - 1) if f else gr.update(value=0, maximum=0),
+            lambda f: gr.update(value=0, maximum=_count_frames(f) - 1) if f else gr.update(value=0, maximum=0),
             file_input,
-            ref_slider
+            reference_frame_slider,
+            show_api=False,
         )
 
         run_btn.click(
             intra_stack_align,
-            [file_input, ref_slider, ext_ref_file, ext_ref_slider, mode_dropdown],
-            [original_image, original_slider, aligned_image, aligned_slider, download]
+            [file_input, reference_frame_slider, ext_ref_file, ext_ref_slider, mode_dropdown],
+            [original_image, original_slider, aligned_image, aligned_slider, download,
+             original_path_state, aligned_path_state],
+            show_api=False,
         )
 
-        original_slider.change(lambda i: original_frames[i] if 0 <= i < len(original_frames) else None,
-                               original_slider, original_image)
-        aligned_slider.change(lambda i: aligned_frames[i] if 0 <= i < len(aligned_frames) else None,
-                              aligned_slider, aligned_image)
+        original_slider.change(
+            lambda i, path: _read_frame(path, i, scale=False),
+            [original_slider, original_path_state], original_image, show_api=False,
+        )
+        aligned_slider.change(
+            lambda i, path: _read_frame(path, i, scale=True),
+            [aligned_slider, aligned_path_state], aligned_image, show_api=False,
+        )
 
         gr.Button("🔄 Reset Tab").click(
             reset_intra_stack,
             outputs=[
-                file_input, ref_slider, ext_ref_file, ext_ref_slider,
-                original_image, original_slider, aligned_image, aligned_slider, download
-            ]
+                file_input, reference_frame_slider, ext_ref_file, ext_ref_slider,
+                original_image, original_slider, aligned_image, aligned_slider, download,
+                original_path_state, aligned_path_state,
+            ],
+            show_api=False,
         )
 
     with gr.Tab("🎯 Stack-Based Alignment"):
@@ -215,7 +272,7 @@ with gr.Blocks() as demo:
             mode_dropdown_ref = gr.Dropdown(["TRANSLATION", "RIGID_BODY", "SCALED_ROTATION", "AFFINE", "BILINEAR"],
                                             value="RIGID_BODY", visible=False, label="Transformation Mode")
 
-        show_adv_ref.change(lambda v: gr.update(visible=v), show_adv_ref, mode_dropdown_ref)
+        show_adv_ref.change(lambda v: gr.update(visible=v), show_adv_ref, mode_dropdown_ref, show_api=False)
         ref_btn = gr.Button("▶️ Register")
 
         with gr.Row():
@@ -223,19 +280,32 @@ with gr.Blocks() as demo:
             reg_image = gr.Image(label="Registered Frame")
 
         with gr.Row():
-            ref_slider = gr.Slider(label="Browse Ref", minimum=0, maximum=0, value=0, step=1)
+            stack_ref_browse_slider = gr.Slider(label="Browse Ref", minimum=0, maximum=0, value=0, step=1)
             reg_slider = gr.Slider(label="Browse Reg", minimum=0, maximum=0, value=0, step=1)
 
         download_ref = gr.File(label="Download")
 
-        ref_btn.click(reference_align, [ref_input, mov_input, mode_dropdown_ref],
-                      [ref_image, ref_slider, reg_image, reg_slider, download_ref])
-        ref_slider.change(lambda i: ref_frames[i] if 0 <= i < len(ref_frames) else None, ref_slider, ref_image)
-        reg_slider.change(lambda i: reg_frames[i] if 0 <= i < len(reg_frames) else None, reg_slider, reg_image)
+        ref_btn.click(
+            reference_align,
+            [ref_input, mov_input, mode_dropdown_ref],
+            [ref_image, stack_ref_browse_slider, reg_image, reg_slider, download_ref,
+             ref_path_state, reg_path_state],
+            show_api=False,
+        )
+        stack_ref_browse_slider.change(
+            lambda i, path: _read_frame(path, i, scale=False),
+            [stack_ref_browse_slider, ref_path_state], ref_image, show_api=False,
+        )
+        reg_slider.change(
+            lambda i, path: _read_frame(path, i, scale=True),
+            [reg_slider, reg_path_state], reg_image, show_api=False,
+        )
 
         gr.Button("🔄 Reset Tab").click(
             reset_reference_based,
-            outputs=[ref_input, mov_input, ref_image, ref_slider, reg_image, reg_slider, download_ref]
+            outputs=[ref_input, mov_input, ref_image, stack_ref_browse_slider, reg_image, reg_slider, download_ref,
+                     ref_path_state, reg_path_state],
+            show_api=False,
         )
 
     with gr.Tab("🧩 Frame-to-Frame Alignment"):
@@ -258,28 +328,118 @@ with gr.Blocks() as demo:
             mode_dropdown_ftf = gr.Dropdown(["TRANSLATION", "RIGID_BODY", "SCALED_ROTATION", "AFFINE", "BILINEAR"],
                                             value="RIGID_BODY", visible=False, label="Transformation Mode")
 
-        show_adv_ftf.change(lambda v: gr.update(visible=v), show_adv_ftf, mode_dropdown_ftf)
+        show_adv_ftf.change(lambda v: gr.update(visible=v), show_adv_ftf, mode_dropdown_ftf, show_api=False)
         frame_btn = gr.Button("▶️ Register Frame")
         frame_output = gr.Image(label="Registered Output")
         download_ftf = gr.File(label="Download")
 
         frame_file.change(
-            lambda f: [gr.update(value=0, maximum=len(iio.mimread(f)) - 1)] * 2 if f else [gr.update(value=0, maximum=0)] * 2,
-            frame_file, [ref_idx, mov_idx]
+            lambda f: [gr.update(value=0, maximum=_count_frames(f) - 1)] * 2 if f else [gr.update(value=0, maximum=0)] * 2,
+            frame_file, [ref_idx, mov_idx],
+            show_api=False,
         )
 
-        frame_btn.click(frame_to_frame_align,
-                        [frame_file, ref_idx, mov_idx, mode_dropdown_ftf],
-                        [frame_output, download_ftf])
+        frame_btn.click(
+            frame_to_frame_align,
+            [frame_file, ref_idx, mov_idx, mode_dropdown_ftf],
+            [frame_output, download_ftf],
+            show_api=False,
+        )
 
         gr.Button("🔄 Reset Tab").click(
             reset_frame_to_frame,
-            outputs=[frame_file, ref_idx, mov_idx, frame_output, download_ftf]
+            outputs=[frame_file, ref_idx, mov_idx, frame_output, download_ftf],
+            show_api=False,
         )
 
-    @demo.load(
-        outputs=[file_input, ref_slider, frame_file, ref_idx, mov_idx, ref_input, mov_input]
-    )
+    # ---------------------------------------------------------------------------
+    # MCP / API-only endpoints — thin wrappers that return the output file path
+    # as a plain string so Gradio/MCP can serve it correctly.
+    # ---------------------------------------------------------------------------
+    def _mcp_align_stack_to_reference(
+        stack_file: str,
+        reference_index: int = 0,
+        mode: str = "RIGID_BODY",
+        external_reference_file: Optional[str] = None,
+        external_reference_index: int = 0,
+    ) -> str:
+        """Align every frame in a TIFF stack to a chosen reference frame.
+
+        Each frame in stack_file is registered to the selected reference frame
+        using the chosen transformation model. The reference frame can come from
+        the same stack or from a separate external TIFF stack.
+
+        Args:
+            stack_file: Path or HTTP/HTTPS URL to the input TIFF stack.
+            reference_index: Zero-based index of the reference frame inside
+                stack_file (ignored when external_reference_file is provided).
+                Default is 0.
+            mode: Transformation model. One of: TRANSLATION, RIGID_BODY,
+                SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+            external_reference_file: Optional path or URL to an external TIFF
+                stack from which the reference frame is taken.
+            external_reference_index: Zero-based index of the reference frame
+                inside external_reference_file. Default is 0.
+
+        Returns:
+            The aligned output TIFF file.
+        """
+        out = align_stack_to_reference(
+            stack_file, reference_index, mode,
+            external_reference_file, external_reference_index,
+        )
+        return out
+
+    def _mcp_align_stack_to_stack(
+        reference_stack_file: str,
+        moving_stack_file: str,
+        mode: str = "RIGID_BODY",
+    ) -> str:
+        """Align every frame in a moving TIFF stack to the first frame of a reference stack.
+
+        Args:
+            reference_stack_file: Path or HTTP/HTTPS URL to the reference TIFF
+                stack. Its first frame is used as the alignment target.
+            moving_stack_file: Path or HTTP/HTTPS URL to the moving TIFF stack
+                to align.
+            mode: Transformation model. One of: TRANSLATION, RIGID_BODY,
+                SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+
+        Returns:
+            The aligned output TIFF file.
+        """
+        out = align_stack_to_stack(reference_stack_file, moving_stack_file, mode)
+        return out
+
+    def _mcp_align_frame_to_frame(
+        stack_file: str,
+        reference_index: int,
+        moving_index: int,
+        mode: str = "RIGID_BODY",
+    ) -> str:
+        """Align a single moving frame to a reference frame within the same TIFF stack.
+
+        Args:
+            stack_file: Path or HTTP/HTTPS URL to the TIFF stack containing both
+                frames.
+            reference_index: Zero-based index of the reference frame.
+            moving_index: Zero-based index of the frame to align.
+            mode: Transformation model. One of: TRANSLATION, RIGID_BODY,
+                SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+
+        Returns:
+            The aligned single-frame output TIFF file.
+        """
+        out = align_frame_to_frame(stack_file, reference_index, moving_index, mode)
+        return out
+
+    gr.api(fn=_mcp_align_stack_to_reference, api_name="align_stack_to_reference")
+    gr.api(fn=_mcp_align_stack_to_stack, api_name="align_stack_to_stack")
+    gr.api(fn=_mcp_align_frame_to_frame, api_name="align_frame_to_frame")
+
+    # ---------------------------------------------------------------------------
+    # Page-load handler (UI only — not an MCP tool)
+    # ---------------------------------------------------------------------------
     def load_from_query(request: gr.Request):
         params = request.query_params
         results = [None] * 7  # 7 outputs
@@ -287,19 +447,12 @@ with gr.Blocks() as demo:
         # One-stack file case (for ref-based + frame-to-frame)
         if "file_url" in params:
             try:
-                url = params["file_url"]
-                if _is_demo_url(url):
-                    tmp_path = _demo_path_for_url(url)
-                    if not os.path.exists(tmp_path):
-                        urllib.request.urlretrieve(url, tmp_path)
-                else:
-                    tmp_path = tempfile.mktemp(suffix=".tif")  # goes to WORK_DIR
-                    urllib.request.urlretrieve(url, tmp_path)
-                stack = iio.mimread(tmp_path)
-                max_frame = len(stack) - 1
+                tmp_path = _resolve_path(params["file_url"], "file_url")
+                with tifffile.TiffFile(tmp_path) as tf:
+                    max_frame = len(tf.pages) - 1
 
                 results[0] = tmp_path  # file_input
-                results[1] = gr.update(value=0, maximum=max_frame)  # ref_slider
+                results[1] = gr.update(value=0, maximum=max_frame)  # reference_frame_slider
                 results[2] = tmp_path  # frame_file
                 results[3] = gr.update(value=0, maximum=max_frame)  # ref_idx
                 results[4] = gr.update(value=1 if max_frame >= 1 else 0, maximum=max_frame)  # mov_idx
@@ -310,32 +463,19 @@ with gr.Blocks() as demo:
         # Two-stack file case (for stack-based alignment)
         if "file_url_1" in params and "file_url_2" in params:
             try:
-                u1, u2 = params["file_url_1"], params["file_url_2"]
-
-                if _is_demo_url(u1):
-                    tmp_path_1 = _demo_path_for_url(u1)
-                    if not os.path.exists(tmp_path_1):
-                        urllib.request.urlretrieve(u1, tmp_path_1)
-                else:
-                    tmp_path_1 = tempfile.mktemp(suffix=".tif")  # goes to WORK_DIR
-                    urllib.request.urlretrieve(u1, tmp_path_1)
-
-                if _is_demo_url(u2):
-                    tmp_path_2 = _demo_path_for_url(u2)
-                    if not os.path.exists(tmp_path_2):
-                        urllib.request.urlretrieve(u2, tmp_path_2)
-                else:
-                    tmp_path_2 = tempfile.mktemp(suffix=".tif")  # goes to WORK_DIR
-                    urllib.request.urlretrieve(u2, tmp_path_2)
-
-                results[5] = tmp_path_1  # ref_input
-                results[6] = tmp_path_2  # mov_input
+                results[5] = _resolve_path(params["file_url_1"], "file_url_1")  # ref_input
+                results[6] = _resolve_path(params["file_url_2"], "file_url_2")  # mov_input
             except Exception as e:
                 print(f"[Error loading file_url_1 or file_url_2] {e}")
 
         return results
 
+    demo.load(
+        load_from_query,
+        outputs=[file_input, reference_frame_slider, frame_file, ref_idx, mov_idx, ref_input, mov_input],
+        show_api=False,
+    )
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(mcp_server=True)

core/registration.py

@@ -0,0 +1,361 @@
+"""
+Pure backend registration functions for pystackreg-app.
+
+These functions implement the three image-registration workflows as
+file-based, MCP-friendly operations. They take TIFF file paths as inputs
+and return the path to the output TIFF file. No Gradio objects are returned.
+
+Gradio MCP uses function names, type hints, and docstrings to build MCP
+tool schemas, so all three are kept clear and complete.
+"""
+
+import ipaddress
+import os
+import socket
+import tempfile
+import urllib.parse
+import urllib.request
+from typing import Optional
+
+import numpy as np
+import tifffile
+from pystackreg import StackReg
+
+from core.utils import WORK_DIR, DEMO_DIR, get_sr_mode, load_stack, normalize_stack
+
+# ---------------------------------------------------------------------------
+# Validation helpers
+# ---------------------------------------------------------------------------
+
+VALID_MODES = {"TRANSLATION", "RIGID_BODY", "SCALED_ROTATION", "AFFINE", "BILINEAR"}
+
+# Maximum size allowed for HTTP downloads (prevents resource-exhaustion attacks).
+_MAX_DOWNLOAD_BYTES = 500 * 1024 * 1024  # 500 MB
+_DOWNLOAD_TIMEOUT = 30  # seconds
+
+# Valid TIFF magic byte sequences (little/big-endian classic and BigTIFF).
+_TIFF_MAGIC = (
+    b"II\x2A\x00",  # little-endian TIFF
+    b"MM\x00\x2A",  # big-endian TIFF
+    b"II\x2B\x00",  # little-endian BigTIFF
+    b"MM\x00\x2B",  # big-endian BigTIFF
+)
+
+
+def _block_private_url(url: str) -> None:
+    """Raise ValueError if *url* resolves to a private, loopback, link-local,
+    reserved, or multicast address (SSRF protection)."""
+    parsed = urllib.parse.urlparse(url)
+    host = parsed.hostname
+    if not host:
+        raise ValueError(f"Could not parse host from URL: {url!r}")
+    try:
+        infos = socket.getaddrinfo(host, None)
+    except socket.gaierror as exc:
+        raise ValueError(f"Could not resolve host '{host}': {exc}") from exc
+    for info in infos:
+        addr_str = info[4][0]
+        try:
+            addr = ipaddress.ip_address(addr_str)
+        except ValueError:
+            continue
+        if (
+            addr.is_private
+            or addr.is_loopback
+            or addr.is_link_local
+            or addr.is_reserved
+            or addr.is_multicast
+            or addr.is_unspecified
+        ):
+            raise ValueError(
+                f"Requests to private or internal addresses are not allowed "
+                f"('{host}' resolved to {addr})."
+            )
+
+
+class _SafeRedirectHandler(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        _block_private_url(newurl)
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_SAFE_URL_OPENER = urllib.request.build_opener(_SafeRedirectHandler)
+
+
+def _download_tiff_to_work_dir(url: str, label: str) -> str:
+    """Download *url* to a temp file in WORK_DIR, validating TIFF magic and size.
+
+    Uses chunked streaming so that the full file is never held in memory.
+    Raises ValueError on SSRF, size-limit, or magic-byte failures.
+    Cleans up the temp file before raising on any error.
+    """
+    _block_private_url(url)
+
+    fd, local_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+
+    total = 0
+    first4 = b""
+
+    try:
+        with _SAFE_URL_OPENER.open(url, timeout=_DOWNLOAD_TIMEOUT) as resp, open(local_path, "wb") as f:
+            _block_private_url(resp.geturl())
+            while True:
+                chunk = resp.read(1024 * 1024)
+                if not chunk:
+                    break
+
+                if len(first4) < 4:
+                    first4 = (first4 + chunk[: 4 - len(first4)])[:4]
+                    if len(first4) == 4 and not any(first4.startswith(magic) for magic in _TIFF_MAGIC):
+                        raise ValueError(f"{label} does not appear to be a valid TIFF file.")
+
+                total += len(chunk)
+                if total > _MAX_DOWNLOAD_BYTES:
+                    raise ValueError(
+                        f"{label} exceeds the maximum allowed download size of "
+                        f"{_MAX_DOWNLOAD_BYTES // (1024 * 1024)} MB."
+                    )
+
+                f.write(chunk)
+
+        if total == 0:
+            raise ValueError(f"{label} is empty.")
+
+        if len(first4) < 4 or not any(first4.startswith(magic) for magic in _TIFF_MAGIC):
+            raise ValueError(f"{label} does not appear to be a valid TIFF file.")
+
+        return local_path
+
+    except Exception:
+        try:
+            os.unlink(local_path)
+        except FileNotFoundError:
+            pass
+        raise
+
+
+def _resolve_path(path_or_url: str, label: str = "file") -> str:
+    """Return a local, sandbox-safe path for *path_or_url*.
+
+    - If the value starts with ``http://`` or ``https://``, the file is
+      downloaded to WORK_DIR and the local path is returned. This is the
+      intended flow for MCP clients, which cannot upload files directly.
+    - Otherwise the value is treated as a local path and must resolve within
+      the app sandbox enforced by _require_file(): WORK_DIR (for outputs from
+      previous tool calls) or DEMO_DIR (for cached demo files).
+    """
+    if path_or_url.startswith(("http://", "https://")):
+        return _download_tiff_to_work_dir(path_or_url, label)
+    _require_file(path_or_url, label)
+    return path_or_url
+
+
+def _validate_mode(mode: str) -> None:
+    """Raise ValueError if *mode* is not a supported transformation mode."""
+    if mode not in VALID_MODES:
+        raise ValueError(
+            f"Invalid transformation mode '{mode}'. "
+            f"Must be one of: {', '.join(sorted(VALID_MODES))}."
+        )
+
+
+def _validate_index(idx: int, stack_len: int, name: str = "frame index") -> None:
+    """Raise IndexError if *idx* is outside [0, stack_len)."""
+    if not (0 <= idx < stack_len):
+        raise IndexError(
+            f"{name} {idx} is out of range for a stack with {stack_len} frame(s) "
+            f"(valid range: 0 to {stack_len - 1})."
+        )
+
+
+def _require_file(path: str, label: str = "file") -> None:
+    """Raise an error if *path* does not exist or is outside the app's sandbox.
+
+    Allowed locations are WORK_DIR (outputs from previous tool calls, enabling
+    tool chaining) and DEMO_DIR (cached demo files). Symlinks are resolved
+    first to prevent traversal attacks.
+
+    Remote MCP clients should pass HTTP/HTTPS URLs; _resolve_path() downloads
+    them to WORK_DIR automatically.
+    """
+    real = os.path.realpath(path)
+    sandboxes = (os.path.realpath(WORK_DIR), os.path.realpath(DEMO_DIR))
+    if not any(real == s or real.startswith(s + os.sep) for s in sandboxes):
+        raise ValueError(
+            f"{label} must be an HTTP/HTTPS URL or a path returned by a previous "
+            "tool call. Pass a URL and it will be downloaded automatically."
+        )
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"{label} not found: {path}")
+
+
+# ---------------------------------------------------------------------------
+# Private computation helpers (array-in / array-out, no file I/O)
+# ---------------------------------------------------------------------------
+
+def _run_align_to_reference(
+    stack: np.ndarray, ref_frame: np.ndarray, mode: str
+) -> np.ndarray:
+    """Register every frame in *stack* against *ref_frame*. Returns normalised uint8 array."""
+    sr = StackReg(get_sr_mode(mode))
+    return normalize_stack(np.stack([sr.register_transform(ref_frame, fr) for fr in stack]))
+
+
+def _run_align_to_stack(
+    ref_stack: np.ndarray, mov_stack: np.ndarray, mode: str
+) -> np.ndarray:
+    """Register every frame in *mov_stack* against the first frame of *ref_stack*.
+    Returns normalised uint8 array."""
+    sr = StackReg(get_sr_mode(mode))
+    return normalize_stack(np.stack([sr.register_transform(ref_stack[0], fr) for fr in mov_stack]))
+
+
+# ---------------------------------------------------------------------------
+# Public backend functions (exposed as MCP tools)
+# ---------------------------------------------------------------------------
+
+
+def align_stack_to_reference(
+    stack_file: str,
+    reference_index: int = 0,
+    mode: str = "RIGID_BODY",
+    external_reference_file: Optional[str] = None,
+    external_reference_index: int = 0,
+) -> str:
+    """
+    Align every frame in a TIFF stack to a chosen reference frame (intra-stack alignment).
+
+    Each frame in *stack_file* is registered to the selected reference frame using
+    the chosen transformation model. The reference frame can come from the same
+    stack or from a separate external TIFF stack.
+
+    Args:
+        stack_file: Path to the input TIFF stack whose frames will be aligned.
+        reference_index: Zero-based index of the reference frame inside
+            *stack_file* (ignored when *external_reference_file* is provided).
+            Default is 0.
+        mode: Transformation model for registration. One of: TRANSLATION,
+            RIGID_BODY, SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+        external_reference_file: Optional path to an external TIFF stack from
+            which the reference frame is taken. When provided, *reference_index*
+            is ignored and *external_reference_index* is used instead.
+        external_reference_index: Zero-based index of the reference frame inside
+            *external_reference_file*. Default is 0.
+
+    Returns:
+        Path to the aligned output TIFF file (same number of frames as input).
+
+    Raises:
+        FileNotFoundError: If *stack_file* or *external_reference_file* does not
+            exist on disk.
+        IndexError: If *reference_index* or *external_reference_index* is out of
+            range for the corresponding stack.
+        ValueError: If *mode* is not one of the supported transformation modes.
+    """
+    _validate_mode(mode)
+    stack_file = _resolve_path(stack_file, "stack_file")
+
+    stack = load_stack(stack_file)
+
+    if external_reference_file is not None:
+        external_reference_file = _resolve_path(external_reference_file, "external_reference_file")
+        ext_stack = load_stack(external_reference_file)
+        _validate_index(external_reference_index, len(ext_stack), "external_reference_index")
+        ref_frame = ext_stack[external_reference_index]
+    else:
+        _validate_index(reference_index, len(stack), "reference_index")
+        ref_frame = stack[reference_index]
+
+    aligned = _run_align_to_reference(stack, ref_frame, mode)
+
+    fd, out_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(out_path, aligned, photometric="minisblack")
+    return out_path
+
+
+def align_stack_to_stack(
+    reference_stack_file: str,
+    moving_stack_file: str,
+    mode: str = "RIGID_BODY",
+) -> str:
+    """
+    Align every frame in a moving TIFF stack to the first frame of a reference TIFF stack.
+
+    All frames in *moving_stack_file* are registered against the first frame of
+    *reference_stack_file* using the specified transformation model.
+
+    Args:
+        reference_stack_file: Path to the reference TIFF stack. Its first frame
+            is used as the alignment target for all frames in the moving stack.
+        moving_stack_file: Path to the moving TIFF stack to align.
+        mode: Transformation model for registration. One of: TRANSLATION,
+            RIGID_BODY, SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+
+    Returns:
+        Path to the aligned output TIFF file (same number of frames as the
+        moving stack).
+
+    Raises:
+        FileNotFoundError: If *reference_stack_file* or *moving_stack_file* does
+            not exist on disk.
+        ValueError: If *mode* is not one of the supported transformation modes.
+    """
+    _validate_mode(mode)
+    reference_stack_file = _resolve_path(reference_stack_file, "reference_stack_file")
+    moving_stack_file = _resolve_path(moving_stack_file, "moving_stack_file")
+
+    ref_stack = load_stack(reference_stack_file)
+    mov_stack = load_stack(moving_stack_file)
+
+    aligned = _run_align_to_stack(ref_stack, mov_stack, mode)
+
+    fd, out_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(out_path, aligned, photometric="minisblack")
+    return out_path
+
+
+def align_frame_to_frame(
+    stack_file: str,
+    reference_index: int,
+    moving_index: int,
+    mode: str = "RIGID_BODY",
+) -> str:
+    """
+    Align a single moving frame to a reference frame within the same TIFF stack.
+
+    Registers the frame at *moving_index* against the frame at *reference_index*
+    inside *stack_file* and writes the result as a single-frame TIFF.
+
+    Args:
+        stack_file: Path to the TIFF stack that contains both frames.
+        reference_index: Zero-based index of the reference frame within the stack.
+        moving_index: Zero-based index of the frame to align (the moving frame).
+        mode: Transformation model for registration. One of: TRANSLATION,
+            RIGID_BODY, SCALED_ROTATION, AFFINE, BILINEAR. Default is RIGID_BODY.
+
+    Returns:
+        Path to the aligned output TIFF file (single-frame TIFF).
+
+    Raises:
+        FileNotFoundError: If *stack_file* does not exist on disk.
+        IndexError: If *reference_index* or *moving_index* is out of range for
+            the stack.
+        ValueError: If *mode* is not one of the supported transformation modes.
+    """
+    _validate_mode(mode)
+    stack_file = _resolve_path(stack_file, "stack_file")
+
+    stack = load_stack(stack_file)
+    _validate_index(reference_index, len(stack), "reference_index")
+    _validate_index(moving_index, len(stack), "moving_index")
+
+    sr = StackReg(get_sr_mode(mode))
+    aligned = normalize_stack(np.stack([sr.register_transform(stack[reference_index], stack[moving_index])]))[0]
+
+    fd, out_path = tempfile.mkstemp(suffix=".tif", dir=WORK_DIR)
+    os.close(fd)
+    tifffile.imwrite(out_path, aligned[np.newaxis, ...], photometric="minisblack")
+    return out_path

core/utils.py

@@ -22,7 +22,10 @@ def normalize_stack(stack):
         f = frame.astype(np.float32)
         low, high = np.percentile(f, (1, 99))
         f = np.clip(f, low, high)
-        f = (f - f.min()) / (np.ptp(f) + 1e-8) * 255 if np.ptp(f) > 0 else np.zeros_like(f)
+        fmin = f.min()
+        fmax = f.max()
+        rng = fmax - fmin
+        f = (f - fmin) / (rng + 1e-8) * 255 if rng > 0 else np.zeros_like(f)
         norm_stack.append(f.astype(np.uint8))
     return np.stack(norm_stack)
 
@@ -45,9 +48,6 @@ DEMO_DIR = os.path.join(APP_TMP_ROOT, "demo")   # persistent demo cache
 os.makedirs(WORK_DIR, exist_ok=True)
 os.makedirs(DEMO_DIR, exist_ok=True)
 
-# Direct all tempfile.* calls to WORK_DIR so cleanup is safe
-tempfile.tempdir = WORK_DIR
-
 TTL_SECONDS = 30 * 60  # 30 minutes
 
 def _cleanup_old_files(folder, older_than_seconds):
@@ -152,6 +152,6 @@ documentation_markdown = """
 
         ### 🧠 Credits
 
-        App developed by **Quentin Chapuis**  
+        App developed by **Quentin Chappuis**  
         Library: [`pystackreg`](https://github.com/glichtner/pystackreg) by **Georg Lichtenberg**
         """

requirements.txt

@@ -1,4 +1,4 @@
-gradio==5.25.1
-pystackreg
-tifffile
-imageio
+gradio[mcp]==5.49.1
+pystackreg==0.2.8
+tifffile==2025.3.30
+imageio==2.37.0