A native MCP server for hardware you don't have to babysit.

Most hardware MCP servers need the board plugged into the machine running the agent. Your devices report to your nodrix deployment instead, so the assistant talks to the deployment — and the board can be in another building, or asleep.

12 read · 16 write tools No delete tools Owner-gated, off by default Streamable HTTP MIT licensed

Walk through the setup View on GitHub

Connect

Two endpoints, one worker

Both speak Streamable HTTP and expose the same tools. They differ only in how the client proves who it is — pick whichever your client supports.

/v1/mcp

Bearer token

CLI and IDE clients

Claude Code, Cursor, and anything configured with a static token. Authenticates with a user token from Settings → Tokens.

/v1/mcp/oauth

OAuth 2.1

Browser-based connectors

claude.ai and ChatGPT custom connectors. No token to manage — the user signs in on your instance and approves a consent screen.

Token-configured clients

Mint a token in Settings → Tokens, then point the client at the bearer endpoint. With the Claude Code CLI:

claude mcp add --transport http nodrix \
  https://your-instance.workers.dev/v1/mcp \
  --header "Authorization: Bearer YOUR_TOKEN"

Or as configuration, for any client that reads an MCP server map:

{
  "mcpServers": {
    "nodrix": {
      "type": "http",
      "url": "https://your-instance.workers.dev/v1/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Browser connectors

For claude.ai and ChatGPT, add a custom connector pointing at the OAuth endpoint. There is no token to paste — you sign in on your own instance and approve a consent screen that spells out what is being granted.

https://your-instance.workers.dev/v1/mcp/oauth

The full walkthrough covers both paths step by step, including where the menus live.

Capabilities

What an assistant can actually do

The tools map onto the platform's own primitives, so anything you can do in the dashboard an assistant can do too — within the limits below.

Read live state

get_state returns the latest value of every variable in a project — whatever the device last reported, even if it is asleep right now.

Query history

get_series pulls recent time-series points for a variable, so an assistant can analyse a trend rather than just quote a number.

Actuate hardware

set_variable enqueues a control write your device picks up on its next poll. This is how an assistant turns on a relay.

Build dashboards

List widget types and their prop shapes, then create dashboards and place widgets — the assistant can assemble a view, not just read one.

Write automations

list_block_types exposes every trigger, condition and action with its config fields, so an assistant can compose a whole flow graph.

Drive integrations

Create, update and test-fire integrations. Secret config values are redacted on the way out, so credentials never reach the model.

Boundaries

Letting an AI near your hardware, carefully

Every capability above is gated. The defaults assume you have not thought about this yet, so nothing is exposed until you deliberately expose it.

Off by default

Two deployment flags, both off. mcp_enabled is the master switch; mcp_write_enabled gates everything that can change state. A fresh deployment exposes no MCP surface at all.

Disabled looks absent

While the master switch is off, /v1/mcp returns 404 rather than 403 — a disabled server looks like it was never there, instead of advertising something to probe.

Read-only until you say otherwise

Even an admin-scope token gets only the 12 read tools until the write flag is on. An assistant can look at everything and command nothing, which is the sane default.

Never more than the human

Every tool re-derives authority from the token creator's role and the token's project scope before it runs. MCP cannot reach a project, or take an action, that the person behind the token could not.

No delete tools, ever

There is no tool to delete a project, variable, dashboard, automation or integration. The destructive verbs are simply not in the surface, so no prompt can reach them.

Every write is audited

MCP-driven changes land in the audit log tagged as MCP-sourced, so an AI-initiated change is always distinguishable from one made in the web app or over the API.

The two flags live in Settings → More: mcp_enabled and mcp_write_enabled. Only the instance owner can change them.

Reference

Every tool

Read — always available when MCP is on

`list_projects`	List the projects this token can access.
`list_variables`	List declared variables (key, unit, last seen) for a project.
`get_state`	Get the latest value of every variable in a project.
`get_series`	Get recent time-series points for one variable.
`list_dashboards`	List dashboards in a project.
`get_dashboard`	Get one dashboard including its widget layout.
`list_widget_types`	List available widget types and their canonical prop shapes.
`list_widgets`	List widgets in a dashboard — id, type, position, props.
`list_block_types`	List automation block kinds — triggers, conditions, actions — with their config fields and ports.
`list_integration_kinds`	List integration kinds with their connection fields and operations.
`list_automations`	List automations — flow graph and last run status — in a project.
`list_integrations`	List integrations in a project. Secret config values are redacted.

Write — only with `mcp_write_enabled` and an admin-scope token

`create_project`	Create a project. Requires an owner/admin token.
`update_project`	Rename or re-describe a project.
`create_variable`	Declare a variable, optionally with a unit.
`update_variable`	Update a variable's unit.
`set_variable`	Enqueue a control write to hardware — the device picks it up on its next poll.
`create_dashboard`	Create a dashboard, with or without a starting widget grid.
`update_dashboard`	Update a dashboard name, description or layout, with optimistic concurrency.
`add_widget`	Add a widget to a dashboard and return the inserted widget.
`update_widget`	Update a single widget. Props replace rather than merge.
`create_automation`	Create an automation from a {nodes, edges} flow graph.
`update_automation`	Update an automation, or replace its whole flow graph.
`run_automation`	Run an automation now — drives manual automations, and acts as a test harness.
`emit_event`	Fire a named event, running any enabled event-triggered automations that match.
`create_integration`	Create an integration of any supported kind.
`update_integration`	Update an integration — name, config, enabled.
`test_integration`	Fire an integration once with a synthetic context to verify delivery.

There is no delete tool on either list, and that is not an oversight — the destructive verbs are absent from the surface entirely.

Discovery

In the official MCP registry

nodrix is published to the official MCP registry as live.nodrix/nodrix. Clients that resolve servers from the registry can add it by name — you still supply your own deployment's hostname, because the server runs in your Cloudflare account rather than ours.

FAQ

Does my telemetry get sent to Anthropic or OpenAI?

Only what the assistant actually asks for, and only when you have connected it. The MCP server runs inside your own Cloudflare account alongside your data — there is no nodrix-operated middleman that sees your projects. When an assistant calls get_state, that tool result goes to the model the same way any tool result does. Nothing is streamed or synced in the background, and with the server switched off nothing is reachable at all.

Which tools require the write toggle?

All sixteen management tools, including set_variable. With only mcp_enabled on, a client sees just the twelve read tools — the write tools are not registered, so they do not appear in the tool list at all rather than failing when called. Turning on mcp_write_enabled additionally requires the connecting token to be admin-scope.

Can an assistant delete my project or my data?

No. There are no delete tools in the MCP surface — not for projects, variables, dashboards, automations or integrations. This is a deliberate design constraint rather than a permission setting, so there is no toggle that turns destructive operations on.

Can I limit an assistant to one project?

Yes. Mint a project-scoped token and every tool resolves against that project only; an all-projects token is the one that can move between them. The scope is enforced server-side before the tool runs, so it is not something a prompt can talk its way around.

Does the hardware need to be plugged into the machine running the assistant?

No, and this is the main thing that separates it from most hardware MCP servers. Your devices report to your nodrix deployment, not to your laptop, so the assistant talks to the deployment. The board can be in another building. A control write is queued and delivered on the device’s next poll, so it also works with a battery sensor that is deep-sleeping when you ask.

Which AI clients can connect?

Anything that speaks MCP over Streamable HTTP. The OAuth endpoint suits browser clients like the claude.ai and ChatGPT connectors; the bearer endpoint suits Claude Code, Cursor and other token-configured tools. nodrix is also listed in the official MCP registry, so registry-aware clients can resolve it by name.

Keep exploring

Control your ESP32 with Claude The step-by-step walkthrough, from enabling the server to the first relay. A Claude Skill that writes ESP32 firmware The other half — generating the sketch, not just driving it. Voice-control an ESP32 Speaking to hardware, on top of the same primitives. Arduino library What runs on the board the assistant is talking to. Docs: MCP The short version, in context with the rest of the platform. Device protocol The HTTPS/WebSocket contract underneath it all.

Deploy the instance your assistant will talk to

Nodrix is free and open source — deploy it to your own Cloudflare account, connect your hardware, then switch the MCP server on when you're ready.

Deploy to Cloudflare Star on GitHub

One-click deploy provisions everything into your own Cloudflare account — nothing leaves it.