This server lets an AI assistant manage an OpenMediaVault NAS through its RPC API over SSH, covering everything the web UI can do.
Connection info: check connectivity and active configuration with omv_connection_info.
API discovery: list all RPC services (omv_list_services) and each service's methods (omv_list_methods).
Manage NAS resources: call any OpenMediaVault RPC method via omv_call (e.g. disks, SMART health, filesystems, shared folders, users/groups, SMB/NFS/FTP/rsync, network, scheduled jobs, package updates, and applying pending config changes).
Handle background jobs: collect output from long-running RPC tasks with omv_wait_for_task.
Shell access (optional): run arbitrary shell commands on the NAS with omv_shell, useful for logs, docker, smartctl, and other non-RPC tasks.
Read-only safety: optional read-only mode blocks non-read operations; shell tool can be disabled entirely.
Works with any MCP client: plain stdio server, no dependencies, Python 3.9+, no install on the NAS.
Provides tools to manage an OpenMediaVault NAS via its RPC interface, including disks, filesystems, shared folders, users, S.M.A.R.T. health, services, configuration changes, and background jobs.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@omv-mcp check S.M.A.R.T. health for all disks"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that lets an AI assistant manage an OpenMediaVault NAS.
Ask in plain language — "which disks are unhealthy?", "why is the SMB share not mounting?", "restart file sharing" — and the assistant works through OpenMediaVault's own API to answer or act.
It connects over ordinary SSH and drives omv-rpc, the command-line tool that ships with
OpenMediaVault. That is the same RPC layer the web interface uses, so anything you can do
by clicking, the assistant can do too. Nothing is installed on the NAS and no extra port
is opened.
MCP client --stdio--> omv_mcp.py --ssh--> NAS --> omv-rpc --> OMV RPC layer
(your PC) (your PC) (the same layer as the web UI)Works with any MCP client. This is a plain stdio MCP server with no client-specific
behaviour: Claude Desktop, Claude Code, Cursor, Zed, Cline, VS Code, the OpenAI Agents SDK
and anything else that speaks the protocol can all run it. Any client needs the same three
things — a Python interpreter, the path to omv_mcp.py, and a handful of environment
variables.
For Claude Desktop specifically there is also a prebuilt .mcpb extension file. It
contains that very same server, wrapped so the app can install it in one click and give you
a settings panel instead of a config file to edit. It is a convenience, not a different
product — and not a requirement.
No dependencies. The server is pure standard library — including its MCP protocol
layer — so there is no virtualenv to create, nothing to pip install, and it runs on any
Python 3.9 or newer.
Six tools, and between them they reach the whole of OpenMediaVault:
Tool | Purpose |
| Show the active configuration and test connectivity |
| List every RPC service, including ones added by plugins |
| List the methods of one service |
| Call an RPC method — the main tool |
| Collect the output of a background job |
| Run an arbitrary shell command on the NAS (off by default) |
In practice that covers disks and S.M.A.R.T. health, filesystems and mount points, shared folders and their permissions, users and groups, the file-sharing services (SMB, NFS, FTP, rsync), network settings, scheduled jobs, package updates, and applying pending configuration changes.
OpenMediaVault exposes roughly 50 RPC services with several hundred methods between them, and every plugin adds more. Rather than wrapping each one in a hand-written tool, omv-mcp stays generic: discover the services, discover a service's methods, call a method. The assistant explores the API the way a developer would, starting from what your particular installation actually offers.
The practical benefit: any plugin you install later — Docker/Compose, ZFS, KVM, Kubernetes, whatever — works immediately, with no update to this server.
Related MCP server: Simple SSH MCP Server
NAS | OpenMediaVault 7 or 8, reachable over SSH |
Your computer | Python 3.9 or newer |
MCP client | Any client that can run a stdio MCP server |
Access | An SSH key that logs in to the NAS without a password, and an account that may run |
Developed and verified against OpenMediaVault 8.5.6-1 (Synchrony) on Debian 13. OMV 7 uses the same RPC layer and is expected to work; reports welcome.
Your computer | Extension ( | Manual setup | Notes |
macOS | Yes | Yes | Python 3.9 ships with the system; |
Windows | Yes | Yes | Python is not included — install it from python.org or the Microsoft Store first. |
Linux | — | Yes | Claude Desktop is released for macOS and Windows only, so there is no extension to install. Everything else works: use Claude Code or any other MCP client. |
The server is verified on macOS (Python 3.9) and Linux (Python 3.13). Windows is covered by CI but has not been run against a real NAS — reports welcome.
Both routes install the same server. Pick one:
Use this when | What you get | |
You use Claude Desktop on macOS or Windows | One click, and a settings panel instead of a config file to edit | |
Any other client, or Linux | Clone the repository and point your client at |
The extension is simply this repository's omv_mcp.py packaged into a .mcpb file — a zip
with a manifest that tells Claude Desktop how to start it and which settings to ask you
for. Same code, same behaviour; only the installation differs. If your client is not Claude
Desktop, you are not missing anything by going the manual route.
The extension gives you a settings panel, so nothing has to be edited in any file. macOS and Windows only; on Linux use the manual setup.
Download omv-mcp-<version>.mcpb from the latest release.
Double-click it, or drag it onto the Claude Desktop window. It is also available under Settings → Extensions → Advanced settings → Install Extension…
Fill in at least the NAS hostname or IP address, then enable the extension.
Setting | Default | What it does |
NAS hostname or IP address | — | Required. An IP address, or a host defined in your |
SSH username |
| The account used to log in |
SSH port |
| Change only for a non-standard port |
SSH private key (path) | (empty) | Best left empty — that uses your ssh-agent and |
OpenMediaVault user |
| The OMV login the RPC runs as — not the SSH user |
Run commands with sudo | off | Turn on when the SSH user is not root |
Read-only mode | on | Refuses anything that is not a read operation |
Allow arbitrary shell commands | off | Adds the unrestricted |
Command timeout |
| Per-command limit |
After changing any setting: click Save, then fully quit Claude Desktop (⌘Q on macOS) and reopen it. The server reads its settings once at startup, so a running server keeps the values it was started with — closing the window is not enough. Until you restart, changes appear not to have saved: writes keep getting refused and
omv_connection_inforeports the old values.
Read-only mode is on by default. Turn it off once you are comfortable letting the assistant change things.
git clone https://github.com/mbgroen/omv-mcp.git
cd omv-mcp
python3 scripts/build_mcpb.pyThe .mcpb lands in dist/. It is an ordinary zip archive with a manifest.json at its
root, so the build script needs nothing but the standard library — no Node.js and no
mcpb CLI.
The route for every client other than Claude Desktop — and the only route on Linux.
git clone https://github.com/mbgroen/omv-mcp.gitThere is nothing to install. Point your client at omv_mcp.py with your system Python.
Whatever the client, it needs the same three things: the command python3, the argument
/absolute/path/to/omv_mcp.py, and the environment variables from
the table below. The examples that follow are just those three
things written in each client's own configuration format.
Claude Code — the same on macOS, Linux and Windows:
claude mcp add openmediavault -e OMV_SSH_HOST=192.168.1.100 -e OMV_READONLY=1 -- python3 "$PWD/omv_mcp.py"Add -s user to make it available in every project rather than only the current one.
claude mcp list reports ✔ Connected once the handshake succeeds.
Cursor, Zed, Cline, VS Code, the OpenAI Agents SDK and others — most use a JSON block in the same shape as the Claude Desktop one below, under whatever key that client calls its server list. Consult its documentation for the file, then fill in the same command, argument and environment variables.
Claude Desktop by hand — useful if you would rather not use the extension, in
claude_desktop_config.json —
~/Library/Application Support/Claude/ on macOS, %APPDATA%\Claude\ on Windows:
{
"mcpServers": {
"openmediavault": {
"command": "python3",
"args": ["/absolute/path/to/omv-mcp/omv_mcp.py"],
"env": {
"OMV_SSH_HOST": "192.168.1.100",
"OMV_SSH_USER": "root",
"OMV_RPC_USER": "admin",
"OMV_READONLY": "1"
}
}
}
}Use absolute paths, not ~, and restart the client completely afterwards.
The extension sets these for you; this table is for manual setups.
Variable | Default | Meaning |
| (empty) | Hostname or IP of the NAS. Empty runs commands locally — use that if the server itself runs on the NAS. |
|
| SSH user |
|
| SSH port |
| (empty) | Path to a private key. Empty uses your ssh-agent and |
|
| The OMV user the RPC call runs as |
|
|
|
|
|
|
|
|
|
|
| Per-command timeout in seconds |
Booleans accept 1/true/yes/on and their opposites.
Leave OMV_SSH_HOST empty and commands run locally instead of over SSH, so the server can
live on the NAS alongside OpenMediaVault. This only helps when the MCP client also runs
there — Claude Code over an SSH session, for instance — because stdio means the client
starts the server as a child process. omv_connection_info reports "mode": "local" when
it is working this way.
The server runs ssh with BatchMode=yes, so password logins will not work. That is
deliberate: an MCP server has no way to prompt you for a password. Use a key.
ssh-keygen -t ed25519 -C "omv-mcp" # skip if you already have a key
ssh-copy-id user@nas # your NAS address
ssh user@nas 'omv-rpc -u admin System getInformation'If that last command prints JSON, the server will work. Run it whenever something is wrong: it separates an SSH problem from an MCP problem in one step.
Which key goes where. The public key (.pub) belongs on the NAS, in
~/.ssh/authorized_keys — that is what ssh-copy-id puts there. The private key stays
on your computer and is what proves your identity. So if you fill in the key setting, give
it the path to the private key: ~/.ssh/id_ed25519, not ~/.ssh/id_ed25519.pub.
Better still, leave that setting empty. Then ssh uses your agent and ~/.ssh/config, which
is where this kind of detail belongs:
Host nas
HostName 192.168.1.100
User root
IdentityFile ~/.ssh/id_ed25519and set the NAS address to nas. Note that leaving the setting empty only works if ssh can
find the key on its own — that means a standard name (id_ed25519, id_rsa), an entry in
~/.ssh/config, or a key loaded into your ssh-agent. A key with a custom name and no config
entry has to be given explicitly.
First connection from a new computer. The NAS will not be in that machine's
known_hosts yet, and BatchMode stops ssh from asking whether to trust it. omv-mcp
therefore connects with StrictHostKeyChecking=accept-new: an unknown host is recorded on
first contact, exactly as answering yes would, while a host key that changes later is
still refused. To approve it yourself instead, run ssh user@nas once in a terminal before
enabling the extension.
Root login refused? OpenMediaVault disables SSH root login by default. Either enable it
under Services → SSH → Permit root login, or use your own account and turn on sudo — that
account needs to be in the sudo group.
Start by asking the assistant to check the connection; it will call omv_connection_info
and report your OpenMediaVault version. From there, ask for what you want in ordinary
language:
"Are any of my disks reporting SMART errors?"
"What is using space on the data pool?"
"Show me the shared folders and who can write to them."
"The SMB service is not responding — what does its status say?"
"Are there package updates pending, and what would they change?"
"Apply the pending configuration changes."
Under the hood the assistant calls omv_call with a service and a method:
omv_call("System", "getInformation")
omv_call("FileSystemMgmt", "enumerateMountedFilesystems", {"includeRoot": True})
omv_call("ShareMgmt", "enumerateSharedFolders")
omv_call("Smart", "getListBg", {"start": 0, "limit": -1})You do not need to memorise service names — omv_list_services and omv_list_methods
always reflect your own installation, plugins included. Service names are case sensitive,
and a few are lowercase (kernel, omvextras), so use them exactly as returned.
Background jobs. Heavier methods return {"filename": "..."} and keep running on the
NAS. omv_wait_for_task polls until the job finishes and returns the accumulated output:
result = omv_call("Apt", "upgrade") # -> {"filename": "/tmp/bgstatus..."}
omv_wait_for_task(result["filename"], max_seconds=600)The shell tool is an escape hatch for everything outside the RPC layer — journalctl,
docker ps, smartctl, package state. Prefer omv_call for anything OpenMediaVault
manages itself, so its configuration database stays in sync with the system. Off by
default.
This server can do anything you can do in the OpenMediaVault web interface, and — if you enable the shell tool — run arbitrary commands as root. That is the point of it, but be clear-eyed about what it means: the only thing between a mistaken suggestion and a wiped filesystem is the tool confirmation dialog in your MCP client. Read what it says before approving.
Sensible precautions:
Keep read-only mode on until you have a feel for what the assistant does with it.
Leave the shell tool off unless you need it.
Use a dedicated SSH key for this rather than your everyday key.
Consider a non-root user with sudo and a narrowed sudoers rule.
Keep it on your LAN. This server has no authentication of its own; its security boundary is your SSH configuration.
Read-only mode uses a prefix heuristic — a method is allowed if its name starts with get,
enumerate, list, is, has, read, query, find, exists, count or check. It
is deliberately conservative and will occasionally block a harmless method. It is a guard
rail, not a security boundary: it cannot stop a read method that happens to have side
effects.
Service and method names are validated against ^[A-Za-z0-9_]+$, and every value
interpolated into a shell command goes through shlex.quote, so parameters cannot break
out into the shell.
On host keys: the connection uses StrictHostKeyChecking=accept-new, which trusts the NAS
on first contact and pins it from then on. That is trust-on-first-use, the same bargain you
make when you type yes at an ssh prompt, and it is what makes an unattended first
connection possible. It is not StrictHostKeyChecking=no: a key that changes after that
first connection is still refused. Connect once from a terminal beforehand if you want to
avoid the first-use window entirely.
An RPC service's name is not its file name — it is whatever the PHP getName() method
returns. So omv_list_services greps the sources in
/usr/share/openmediavault/engined/rpc/ and reads the names out. The result is cached for
the lifetime of the process; restart the server after installing a plugin.
Three details about OpenMediaVault's sources that this parser handles, and which are easy to get wrong when writing your own:
Quoting is inconsistent. The PHP mixes ' and " freely. On OMV 8.5, six of the 52
service names and about a third of all registerMethod() calls use single quotes.
Matching only double quotes silently loses them.
Some service names are lowercase — kernel and omvextras, for instance — and
omv-rpc is case sensitive.
One file can hold several RPC classes. notification.inc defines both Notification
and EmailNotification, so methods are scoped to the class block they appear in rather
than to the whole file.
Errors are cleaned up too: a failed omv-rpc call writes a JSON blob to stderr containing a
full PHP stack trace, and only the message field is surfaced.
mcp_stdio.py implements the protocol directly: newline-delimited JSON-RPC 2.0 over stdio,
initialize with version negotiation, tools/list with input schemas derived from each
function's signature and docstring, and tools/call.
That is a deliberate choice rather than an exercise. The official MCP Python SDK depends on pydantic, which ships compiled binaries — and the MCPB documentation is explicit that you cannot portably bundle compiled dependencies. Implementing the handful of methods a tools-only server needs keeps the extension a single small file that works on macOS, Windows and Linux alike, with no runtime to install and no Python version floor beyond 3.9.
No dependencies, nothing to install:
python3 -m unittest discover -s tests -t tests -vOr with pytest, if you prefer its output:
pip install pytest && pytestThe fixtures under tests/fixtures/ are real output captured from an OpenMediaVault 8.5.6-1
system — grep dumps of the RPC sources, a successful RPC response and an error response —
with identifying values replaced. The tests therefore assert against what a NAS actually
returns rather than against an idealised sample.
Symptom | Likely cause |
Extension will not install | Python 3.9 or newer is missing. Check with |
Extension will not start | No |
Server does not appear in the client | JSON syntax error, or a relative path in a manual config |
| This computer's key is not in |
| The NAS key could not be accepted automatically — run |
No connection from a newly set up computer | That machine has no SSH key on the NAS yet. Test with |
| The SSH user cannot read |
|
|
| Raise the timeout, or use |
A method is refused as "not a read method" | Read-only mode is on. If you just turned it off, fully quit and reopen Claude Desktop. |
Settings disagree with | The server still holds its startup values, or a second registration in another client answered |
A setting will not stick | Quit Claude Desktop and edit the extension's JSON under |
A newly installed plugin is invisible | Restart the MCP server; the service list is cached |
Claude Desktop writes per-server logs to ~/Library/Logs/Claude/ on macOS.
Issues and pull requests are welcome — particularly reports from OpenMediaVault 7, from plugins whose RPC sources are laid out unusually, and from setups where discovery finds fewer services than the web interface offers.
Please run the test suite before opening a PR. If you are fixing a parsing issue, add a fixture captured from the real system alongside it; that is how the existing tests are built.
MIT — see LICENSE.
This project is not affiliated with or endorsed by the OpenMediaVault project.
Call an OpenMediaVault RPC method. This is the main tool.
Anything the web interface can do is available here. Some heavier methods run in the background and return {"filename": "..."} -- pass that value to omv_wait_for_task to collect the output.
Examples: omv_call("System", "getInformation") omv_call("FileSystemMgmt", "enumerateMountedFilesystems", {"includeRoot": True}) omv_call("ShareMgmt", "enumerateSharedFolders")
| Name | Required | Description | Default |
|---|---|---|---|
| method | Yes | For example "enumerateMountedFilesystems", "getInformation". | |
| params | No | Parameters as a dict. Omit for methods that take none. | |
| service | Yes | For example "FileSystemMgmt", "System", "ShareMgmt". | |
| timeout | No | Timeout in seconds for this specific call. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It reveals an important async behavior: some heavier methods run in the background and return a filename that must be passed to omv_wait_for_task. However, it does not warn that RPC calls may be destructive or require elevated permissions, nor does it describe the normal return format beyond the background case. This is meaningful but incomplete transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately sized but each sentence contributes: the main-tool claim, the scope, the async behavior, and examples. It is front-loaded with purpose and uses examples efficiently. It could be tightened slightly, but it is well-structured for a generic RPC facade.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a generic and potentially complex RPC wrapper with no output schema and no annotations. The description explains the async path and gives examples, but it does not mention how to discover valid method/service names via omv_list_methods or omv_list_services, nor does it describe normal return values or error behavior. Given the complexity, this is only partially complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers all four parameters with examples, so the baseline is 3. The description adds value beyond the schema by showing full call examples, illustrating how the params object is constructed, and explicitly stating that params should be omitted for methods taking none. This extra guidance helps the agent correctly format arguments.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool calls an OpenMediaVault RPC method and is the main tool. It goes beyond a simple verb+resource by noting that 'anything the web interface can do is available here,' which effectively defines its broad scope and distinguishes it from the sibling helper tools. Concrete examples reinforce the resource and action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives strong context for when to use the tool: it is the 'main' RPC entry point covering everything the web UI can do. It also explicitly explains that heavier background methods require passing the returned filename to omv_wait_for_task, which is an explicit alternative workflow. It does not mention omv_list_methods or omv_list_services for discovery, so it lacks complete exclusion/alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show how this server connects and whether that works.
Useful as a first smoke test and when troubleshooting connectivity.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden. The text implies a read-only operation ('Show how this server connects'), but it does not disclose potential side effects, required permissions, or error behavior. It's a minimal disclosure, not covering important behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with purpose and immediate use cases. Every word earns its place; no unnecessary content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description does not explain the return format or what fields the connection info will contain. For a 'smoke test' tool, an agent would likely need to know what to expect in the response. The description is too sparse for full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the parameter semantic burden is none. Per rubric, a baseline of 4 applies since there are no parameters to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Show how this server connects and whether that works.' This is a specific informative action, distinct from sibling tools like omv_call or omv_shell. However, it doesn't explicitly differentiate itself by naming alternatives, so a 4 is appropriate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit use cases: 'Useful as a first smoke test and when troubleshooting connectivity.' This gives clear context for when to invoke the tool. It does not mention when not to use it or alternatives, but the identified scenarios are specific enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every method of an RPC service.
Call this before omv_call so you use the exact method name instead of guessing it.
| Name | Required | Description | Default |
|---|---|---|---|
| service | Yes | A service name as returned by omv_list_services. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. As a listing operation, it is implicitly read-only, and the description adds the prerequisite relationship with omv_call. It doesn't detail output format or error handling, but for a simple introspection tool, that is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the primary action, and contains no fluff. Every sentence adds value: the first states what it does, the second explains why to use it.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool of this simplicity, the description is complete: it states the action, the timing relative to omv_call, and the parameter source. Without an output schema, it doesn't describe the return format, but the name 'list_methods' makes it obvious. Slight gap around failure modes keeps it from a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description covers 100% of the single parameter (service), and the description adds no additional parameter-level meaning. The baseline of 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists every method of an RPC service, using a specific verb and resource. It distinguishes itself from sibling tools like omv_call (which calls a method) and omv_list_services (which lists services).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to call this tool before omv_call to get the exact method name instead of guessing. This provides clear, actionable guidance on when to use this tool, fulfilling the dimension completely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every available OpenMediaVault RPC service.
This is the starting point: every action in the web interface belongs to one of these services (for example System, FileSystemMgmt, ShareMgmt, UserMgmt, Smart, Services). Installed plugins add their own services here.
Note that some service names are lowercase (for example "kernel" and "omvextras") and omv-rpc is case sensitive, so use the name exactly as returned.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that service names are case-sensitive and some are lowercase, advising to use names exactly as returned. It also mentions plugin-added services, which is useful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three well-structured sentences: the core statement, contextual explanation, and a necessary caveat. It is concise, front-loaded, and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with 0 params and no annotations, the description fully covers purpose, usage, and an important case-sensitivity detail. It implicitly describes the output as a list of service names, which is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the description doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description adds context about the return values being service names, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'List every available OpenMediaVault RPC service', which is a clear verb+resource. It positions itself as the starting point for discovery, distinguishing it from siblings like omv_list_methods.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'This is the starting point', indicating when to use it. It also notes that installed plugins add services, giving context. It doesn't explicitly name alternatives, but the use case is well implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run an arbitrary shell command on the NAS.
Intended for everything outside the RPC layer: reading logs (journalctl), package status, docker commands, disk details and so on.
Prefer omv_call for anything OMV manages itself, so that OMV's own configuration database stays in sync with the system.
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | The shell command. | |
| timeout | No | Timeout in seconds. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It identifies the tool as arbitrary shell execution but does not warn about destructive potential, permission requirements, side effects, or output behavior, which is a significant gap for an unrestricted shell tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: purpose first, then use cases, then alternative guidance. Every sentence earns its place with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an arbitrary shell tool with no output schema, the description explains its scope and relationship to omv_call well. However, it omits timeout behavior, return/output format, and safety caveats, which are important for such a powerful tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover both parameters (command and timeout), so the baseline is 3. The description adds context for command types but no parameter-specific semantics beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Run an arbitrary shell command on the NAS' with a specific verb and resource. It also distinguishes itself from omv_call by explicitly positioning itself for everything outside the RPC layer.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit intended use cases (journalctl, package status, docker commands, disk details) and gives a direct alternative: 'Prefer omv_call for anything OMV manages itself.' This is clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Collect the output of a background task started by omv_call.
When omv_call returns something like {"filename": "..."}, the job is running asynchronously on the NAS. This tool polls until it finishes.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The filename value from the omv_call result. | |
| max_seconds | No | How long to wait before giving up. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states that the tool polls until the background task finishes, which communicates the blocking/asynchronous nature of the operation. It does not detail failure/timeout outcomes, but the core behavior is clearly and honestly described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states the action, and the second provides necessary context. Every sentence contributes useful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple polling tool with two well-documented parameters, the description is sufficiently complete. It explains the workflow, the trigger condition, and the polling behavior. It omits explicit return-value details, but 'collect the output' adequately conveys the tool's function given the simple context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% parameter coverage with descriptions for both 'filename' and 'max_seconds'. The tool description adds minimal new semantic value beyond referencing omv_call's result, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: collecting output from an asynchronous background task started by omv_call. It uses a specific verb ('collect') and resource ('output of a background task'), and it distinguishes itself from siblings like omv_call by explicitly connecting the workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this tool when omv_call returns a filename indicating an async job. It names the prerequisite condition and the polling behavior, but it does not explicitly mention alternatives or edge cases like when a task has already finished.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a distinct role: connection check, async task polling, generic RPC call, method discovery, service discovery, and shell access. There is no overlap between them, and their purposes are clearly separable.
All tools share the 'omv_' prefix and use lowercase snake_case, which provides consistency. However, the naming is not strictly verb_noun: 'omv_call', 'omv_list_methods', and 'omv_list_services' are verb-first, while 'omv_connection_info' and 'omv_shell' are noun-first. This minor deviation is still readable and predictable.
Six tools is an appropriate size for this MCP server. The generic omv_call tool provides broad functionality, while the supporting tools (discovery, async handling, health check, shell) round out the surface without unnecessary bloat.
The tool set is highly complete: omv_call can invoke any RPC method, omv_list_methods and omv_list_services enable discovery, omv_wait_for_task handles asynchronous operations, omv_connection_info verifies connectivity, and omv_shell covers non-RPC needs. There are no obvious gaps in managing an OpenMediaVault system.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/mbgroen/omv-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
