mcp-snap7 0.1.0__tar.gz

mcp_snap7-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.env
+.venv
+venv/
+env/
+*.pyc
+*.pyo
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+htmlcov/
+.coverage
+.coverage.*
+*.log
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo

mcp_snap7-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dario Clavijo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_snap7-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: mcp-snap7
+Version: 0.1.0
+Summary: MCP server for python-snap7, enabling MCP clients to interact with Siemens PLCs
+Project-URL: Homepage, https://github.com/daedalus/mcp-snap7
+Project-URL: Repository, https://github.com/daedalus/mcp-snap7
+Project-URL: Issues, https://github.com/daedalus/mcp-snap7/issues
+Author-email: Dario Clavijo <clavijodario@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: fastmcp
+Requires-Dist: python-snap7
+Provides-Extra: all
+Requires-Dist: hatch; extra == 'all'
+Requires-Dist: hypothesis; extra == 'all'
+Requires-Dist: mypy; extra == 'all'
+Requires-Dist: pytest; extra == 'all'
+Requires-Dist: pytest-asyncio; extra == 'all'
+Requires-Dist: pytest-cov; extra == 'all'
+Requires-Dist: pytest-mock; extra == 'all'
+Requires-Dist: ruff; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: lint
+Requires-Dist: mypy; extra == 'lint'
+Requires-Dist: ruff; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Description-Content-Type: text/markdown
+
+# mcp-snap7
+
+> MCP server for python-snap7, enabling MCP clients to interact with Siemens PLCs
+
+[![PyPI](https://img.shields.io/pypi/v/mcp-snap7.svg)](https://pypi.org/project/mcp-snap7/)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-snap7.svg)](https://pypi.org/project/mcp-snap7/)
+[![Coverage](https://codecov.io/gh/daedalus/mcp-snap7/branch/main/graph/badge.svg)](https://codecov.io/gh/daedalus/mcp-snap7)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+## Install
+
+```bash
+pip install mcp-snap7
+```
+
+## Requirements
+
+- python-snap7 requires the libsnap7 library to be installed on your system.
+  See [python-snap7 documentation](https://python-snap7.readthedocs.io/) for installation instructions.
+
+## Usage
+
+### As MCP Server
+
+Configure your MCP client to use `mcp-snap7` as a stdio server:
+
+```json
+{
+  "mcpServers": {
+    "mcp-snap7": {
+      "command": "mcp-snap7"
+    }
+  }
+}
+```
+
+### Available Tools
+
+- `connect_plc` - Connect to a Siemens PLC
+- `disconnect_plc` - Disconnect from PLC
+- `get_connected` - Check connection status
+- `db_read` / `db_write` - Read/write data blocks
+- `mb_read` / `mb_write` - Read/write memory bytes
+- `tm_read` / `tm_write` - Read/write timers
+- `ct_read` / `ct_write` - Read/write counters
+- `eb_read` / `eb_write` - Read/write edge inputs
+- `ab_read` / `ab_write` - Read/write absolute bytes
+- `get_cpu_info` - Get CPU information
+- `get_cpu_state` - Get CPU state
+- `get_protection` - Get PLC protection level
+- `plc_cold_start` - Trigger cold start
+- `plc_hot_start` - Trigger hot start
+- `plc_stop` - Stop PLC
+- `get_error_text` - Get error description
+
+## Development
+
+```bash
+git clone https://github.com/daedalus/mcp-snap7.git
+cd mcp-snap7
+pip install -e ".[test]"
+
+# run tests
+pytest
+
+# format
+ruff format src/ tests/
+
+# lint
+ruff check src/ tests/
+
+# type check
+mypy src/
+```

mcp_snap7-0.1.0/README.md

@@ -0,0 +1,74 @@
+# mcp-snap7
+
+> MCP server for python-snap7, enabling MCP clients to interact with Siemens PLCs
+
+[![PyPI](https://img.shields.io/pypi/v/mcp-snap7.svg)](https://pypi.org/project/mcp-snap7/)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-snap7.svg)](https://pypi.org/project/mcp-snap7/)
+[![Coverage](https://codecov.io/gh/daedalus/mcp-snap7/branch/main/graph/badge.svg)](https://codecov.io/gh/daedalus/mcp-snap7)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+## Install
+
+```bash
+pip install mcp-snap7
+```
+
+## Requirements
+
+- python-snap7 requires the libsnap7 library to be installed on your system.
+  See [python-snap7 documentation](https://python-snap7.readthedocs.io/) for installation instructions.
+
+## Usage
+
+### As MCP Server
+
+Configure your MCP client to use `mcp-snap7` as a stdio server:
+
+```json
+{
+  "mcpServers": {
+    "mcp-snap7": {
+      "command": "mcp-snap7"
+    }
+  }
+}
+```
+
+### Available Tools
+
+- `connect_plc` - Connect to a Siemens PLC
+- `disconnect_plc` - Disconnect from PLC
+- `get_connected` - Check connection status
+- `db_read` / `db_write` - Read/write data blocks
+- `mb_read` / `mb_write` - Read/write memory bytes
+- `tm_read` / `tm_write` - Read/write timers
+- `ct_read` / `ct_write` - Read/write counters
+- `eb_read` / `eb_write` - Read/write edge inputs
+- `ab_read` / `ab_write` - Read/write absolute bytes
+- `get_cpu_info` - Get CPU information
+- `get_cpu_state` - Get CPU state
+- `get_protection` - Get PLC protection level
+- `plc_cold_start` - Trigger cold start
+- `plc_hot_start` - Trigger hot start
+- `plc_stop` - Stop PLC
+- `get_error_text` - Get error description
+
+## Development
+
+```bash
+git clone https://github.com/daedalus/mcp-snap7.git
+cd mcp-snap7
+pip install -e ".[test]"
+
+# run tests
+pytest
+
+# format
+ruff format src/ tests/
+
+# lint
+ruff check src/ tests/
+
+# type check
+mypy src/
+```

mcp_snap7-0.1.0/pyproject.toml

@@ -0,0 +1,89 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-snap7"
+version = "0.1.0"
+description = "MCP server for python-snap7, enabling MCP clients to interact with Siemens PLCs"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "Dario Clavijo", email = "clavijodario@gmail.com"}
+]
+dependencies = ["fastmcp", "python-snap7"]
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "mypy",
+    "hatch",
+]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-mock",
+    "pytest-asyncio",
+    "hypothesis",
+]
+lint = [
+    "ruff",
+    "mypy",
+]
+all = ["mcp-snap7[dev,test,lint]"]
+
+[project.scripts]
+mcp-snap7 = "mcp_snap7.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/daedalus/mcp-snap7"
+Repository = "https://github.com/daedalus/mcp-snap7"
+Issues = "https://github.com/daedalus/mcp-snap7/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_snap7"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/mcp_snap7"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "ANN", "TCH", "N", "C4", "ARG"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/*" = ["ANN", "ARG", "F401"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_return_any = true
+warn_unused_ignores = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short --cov=src --cov-fail-under=80"
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[tool.coverage.run]
+source = ["src"]
+branch = true
+
+[tool.coverage.report]
+exclude = ["tests/*", "*/__init__.py"]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

mcp_snap7-0.1.0/src/mcp_snap7/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.1.0"
+__all__ = ["mcp", "client"]
+
+from typing import TYPE_CHECKING
+
+from ._mcp import mcp
+
+if TYPE_CHECKING:
+    from ._client import Snap7Client

mcp_snap7-0.1.0/src/mcp_snap7/__main__.py

@@ -0,0 +1,10 @@
+from . import mcp
+
+
+def main() -> int:
+    mcp.run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mcp_snap7-0.1.0/src/mcp_snap7/_client.py

@@ -0,0 +1,190 @@
+import json
+from typing import Any
+
+import snap7
+
+
+class Snap7Client:
+    def __init__(self) -> None:
+        self._client = snap7.client.Client()
+        self._connected = False
+
+    def connect(self, address: str, rack: int, slot: int, tcp_port: int) -> str:
+        try:
+            self._client.connect(address, rack, slot, tcp_port)
+            self._connected = True
+            return f"Connected to {address} (rack={rack}, slot={slot}, port={tcp_port})"
+        except Exception as e:
+            return f"Connection failed: {str(e)}"
+
+    def disconnect(self) -> str:
+        try:
+            if self._connected:
+                self._client.disconnect()
+                self._connected = False
+            return "Disconnected"
+        except Exception as e:
+            return f"Disconnect failed: {str(e)}"
+
+    def get_connected(self) -> bool:
+        try:
+            return self._client.get_connected()
+        except Exception:
+            return False
+
+    def _hex_to_bytearray(self, hex_string: str) -> bytearray:
+        if hex_string.startswith("0x"):
+            hex_string = hex_string[2:]
+        return bytearray(bytes.fromhex(hex_string))
+
+    def _data_to_hex(self, data: bytearray | bytes) -> str:
+        return bytes(data).hex()
+
+    def db_read(self, db_number: int, start: int, size: int) -> str:
+        try:
+            data = self._client.db_read(db_number, start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"DB read failed: {str(e)}")
+
+    def db_write(self, db_number: int, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.db_write(db_number, start, data_bytes)
+            return f"Written {len(data_bytes)} bytes to DB{db_number}"
+        except Exception as e:
+            raise RuntimeError(f"DB write failed: {str(e)}")
+
+    def mb_read(self, start: int, size: int) -> str:
+        try:
+            data = self._client.mb_read(start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"MB read failed: {str(e)}")
+
+    def mb_write(self, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.mb_write(start, len(data_bytes), data_bytes)
+            return f"Written {len(data_bytes)} bytes to MB"
+        except Exception as e:
+            raise RuntimeError(f"MB write failed: {str(e)}")
+
+    def tm_read(self, start: int, size: int) -> str:
+        try:
+            data = self._client.tm_read(start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"TM read failed: {str(e)}")
+
+    def tm_write(self, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.tm_write(start, len(data_bytes), data_bytes)
+            return f"Written {len(data_bytes)} bytes to TM"
+        except Exception as e:
+            raise RuntimeError(f"TM write failed: {str(e)}")
+
+    def ct_read(self, start: int, size: int) -> str:
+        try:
+            data = self._client.ct_read(start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"CT read failed: {str(e)}")
+
+    def ct_write(self, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.ct_write(start, len(data_bytes), data_bytes)
+            return f"Written {len(data_bytes)} bytes to CT"
+        except Exception as e:
+            raise RuntimeError(f"CT write failed: {str(e)}")
+
+    def eb_read(self, start: int, size: int) -> str:
+        try:
+            data = self._client.eb_read(start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"EB read failed: {str(e)}")
+
+    def eb_write(self, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.eb_write(start, len(data_bytes), data_bytes)
+            return f"Written {len(data_bytes)} bytes to EB"
+        except Exception as e:
+            raise RuntimeError(f"EB write failed: {str(e)}")
+
+    def ab_read(self, start: int, size: int) -> str:
+        try:
+            data = self._client.ab_read(start, size)
+            return self._data_to_hex(data)
+        except Exception as e:
+            raise RuntimeError(f"AB read failed: {str(e)}")
+
+    def ab_write(self, start: int, data: str) -> str:
+        try:
+            data_bytes = self._hex_to_bytearray(data)
+            self._client.ab_write(start, data_bytes)
+            return f"Written {len(data_bytes)} bytes to AB"
+        except Exception as e:
+            raise RuntimeError(f"AB write failed: {str(e)}")
+
+    def get_cpu_info(self) -> dict[str, Any]:
+        try:
+            info = self._client.get_cpu_info()
+            return {
+                "module_type": info.ModuleType,
+                "serial_number": info.SerialNumber,
+                "as_name": info.ASName,
+                "module_name": info.ModuleName,
+                "copyright": info.Copyright,
+            }
+        except Exception as e:
+            raise RuntimeError(f"Get CPU info failed: {str(e)}")
+
+    def get_cpu_state(self) -> str:
+        try:
+            return self._client.get_cpu_state()
+        except Exception as e:
+            raise RuntimeError(f"Get CPU state failed: {str(e)}")
+
+    def get_protection(self) -> dict[str, Any]:
+        try:
+            protection = self._client.get_protection()
+            return {
+                "protection_level": protection.szl_protection.SZLProtection,
+            }
+        except Exception as e:
+            raise RuntimeError(f"Get protection failed: {str(e)}")
+
+    def plc_cold_start(self) -> str:
+        try:
+            self._client.plc_cold_start()
+            return "Cold start command sent"
+        except Exception as e:
+            raise RuntimeError(f"Cold start failed: {str(e)}")
+
+    def plc_hot_start(self) -> str:
+        try:
+            self._client.plc_hot_start()
+            return "Hot start command sent"
+        except Exception as e:
+            raise RuntimeError(f"Hot start failed: {str(e)}")
+
+    def plc_stop(self) -> str:
+        try:
+            self._client.plc_stop()
+            return "Stop command sent"
+        except Exception as e:
+            raise RuntimeError(f"Stop failed: {str(e)}")
+
+    def get_error_text(self, error_code: int) -> str:
+        return self._client.error_text(error_code)
+
+    def get_status(self) -> str:
+        return json.dumps(
+            {
+                "connected": self.get_connected(),
+            }
+        )

mcp_snap7-0.1.0/src/mcp_snap7/_mcp.py

@@ -0,0 +1,328 @@
+from typing import Any
+
+import fastmcp
+
+from ._client import Snap7Client
+
+mcp = fastmcp.FastMCP("mcp-snap7")
+
+_client: Snap7Client | None = None
+
+
+def _get_client() -> Snap7Client:
+    global _client
+    if _client is None:
+        _client = Snap7Client()
+    return _client
+
+
+@mcp.tool()
+def connect_plc(address: str, rack: int = 0, slot: int = 1, tcp_port: int = 102) -> str:
+    """Connect to a Siemens PLC.
+
+    Args:
+        address: PLC IP address (e.g., "192.168.1.1")
+        rack: Rack number (default 0)
+        slot: Slot number (default 1)
+        tcp_port: TCP port (default 102)
+
+    Returns:
+        Connection status message
+    """
+    client = _get_client()
+    return client.connect(address, rack, slot, tcp_port)
+
+
+@mcp.tool()
+def disconnect_plc() -> str:
+    """Disconnect from the connected PLC.
+
+    Returns:
+        Disconnection status message
+    """
+    client = _get_client()
+    return client.disconnect()
+
+
+@mcp.tool()
+def get_connected() -> bool:
+    """Check if PLC is connected.
+
+    Returns:
+        True if connected, False otherwise
+    """
+    client = _get_client()
+    return client.get_connected()
+
+
+@mcp.tool()
+def db_read(db_number: int, start: int, size: int) -> str:
+    """Read data block from PLC.
+
+    Args:
+        db_number: Data block number
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.db_read(db_number, start, size)
+
+
+@mcp.tool()
+def db_write(db_number: int, start: int, data: str) -> str:
+    """Write data block to PLC.
+
+    Args:
+        db_number: Data block number
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.db_write(db_number, start, data)
+
+
+@mcp.tool()
+def mb_read(start: int, size: int) -> str:
+    """Read memory bytes from PLC.
+
+    Args:
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.mb_read(start, size)
+
+
+@mcp.tool()
+def mb_write(start: int, data: str) -> str:
+    """Write memory bytes to PLC.
+
+    Args:
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.mb_write(start, data)
+
+
+@mcp.tool()
+def tm_read(start: int, size: int) -> str:
+    """Read timers from PLC.
+
+    Args:
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.tm_read(start, size)
+
+
+@mcp.tool()
+def tm_write(start: int, data: str) -> str:
+    """Write timers to PLC.
+
+    Args:
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.tm_write(start, data)
+
+
+@mcp.tool()
+def ct_read(start: int, size: int) -> str:
+    """Read counters from PLC.
+
+    Args:
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.ct_read(start, size)
+
+
+@mcp.tool()
+def ct_write(start: int, data: str) -> str:
+    """Write counters to PLC.
+
+    Args:
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.ct_write(start, data)
+
+
+@mcp.tool()
+def eb_read(start: int, size: int) -> str:
+    """Read edge inputs from PLC.
+
+    Args:
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.eb_read(start, size)
+
+
+@mcp.tool()
+def eb_write(start: int, data: str) -> str:
+    """Write edge inputs to PLC.
+
+    Args:
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.eb_write(start, data)
+
+
+@mcp.tool()
+def ab_read(start: int, size: int) -> str:
+    """Read absolute bytes from PLC.
+
+    Args:
+        start: Start byte offset
+        size: Number of bytes to read
+
+    Returns:
+        Hex string of read data
+    """
+    client = _get_client()
+    return client.ab_read(start, size)
+
+
+@mcp.tool()
+def ab_write(start: int, data: str) -> str:
+    """Write absolute bytes to PLC.
+
+    Args:
+        start: Start byte offset
+        data: Hex string of data to write
+
+    Returns:
+        Write status message
+    """
+    client = _get_client()
+    return client.ab_write(start, data)
+
+
+@mcp.tool()
+def get_cpu_info() -> dict[str, Any]:
+    """Get CPU information from PLC.
+
+    Returns:
+        Dictionary containing CPU information
+    """
+    client = _get_client()
+    return client.get_cpu_info()
+
+
+@mcp.tool()
+def get_cpu_state() -> str:
+    """Get CPU state from PLC.
+
+    Returns:
+        CPU state string
+    """
+    client = _get_client()
+    return client.get_cpu_state()
+
+
+@mcp.tool()
+def get_protection() -> dict[str, Any]:
+    """Get PLC protection level.
+
+    Returns:
+        Dictionary containing protection level info
+    """
+    client = _get_client()
+    return client.get_protection()
+
+
+@mcp.tool()
+def plc_cold_start() -> str:
+    """Trigger PLC cold start.
+
+    Returns:
+        Status message
+    """
+    client = _get_client()
+    return client.plc_cold_start()
+
+
+@mcp.tool()
+def plc_hot_start() -> str:
+    """Trigger PLC hot start.
+
+    Returns:
+        Status message
+    """
+    client = _get_client()
+    return client.plc_hot_start()
+
+
+@mcp.tool()
+def plc_stop() -> str:
+    """Stop PLC.
+
+    Returns:
+        Status message
+    """
+    client = _get_client()
+    return client.plc_stop()
+
+
+@mcp.tool()
+def get_error_text(error_code: int) -> str:
+    """Get error description from error code.
+
+    Args:
+        error_code: Numeric error code
+
+    Returns:
+        Error description string
+    """
+    client = _get_client()
+    return client.get_error_text(error_code)
+
+
+@mcp.resource("connection://status")
+def connection_status() -> str:
+    """Get current connection status.
+
+    Returns:
+        Connection status as JSON string
+    """
+    client = _get_client()
+    return client.get_status()