mcp-server-senseca-pro 0.1.0__tar.gz

mcp_server_senseca_pro-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: mcp-server-senseca-pro
+Version: 0.1.0
+Summary: Unofficial MCP server for Senseca PRO 111 / PRO 115 Pt100 thermometers
+Keywords: mcp,senseca,pt100,thermometer,serial
+Author: shaag7967
+Author-email: shaag7967 <shaag@gmx.net>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Hardware
+Requires-Dist: mcp>=2.3.0
+Requires-Dist: pyserial>=3.5
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/shaag7967/mcp-server-senseca-pro
+Project-URL: Issues, https://github.com/shaag7967/mcp-server-senseca-pro/issues
+Project-URL: Changelog, https://github.com/shaag7967/mcp-server-senseca-pro/releases
+Description-Content-Type: text/markdown
+
+# mcp-server-senseca-pro
+
+An [MCP](https://modelcontextprotocol.io) server that lets AI assistants read live measurements
+from a **Senseca PRO 111 / PRO 115** handheld Pt100 thermometer connected via USB.
+
+> Unofficial project, not affiliated with or endorsed by Senseca.
+> Tested with a PRO 111, firmware V1.4.3.0, interface protocol V1.0.0.1.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `read_temperature` | Current temperature with unit (°C/°F/K, as set on the instrument) and UTC timestamp |
+| `read_resistance` | Current Pt100 resistance in ohm |
+| `sample_temperature` | Readings over a period (max 600 s, interval ≥ 0.5 s) with min/max/mean/stdev |
+| `get_device_info` | Model, serial number, firmware, instrument clock, battery level |
+
+With `--allow-write` two more tools are available:
+
+| Tool | Description |
+|---|---|
+| `set_device_clock` | Set the instrument clock (default: this computer's time) |
+| `set_location_name` | Rename one of the 20 location labels |
+
+The server cannot change calibration or adjustment data; the instrument does not offer that
+over its serial interface.
+
+## Requirements
+
+- Python ≥ 3.10 and [uv](https://docs.astral.sh/uv/)
+- The instrument switched on and connected via USB-C. On the PRO 115 set
+  *Settings → USB mode* to **COM interface**.
+- **Linux:** your user must be in the `dialout` group (`sudo usermod -aG dialout $USER`, then log in again).
+- **Windows / macOS:** no extra setup; the port shows up as `COMx` or `/dev/cu.usbmodem…`.
+
+## Configuration
+
+### Claude Code
+
+```bash
+claude mcp add senseca-pro -- uvx mcp-server-senseca-pro
+```
+
+### Claude Desktop and other clients
+
+```json
+{
+  "mcpServers": {
+    "senseca-pro": {
+      "command": "uvx",
+      "args": ["mcp-server-senseca-pro"]
+    }
+  }
+}
+```
+
+### Options
+
+| Option | Environment variable | Default |
+|---|---|---|
+| `--port PORT` | `SENSECA_PORT` | auto-detect |
+| `--allow-write` | `SENSECA_ALLOW_WRITE=1` | off |
+| `--log-level LEVEL` | `SENSECA_LOG_LEVEL` | `WARNING` |
+| — | `SENSECA_PIN` | none; needed only if the instrument's protected mode is on |
+
+Auto-detection looks for USB ID `0483:5740` and only accepts a port whose device reports
+manufacturer `senseca`. If several instruments are connected, set the port explicitly; on Linux
+prefer the stable `/dev/serial/by-id/…` path.
+
+Only one program can use the serial port at a time. Close ProXware or terminal programs while
+the server is running.
+
+## Measurement notes
+
+- Instrument accuracy: ±0.05 °C or ±0.06 % of reading (whichever is higher) ±1 digit, probe not included.
+- The USB port is **not galvanically isolated**. With a probe touching a grounded medium, the
+  USB connection can shift the reading. Compare readings with and without USB, and use a USB
+  isolator if they differ (see the instrument manual, section 7.2).
+
+## Development
+
+```bash
+uv sync
+uv run pytest                                   # tests use a simulated instrument
+npx @modelcontextprotocol/inspector uv run mcp-server-senseca-pro   # try the tools interactively
+```
+
+The serial protocol is described in [docs/protocol.md](https://github.com/shaag7967/mcp-server-senseca-pro/blob/main/docs/protocol.md).
+
+## License
+
+MIT
+
+<!-- mcp-name: io.github.shaag7967/mcp-server-senseca-pro -->

mcp_server_senseca_pro-0.1.0/README.md

@@ -0,0 +1,94 @@
+# mcp-server-senseca-pro
+
+An [MCP](https://modelcontextprotocol.io) server that lets AI assistants read live measurements
+from a **Senseca PRO 111 / PRO 115** handheld Pt100 thermometer connected via USB.
+
+> Unofficial project, not affiliated with or endorsed by Senseca.
+> Tested with a PRO 111, firmware V1.4.3.0, interface protocol V1.0.0.1.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `read_temperature` | Current temperature with unit (°C/°F/K, as set on the instrument) and UTC timestamp |
+| `read_resistance` | Current Pt100 resistance in ohm |
+| `sample_temperature` | Readings over a period (max 600 s, interval ≥ 0.5 s) with min/max/mean/stdev |
+| `get_device_info` | Model, serial number, firmware, instrument clock, battery level |
+
+With `--allow-write` two more tools are available:
+
+| Tool | Description |
+|---|---|
+| `set_device_clock` | Set the instrument clock (default: this computer's time) |
+| `set_location_name` | Rename one of the 20 location labels |
+
+The server cannot change calibration or adjustment data; the instrument does not offer that
+over its serial interface.
+
+## Requirements
+
+- Python ≥ 3.10 and [uv](https://docs.astral.sh/uv/)
+- The instrument switched on and connected via USB-C. On the PRO 115 set
+  *Settings → USB mode* to **COM interface**.
+- **Linux:** your user must be in the `dialout` group (`sudo usermod -aG dialout $USER`, then log in again).
+- **Windows / macOS:** no extra setup; the port shows up as `COMx` or `/dev/cu.usbmodem…`.
+
+## Configuration
+
+### Claude Code
+
+```bash
+claude mcp add senseca-pro -- uvx mcp-server-senseca-pro
+```
+
+### Claude Desktop and other clients
+
+```json
+{
+  "mcpServers": {
+    "senseca-pro": {
+      "command": "uvx",
+      "args": ["mcp-server-senseca-pro"]
+    }
+  }
+}
+```
+
+### Options
+
+| Option | Environment variable | Default |
+|---|---|---|
+| `--port PORT` | `SENSECA_PORT` | auto-detect |
+| `--allow-write` | `SENSECA_ALLOW_WRITE=1` | off |
+| `--log-level LEVEL` | `SENSECA_LOG_LEVEL` | `WARNING` |
+| — | `SENSECA_PIN` | none; needed only if the instrument's protected mode is on |
+
+Auto-detection looks for USB ID `0483:5740` and only accepts a port whose device reports
+manufacturer `senseca`. If several instruments are connected, set the port explicitly; on Linux
+prefer the stable `/dev/serial/by-id/…` path.
+
+Only one program can use the serial port at a time. Close ProXware or terminal programs while
+the server is running.
+
+## Measurement notes
+
+- Instrument accuracy: ±0.05 °C or ±0.06 % of reading (whichever is higher) ±1 digit, probe not included.
+- The USB port is **not galvanically isolated**. With a probe touching a grounded medium, the
+  USB connection can shift the reading. Compare readings with and without USB, and use a USB
+  isolator if they differ (see the instrument manual, section 7.2).
+
+## Development
+
+```bash
+uv sync
+uv run pytest                                   # tests use a simulated instrument
+npx @modelcontextprotocol/inspector uv run mcp-server-senseca-pro   # try the tools interactively
+```
+
+The serial protocol is described in [docs/protocol.md](https://github.com/shaag7967/mcp-server-senseca-pro/blob/main/docs/protocol.md).
+
+## License
+
+MIT
+
+<!-- mcp-name: io.github.shaag7967/mcp-server-senseca-pro -->

mcp_server_senseca_pro-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "mcp-server-senseca-pro"
+version = "0.1.0"
+description = "Unofficial MCP server for Senseca PRO 111 / PRO 115 Pt100 thermometers"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = [
+    "mcp",
+    "senseca",
+    "pt100",
+    "thermometer",
+    "serial",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering",
+    "Topic :: System :: Hardware",
+]
+dependencies = [
+    "mcp>=2.3.0",
+    "pyserial>=3.5",
+]
+
+[[project.authors]]
+name = "shaag7967"
+email = "shaag@gmx.net"
+
+[project.urls]
+Repository = "https://github.com/shaag7967/mcp-server-senseca-pro"
+Issues = "https://github.com/shaag7967/mcp-server-senseca-pro/issues"
+Changelog = "https://github.com/shaag7967/mcp-server-senseca-pro/releases"
+
+[project.scripts]
+mcp-server-senseca-pro = "mcp_server_senseca_pro:main"
+
+[build-system]
+requires = ["uv_build>=0.12.24,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=9.2.0"]

mcp_server_senseca_pro-0.1.0/pyproject.toml.orig

@@ -0,0 +1,45 @@
+[project]
+name = "mcp-server-senseca-pro"
+version = "0.1.0"
+description = "Unofficial MCP server for Senseca PRO 111 / PRO 115 Pt100 thermometers"
+readme = "README.md"
+authors = [
+    { name = "shaag7967", email = "shaag@gmx.net" }
+]
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["mcp", "senseca", "pt100", "thermometer", "serial"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering",
+    "Topic :: System :: Hardware",
+]
+dependencies = [
+    "mcp>=2.3.0",
+    "pyserial>=3.5",
+]
+
+[project.urls]
+Repository = "https://github.com/shaag7967/mcp-server-senseca-pro"
+Issues = "https://github.com/shaag7967/mcp-server-senseca-pro/issues"
+Changelog = "https://github.com/shaag7967/mcp-server-senseca-pro/releases"
+
+[project.scripts]
+mcp-server-senseca-pro = "mcp_server_senseca_pro:main"
+
+[build-system]
+requires = ["uv_build>=0.12.24,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0",
+]

mcp_server_senseca_pro-0.1.0/src/mcp_server_senseca_pro/__init__.py

@@ -0,0 +1,5 @@
+"""MCP server for Senseca PRO 111 / PRO 115 Pt100 thermometers."""
+
+from .server import main
+
+__all__ = ["main"]

mcp_server_senseca_pro-0.1.0/src/mcp_server_senseca_pro/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+main()

mcp_server_senseca_pro-0.1.0/src/mcp_server_senseca_pro/device.py

@@ -0,0 +1,274 @@
+"""Serial driver for Senseca PRO 111 / PRO 115 Pt100 thermometers.
+
+The instrument shows up as a USB CDC virtual COM port (115200 8N1). Commands are
+ASCII lines of the form ``Command: argument`` terminated by CRLF; every reply is
+one or more CRLF-terminated lines followed by an empty line.
+
+This module does not depend on MCP so it can be used and tested on its own.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import threading
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Callable, Protocol
+
+import serial
+from serial.tools import list_ports
+
+log = logging.getLogger(__name__)
+
+BAUDRATE = 115200
+# Generic STMicroelectronics Virtual COM Port ID. Many other devices use it too,
+# so candidates are only accepted after the manufacturer query answers "senseca".
+USB_VID = 0x0483
+USB_PID = 0x5740
+
+REPLY_TERMINATOR = b"\r\n\r\n"
+
+# Channel layout observed on PRO 111 firmware V1.4.3.0.
+BATTERY_CHANNEL = (0, None)
+RESISTANCE_CHANNEL = (1, None)
+TEMPERATURE_CHANNEL = (1, 1)
+
+# The serial interface relocks after 2 minutes without commands; resend the PIN before that.
+PIN_REFRESH_S = 90.0
+
+_RANGE_STATES = {"underflow", "overflow"}
+_DATETIME_RE = re.compile(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})(?:\.(\d+))?")
+
+
+class DeviceError(Exception):
+    """Base class for all errors raised by this module."""
+
+
+class DeviceNotFoundError(DeviceError):
+    pass
+
+
+class CommandError(DeviceError):
+    """The instrument answered with ``error: ...``."""
+
+
+class OutOfRangeError(DeviceError):
+    """The instrument reported Underflow/Overflow, e.g. no probe connected."""
+
+
+class SerialLike(Protocol):
+    def write(self, data: bytes) -> int | None: ...
+    def read_until(self, expected: bytes = ..., size: int | None = ...) -> bytes: ...
+    def reset_input_buffer(self) -> None: ...
+    def reset_output_buffer(self) -> None: ...
+    def close(self) -> None: ...
+
+
+Opener = Callable[[str], SerialLike]
+
+
+def _open_serial(port: str) -> serial.Serial:
+    return serial.Serial(port, BAUDRATE, timeout=2.0, write_timeout=2.0, exclusive=True)
+
+
+@dataclass(frozen=True)
+class Reading:
+    value: float
+    unit: str
+    timestamp: datetime
+
+    def as_dict(self) -> dict[str, Any]:
+        return {"value": self.value, "unit": self.unit, "timestamp": self.timestamp.isoformat()}
+
+
+class Pro11x:
+    """Thread-safe connection to one PRO 11x instrument.
+
+    The port is opened lazily and reopened once if a command fails because the
+    device was unplugged or switched off in the meantime.
+    """
+
+    def __init__(self, port: str | None = None, pin: str | None = None, opener: Opener = _open_serial):
+        self._port = port
+        # An auto-detected port is searched again after a disconnect, since the
+        # instrument may come back under a different device name.
+        self._auto_detect = port is None
+        self._pin = f"{int(pin):04d}" if pin else None
+        self._opener = opener
+        self._conn: SerialLike | None = None
+        self._lock = threading.Lock()
+        self._last_command: float | None = None  # monotonic time, None = nothing sent yet
+
+    @property
+    def port(self) -> str | None:
+        return self._port
+
+    def close(self) -> None:
+        with self._lock:
+            self._disconnect()
+
+    def __enter__(self) -> Pro11x:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    # -- low level -----------------------------------------------------------
+
+    def query(self, command: str) -> list[str]:
+        """Send one command and return the non-empty reply lines."""
+        with self._lock:
+            try:
+                return self._query_locked(command)
+            except serial.SerialTimeoutException as e:
+                # The port is fine but the firmware does not take data; reopening will not help.
+                self._disconnect()
+                raise DeviceError(
+                    f"Instrument on {self._port} does not respond. Check that it is switched on; "
+                    "if it is, unplug and reconnect the USB cable."
+                ) from e
+            except (serial.SerialException, OSError) as e:
+                log.warning("Serial error (%s), reconnecting", e)
+                self._disconnect()
+                try:
+                    return self._query_locked(command)
+                except (serial.SerialException, OSError) as e2:
+                    self._disconnect()
+                    raise DeviceError(f"Communication with {self._port} failed: {e2}") from e2
+
+    def _query_locked(self, command: str) -> list[str]:
+        conn = self._connect()
+        if self._pin and (self._last_command is None or time.monotonic() - self._last_command > PIN_REFRESH_S):
+            self._exchange(conn, f"setPINCode: {self._pin}")
+        return self._exchange(conn, command)
+
+    def _exchange(self, conn: SerialLike, command: str) -> list[str]:
+        conn.reset_input_buffer()
+        conn.write(command.encode("ascii") + b"\r\n")
+        raw = conn.read_until(REPLY_TERMINATOR)
+        self._last_command = time.monotonic()
+        if not raw.endswith(REPLY_TERMINATOR):
+            raise DeviceError(f"Timeout waiting for reply to {command!r} (got {raw!r})")
+        lines = [line.strip() for line in raw.decode("utf-8", errors="replace").splitlines()]
+        lines = [line for line in lines if line]
+        if lines and lines[0].lower().startswith("error:"):
+            raise CommandError(f"{command!r}: {lines[0][6:].strip()}")
+        return lines
+
+    def _connect(self) -> SerialLike:
+        if self._conn is None:
+            if self._port is None:
+                self._port = find_port(self._opener)
+            log.info("Opening %s", self._port)
+            try:
+                self._conn = self._opener(self._port)
+            except (serial.SerialException, OSError) as e:
+                raise DeviceNotFoundError(f"Cannot open {self._port}: {e}") from e
+            self._last_command = None
+        return self._conn
+
+    def _disconnect(self) -> None:
+        if self._conn is not None:
+            try:
+                # Drop unsent data, otherwise close() blocks up to 30 s (tty closing_wait).
+                self._conn.reset_output_buffer()
+                self._conn.close()
+            except Exception:
+                pass
+            self._conn = None
+        if self._auto_detect:
+            self._port = None
+
+    def _single(self, command: str) -> str:
+        lines = self.query(command)
+        if not lines:
+            raise DeviceError(f"Empty reply to {command!r}")
+        return lines[0]
+
+    # -- commands ------------------------------------------------------------
+
+    @staticmethod
+    def _channel_arg(channel: int, sub: int | None) -> str:
+        return f"{channel}" if sub is None else f"{channel}, {sub}"
+
+    def value(self, channel: int, sub: int | None = None) -> float:
+        """Latest measured value of a channel in full resolution."""
+        text = self._single(f"GetFullResolutionValue: {self._channel_arg(channel, sub)}")
+        if text.lower() in _RANGE_STATES:
+            raise OutOfRangeError(f"Measurement {text} (probe missing, broken or out of range)")
+        try:
+            return float(text)
+        except ValueError:
+            raise DeviceError(f"Unexpected measurement reply: {text!r}") from None
+
+    def unit(self, channel: int, sub: int | None = None) -> str:
+        return self._single(f"GetChannelUnit: {self._channel_arg(channel, sub)}")
+
+    def reading(self, channel: int, sub: int | None = None) -> Reading:
+        return Reading(self.value(channel, sub), self.unit(channel, sub), datetime.now(timezone.utc))
+
+    def temperature(self) -> Reading:
+        return self.reading(*TEMPERATURE_CHANNEL)
+
+    def resistance(self) -> Reading:
+        return self.reading(*RESISTANCE_CHANNEL)
+
+    def battery(self) -> Reading:
+        return self.reading(*BATTERY_CHANNEL)
+
+    def manufacturer(self) -> str:
+        return self._single("GetDeviceManufacturer: 0")
+
+    def device_information(self) -> dict[str, str]:
+        info: dict[str, str] = {}
+        for line in self.query("GetDeviceInformation: 0"):
+            key, sep, value = line.partition(":")
+            if sep:
+                info[key.strip().strip('"')] = value.strip().strip('"')
+        return info
+
+    def get_datetime(self) -> datetime:
+        """Instrument clock (the instrument keeps UTC)."""
+        text = self._single("GetDateTime: 0")
+        m = _DATETIME_RE.search(text)
+        if not m:
+            raise DeviceError(f"Unexpected date/time reply: {text!r}")
+        # Pad the fraction ("08.55") to microseconds; Python 3.10 only parses 3 or 6 digits.
+        fraction = (m.group(2) or "").ljust(6, "0")[:6]
+        return datetime.fromisoformat(f"{m.group(1)}.{fraction}").replace(tzinfo=timezone.utc)
+
+    def set_datetime(self, when: datetime) -> list[str]:
+        utc = when.astimezone(timezone.utc) if when.tzinfo else when
+        return self.query(f"SetDateTime: {utc:%Y-%m-%d %H:%M:%S}")
+
+    def update_location(self, index: int, name: str) -> list[str]:
+        if not 1 <= index <= 20:
+            raise ValueError("Location index must be 1..20")
+        if len(name) > 16 or not name.isascii() or any(c in name for c in "\r\n"):
+            raise ValueError("Location name must be at most 16 ASCII characters on one line")
+        return self.query(f"updateLocation: {index}, {name}")
+
+
+def find_port(opener: Opener = _open_serial) -> str:
+    """Return the first serial port that answers like a Senseca instrument."""
+    candidates = [p.device for p in list_ports.comports() if p.vid == USB_VID and p.pid == USB_PID]
+    if not candidates:
+        raise DeviceNotFoundError(
+            "No Senseca instrument found. Check the USB cable, that the instrument is on, "
+            "and set SENSECA_PORT if auto-detection does not work."
+        )
+    problems = []
+    for device in candidates:
+        probe = Pro11x(device, opener=opener)
+        try:
+            manufacturer = probe.manufacturer()
+            if manufacturer.lower() == "senseca":
+                return device
+            problems.append(f"{device}: manufacturer is {manufacturer!r}")
+        except DeviceError as e:
+            problems.append(str(e))
+        finally:
+            probe.close()
+    raise DeviceNotFoundError("No Senseca instrument answered. " + " ".join(problems))

mcp_server_senseca_pro-0.1.0/src/mcp_server_senseca_pro/server.py

@@ -0,0 +1,165 @@
+"""MCP server exposing a Senseca PRO 111 / PRO 115 thermometer."""
+
+import argparse
+import logging
+import os
+import statistics
+import sys
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from importlib.metadata import version
+from typing import Any
+
+from mcp.server.mcpserver import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
+from mcp_types import ToolAnnotations
+
+from .device import DeviceError, Pro11x
+
+log = logging.getLogger(__name__)
+
+ACCURACY = "±0.05 °C or ±0.06 % of reading (whichever is higher) ±1 digit, instrument only"
+MIN_INTERVAL_S = 0.5  # the instrument measures 2 times per second
+MAX_DURATION_S = 600.0
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, idempotent_hint=True, open_world_hint=False)
+WRITES_DEVICE = ToolAnnotations(read_only_hint=False, destructive_hint=False, open_world_hint=False)
+
+INSTRUCTIONS = """\
+Access to a Senseca PRO 111/115 handheld thermometer with a 4-wire Pt100 probe, connected via USB.
+Readings are live values from the physical instrument. The temperature unit follows the instrument
+setting (°C, °F or K) and is always returned with the value. The instrument updates twice per second.
+"""
+
+
+@contextmanager
+def _device_errors() -> Iterator[None]:
+    # Only ToolError messages reach the model; anything else shows up as a bare crash.
+    try:
+        yield
+    except (DeviceError, ValueError) as e:
+        raise ToolError(str(e)) from e
+
+
+def create_server(device: Pro11x, allow_write: bool = False) -> MCPServer:
+    mcp = MCPServer(
+        name="senseca-pro",
+        title="Senseca PRO 111/115 thermometer",
+        version=version("mcp-server-senseca-pro"),
+        instructions=INSTRUCTIONS,
+    )
+
+    @mcp.tool(annotations=READ_ONLY)
+    def read_temperature() -> dict[str, Any]:
+        """Read the current temperature from the Pt100 probe, with unit and UTC timestamp."""
+        with _device_errors():
+            return device.temperature().as_dict() | {"accuracy": ACCURACY}
+
+    @mcp.tool(annotations=READ_ONLY)
+    def read_resistance() -> dict[str, Any]:
+        """Read the current Pt100 probe resistance in ohm (about 100 ohm at 0 °C)."""
+        with _device_errors():
+            return device.resistance().as_dict()
+
+    @mcp.tool(annotations=READ_ONLY)
+    def sample_temperature(duration_s: float = 10.0, interval_s: float = 1.0) -> dict[str, Any]:
+        """Record temperature readings over a period and return statistics plus all samples.
+
+        Args:
+            duration_s: Recording time in seconds (max 600).
+            interval_s: Time between readings in seconds (min 0.5, the instrument's update rate).
+        """
+        if not 0 < duration_s <= MAX_DURATION_S:
+            raise ToolError(f"duration_s must be between 0 and {MAX_DURATION_S:g}")
+        if interval_s < MIN_INTERVAL_S:
+            raise ToolError(f"interval_s must be at least {MIN_INTERVAL_S}")
+        samples = []
+        with _device_errors():
+            start = time.monotonic()
+            while True:
+                samples.append(device.temperature())
+                next_at = start + len(samples) * interval_s
+                if next_at - start > duration_s:
+                    break
+                time.sleep(max(0.0, next_at - time.monotonic()))
+        values = [s.value for s in samples]
+        return {
+            "unit": samples[0].unit,
+            "count": len(values),
+            "min": min(values),
+            "max": max(values),
+            "mean": round(statistics.fmean(values), 4),
+            "stdev": round(statistics.stdev(values), 4) if len(values) > 1 else 0.0,
+            "start": samples[0].timestamp.isoformat(),
+            "end": samples[-1].timestamp.isoformat(),
+            "samples": [{"t": s.timestamp.isoformat(), "value": s.value} for s in samples],
+        }
+
+    @mcp.tool(annotations=READ_ONLY)
+    def get_device_info() -> dict[str, Any]:
+        """Instrument model, serial number, firmware, clock (UTC) and battery level."""
+        with _device_errors():
+            info: dict[str, Any] = dict(device.device_information())
+            info["port"] = device.port
+            info["clock_utc"] = device.get_datetime().isoformat()
+            info["battery_percent"] = device.battery().value
+            return info
+
+    if allow_write:
+
+        @mcp.tool(annotations=WRITES_DEVICE)
+        def set_device_clock(utc_time: str | None = None) -> dict[str, Any]:
+            """Set the instrument clock. Without argument it is synchronised to this computer's time.
+
+            Args:
+                utc_time: Optional ISO 8601 time, e.g. "2026-10-28 17:00:00" (interpreted as UTC).
+            """
+            with _device_errors():
+                when = datetime.fromisoformat(utc_time) if utc_time else datetime.now(timezone.utc)
+                if when.tzinfo is None:
+                    when = when.replace(tzinfo=timezone.utc)
+                device.set_datetime(when)
+                return {"clock_utc": device.get_datetime().isoformat()}
+
+        @mcp.tool(annotations=WRITES_DEVICE)
+        def set_location_name(index: int, name: str) -> dict[str, Any]:
+            """Rename one of the 20 location labels used when saving single readings on the instrument.
+
+            Args:
+                index: Label number 1..20.
+                name: New label text, at most 16 ASCII characters.
+            """
+            with _device_errors():
+                reply = device.update_location(index, name)
+                return {"index": index, "name": name, "reply": reply}
+
+    return mcp
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="mcp-server-senseca-pro", description=__doc__)
+    parser.add_argument(
+        "--port",
+        default=os.environ.get("SENSECA_PORT"),
+        help="serial port, e.g. /dev/ttyACM0 or COM3 (env SENSECA_PORT; default: auto-detect)",
+    )
+    parser.add_argument(
+        "--allow-write",
+        action="store_true",
+        default=os.environ.get("SENSECA_ALLOW_WRITE", "").lower() in ("1", "true", "yes"),
+        help="enable tools that change instrument settings (env SENSECA_ALLOW_WRITE)",
+    )
+    parser.add_argument("--log-level", default=os.environ.get("SENSECA_LOG_LEVEL", "WARNING"))
+    args = parser.parse_args()
+
+    # stdout carries the MCP protocol, so logs must go to stderr.
+    logging.basicConfig(stream=sys.stderr, level=args.log_level.upper(), format="%(levelname)s %(name)s: %(message)s")
+
+    # The PIN is only read from the environment so it never ends up in a process list or chat.
+    device = Pro11x(port=args.port, pin=os.environ.get("SENSECA_PIN"))
+    try:
+        create_server(device, allow_write=args.allow_write).run("stdio")
+    finally:
+        device.close()