Node-RED MCP. Control flows, nodes, and system health via conversation.
Node-RED MCP lets you control complex, event-driven workflows directly through your AI agent. Manage entire IoT pipelines and low-code applications without leaving the chat window. You can check system diagnostics, update flow logic, or install new node modules just by asking your agent.
Give Claude and any AI agent real-world access
Create new workflows, delete unused tabs, retrieve existing flows, or modify running logic.
List all installed modules, install missing packages, and remove obsolete nodes from your system.
Get immediate diagnostics on the Node.js version, operating system details, and current memory usage of the runtime environment.
Fetch the active operational settings to understand what constraints or variables your workflow is running under.
Ask an AI about this
Waiting for input…
What AI agents can do with Node-RED MCP with 11 Tools
These tools give your agent the ability to perform every action needed to build, monitor, and debug a Node-RED workflow environment.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Node-RED MCPAdd Flow
Creates a brand-new, empty workflow tab within your Node-RED instance.
Delete Flow
Removes an entire flow configuration (tab) from the active workspace.
Get Diagnostics
Retrieves a detailed report on system diagnostics, including OS version and memory...
Get Flow
Pulls the configuration details for one specific workflow tab you want to inspect.
Get Flows
Lists all currently active flow configurations available in your Node-RED...
Get Nodes
Retrieves a list of every node module that is currently installed on the system.
Install Node
Adds and installs a specified new node module package into your environment.
Remove Node
Deletes an installed node module package from the system to clean up dependencies.
Set Flows
Sets or switches the active flow configuration that Node-RED is currently focused on.
Get Settings
Fetches all current runtime operational settings for the entire Node-RED instance.
Update Flow
Modifies and saves changes to a specific, existing flow configuration tab.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on each call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Node-RED, then connect any of our 5,200+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,200+ others, all in one place
- Add new capabilities to your AI anytime you want
- Connections are secured and governed automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog weekly
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Node-RED. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS CLOUD
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on each call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
The headache of manual workflow maintenance
Today, managing complex automation means constant context switching. You start in the Node-RED editor to build a flow; you jump to the terminal to check if the required node is installed and what memory usage looks like. Then you might switch to a dashboard view just to see the current operational settings before you even try to save a change.
With this MCP, your agent handles all those jumps. You tell it, 'Check the system health and update the data logging flow.' It runs get_diagnostics for you, verifies dependencies using get_nodes, and executes the necessary updates via update_flow. Everything happens in one conversation.
Node-RED MCP: Full Control Over Your Automation
You stop manually running `npm list` every time you suspect a dependency issue, and you stop copy-pasting flow structures between local files and the editor. Instead, your agent executes get_nodes and then uses install_node or remove_node when needed.
Your workflow logic is now fully controllable via chat commands. You don't just monitor; you actively manage the entire stack—from OS diagnostics to individual node dependencies.
What Node-RED MCP does for your AI
Running automated systems means dealing with constantly changing flows, dependencies, and runtime errors. This MCP gives you a single connection point to manage those complexities in Node-RED. Instead of jumping between the editor GUI, terminal logs, and configuration files, you talk to your AI client. Your agent handles reading existing flow configurations, updating nodes, or checking system health.
When you connect this capability via Vinkius, it becomes part of a larger catalog of tools, letting you orchestrate much more than just Node-RED. You can ask your agent to troubleshoot a memory spike and get the live diagnostics report instantly. This means complex, mission-critical automation is now controllable through simple conversation.
019e38c9-40ea-71e7-ab60-7936df3e2d0d How to set up Node-RED MCP
The bottom line is that your AI client routes complex flow and system commands through this MCP, giving you full control over the entire Node-RED environment from a single chat interface.
First, subscribe to this MCP and provide your Node-RED Base URL and Access Token.
Next, authorize your preferred AI client—Claude, Cursor, or any other MCP-compatible agent—to access the connection.
Finally, tell your agent what you need. You can ask it to 'show me all active flows' or 'install the weather node,' and it executes the command instantly.
Who uses Node-RED MCP
This is for the DevOps Engineer who needs to check runtime diagnostics at 3 AM without SSHing into multiple servers. It's for the Automation Developer tired of context switching between three different tools just to update a single flow, and for the IoT specialist managing edge devices remotely.
Checks system diagnostics and runtime settings across multiple Node-RED instances without logging into individual machines.
Monitors, modifies, and deploys edge computing flows directly through the conversation interface, eliminating terminal time sinks.
Deploys new flow logic or manages node dependencies by simply describing the change to their agent.
Benefits of connecting Node-RED MCP
You check the overall state of your environment using get_diagnostics. You instantly know if a memory spike is due to OS limits or an internal application leak, without manually checking server logs.
Updating complex logic used to require multiple manual steps: copying JSON definitions and pasting them into different dashboards. Now you can use update_flow and tell your agent exactly what change needs implementing.
Dependency management gets simple. Instead of remembering the npm command or searching documentation, you just ask your agent to install a missing piece using install_node.
The ability to see everything with get_flows is huge. You immediately know which automation pathways exist and can use get_flow on any specific tab without navigating away from your chat interface.
You manage the entire lifecycle of an application: list dependencies with get_nodes, add new ones with install_node, and remove them later with remove_node—all conversationally controlled.
Node-RED MCP use cases
The critical flow failure
A smart home automation fails after a firmware update. Instead of logging into the server to check logs, you ask your agent to get_diagnostics. You see Node.js is running an outdated version and need to upgrade. Your agent reports the current setup (get_settings), allowing you to quickly determine the necessary patch.
Adding a new data source
You need your IoT dashboard to pull weather data, but the node isn't installed. You tell your agent, and it uses install_node. It confirms the installation, and then you use get_nodes to verify the module is now available for building the flow.
Auditing an old project
A new team member needs to understand a complex workflow built months ago. You ask your agent to get_flows, which lists all active tabs. You then use get_flow on specific IDs to show the entire structure without having to manually recreate or navigate the whole thing.
Refactoring an obsolete module
A project is winding down and you need to clean up dependencies. Instead of searching your file system, you use get_nodes to list everything installed. You then instruct the agent to remove_node for outdated modules.
Node-RED MCP tradeoffs
What to watch out for, and the recommended way to handle each one.
Manual GUI Navigation
Logging into Node-RED via a web browser, clicking through menus, manually checking dependencies in different tabs, and then switching back to the terminal for diagnostics.
Use your agent. Ask it to get_diagnostics first. Then use get_flows to see all paths. Finally, ask it to install_node if anything is missing.
Vague Configuration Changes
Telling a teammate, 'Hey, can you just change the flow?' This forces them to manually find the correct tab, understand the JSON structure, and then apply the changes.
Use the specific tools. Tell your agent: 'Please use get_flow on ID X to review it, and then update_flow with this new logic.' It handles the specifics.
Unverified Dependencies
Assuming a necessary node is installed because you used that module last week. You only find out later that the dependency was removed or never properly set up.
Always start by calling get_nodes to verify every single required module is present before building or running any flow.
When to use Node-RED MCP
Use this MCP if your primary bottleneck is context switching between configuration tools and live monitoring. You need an agent that can manage the entire lifecycle of a low-code application—from initial setup (add_flow) to runtime maintenance (get_diagnostics). Don't use it if you only need to read static data; for simple reads, just asking 'what are my flows?' is enough. However, if your job requires making changes or confirming system health before making those changes, this MCP is essential because it gives your agent the necessary write access (update_flow, install_node) and read capabilities (get_diagnostics). If you only need to monitor a single endpoint without changing its configuration, other monitoring tools might suffice. But for deep flow control, stick with this.
Frequently asked questions about Node-RED MCP
How do I check if my Node-RED instance has enough memory using the Node-RED MCP? +
You run get_diagnostics. This tool provides a full report, including live details on OS and current memory usage, letting you know immediately if resources are constrained.
Can I see all my existing workflows using the Node-RED MCP? +
Yes, use get_flows. This tool lists every active flow configuration available in your workspace, giving you a clear overview of your automation paths.
What if I need to add a new node module? Which tool should I use with the Node-RED MCP? +
You use install_node. Simply tell your agent what package name needs adding, and it handles the installation process for you.
How do I update an old flow without losing data using the Node-RED MCP? +
You can use update_flow. You provide the specific ID of the flow you want to change, and your agent applies the modifications while keeping the existing structure intact.
Does the Node-RED MCP let me see what settings my instance is running? +
Yes, run get_settings. This tool fetches all current runtime operational parameters for the entire system, so you know exactly how your application behaves out of the box.