MCP Connectors

Plug Your Broker Into Any MCP Tool

MCP (Model Context Protocol) is an open standard that defines how applications communicate with external tool servers. MCP Connectors let your Coreflux broker connect to any MCP-compatible server — file systems, messaging platforms, cloud storage, spreadsheets, and more — and call their tools directly from LoT Actions.

This page is the MCP client connector (DEFINE CONNECTOR … WITH TYPE MCP and CALL MCP from Actions). The broker connects out to an external MCP server.To expose this broker as an MCP server for Cursor or Claude Desktop, use the MCP Server (Mcp.Enabled). TYPE MCP_SERVER was removed. The hosted documentation MCP searches docs.coreflux.org and does not control a broker.

A DEFINE AGENT does not receive this connector’s tools, and execute_routes cannot reach them. Call MCP tools from an Action with CALL MCP. To give an agent one tool, wrap the call in a callable action and grant that action with ADD TOOL "execute_actions". See Agents and MCP Tools.

Like adding power tools to a workbench. Each MCP Connector plugs a new tool into your broker — a Slack server for sending messages, a filesystem server for reading logs, a Google Drive server for cloud backups. Once connected, any LoT Action can pick up and use that tool.

Integration Architecture

MCP Connectors allow the Coreflux Broker to connect to external MCP servers as a client. This enables LoT Actions to call tools provided by any MCP server—file systems, cloud services, communication platforms, and more.

How It Works

Define MCP Connectors - Each connector connects to an external MCP server
Discover Tools - The broker discovers available tools from each server, once after it connects
Call from Actions - Use CALL MCP in LoT Actions to invoke any tool
Reusable Connections - Multiple actions can share the same MCP connector

MCP as a Connection Type. Just like database connectors or REST API connectors, MCP connectors provide a reusable connection that any action can leverage. Define the connector once, use it everywhere.

Basic Syntax

The MCP connector type connects your Coreflux broker to an external MCP server, making that server’s tools callable from LoT Actions. Each connector manages one MCP server connection, and you can define multiple connectors to connect to different servers simultaneously.

DEFINE CONNECTOR MCPFilesystem WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "npx"
        WITH SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-filesystem, /data"
        WITH CLIENT_NAME "CorefluxFS"

Once connected, any LoT Action can use CALL MCP to invoke the server’s tools — send Slack messages, read and write files, generate spreadsheet reports, or interact with any other MCP-compatible service.

MCP Configuration

MCP_CONFIG Parameters

A connector reaches its server in one of two ways. Set SERVER_COMMAND and SERVER_ARGUMENTS to start a local server process (stdio). Or set SERVER_URL to connect to a remote server over HTTP. When SERVER_URL is set, SERVER_COMMAND and SERVER_ARGUMENTS are not needed. Without it, -addConnector requires both.

string

MCP server command to execute (e.g., npx, python, node). Required unless SERVER_URL is set.

string

Comma-separated server arguments (e.g., -y, @modelcontextprotocol/server-filesystem). Required unless SERVER_URL is set.

string

URL of a remote MCP server (e.g., https://mcp.example.com/mcp). Replaces SERVER_COMMAND and SERVER_ARGUMENTS. The broker sends no authentication headers to this URL.

string

WITH SERVER_ENV "NAME" <value> sets one environment variable on the server process. Repeat the line for each variable. The value can be a string, a number, true/false, GET ENV "...", or GET SECRET "...", resolved when the connector starts. Applies only to a server started with SERVER_COMMAND.

string

MCP client identifier. Default: CorefluxBroker.

Configuration Examples

Filesystem Server
Custom MCP Server
Node.js Server
Server Credentials
Remote Server

Enable LoT Actions to perform file operations:

DEFINE CONNECTOR MCPFilesystem WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "npx"
        WITH SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-filesystem, /data"
        WITH CLIENT_NAME "CorefluxFS"

Connect to a custom MCP server:

DEFINE CONNECTOR MCPCustom WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "python"
        WITH SERVER_ARGUMENTS "-m, my_mcp_server"
        WITH CLIENT_NAME "CorefluxCustom"

Run a Node.js MCP server:

DEFINE CONNECTOR MCPNode WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "node"
        WITH SERVER_ARGUMENTS "/opt/mcp/server.js, --config, /etc/mcp/config.json"
        WITH CLIENT_NAME "CorefluxNode"

Pass an API key to a local server as an environment variable. Keep the key in a secret, not in the connector:

DEFINE CONNECTOR MCPNotion WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "npx"
        WITH SERVER_ARGUMENTS "-y, @notionhq/notion-mcp-server"
        WITH SERVER_ENV "NOTION_API_KEY" GET SECRET "NOTION_KEY"
        WITH SERVER_ENV "NOTION_CACHE_TTL" "300"

Connect to an MCP server over HTTP. No local Node.js or Python is needed:

DEFINE CONNECTOR MCPRemote WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_URL "https://mcp.example.com/mcp"
        WITH CLIENT_NAME "CorefluxRemote"

The broker sends no API key, token, or OAuth credentials to a SERVER_URL. Use a server that accepts unauthenticated calls from the broker’s network, or run the server locally with SERVER_COMMAND and pass its credentials with SERVER_ENV.

MCP Server Examples

The MCP ecosystem includes servers for various platforms and services. These examples show how to connect popular MCP servers to your Coreflux broker for IoT integration.

Node.js Servers (npx)
Python Servers (uvx)

Node.js-based MCP servers can be run directly using npx. These are the most common and include official Anthropic servers.

Server	LoT Configuration	IoT Use Case
Filesystem	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-filesystem, /data"`	Read sensor logs, manage config files
Google Drive	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-gdrive"`	Cloud backup of IoT data
Slack	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-slack"`	Send alerts to team channels
Memory	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-memory"`	Persist context across AI sessions
Fetch	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-fetch"`	Access external APIs and web data
Windows Control	`SERVER_COMMAND "npx"` with `SERVER_ARGUMENTS "-y, mcp-control"`	Automate HMI/SCADA systems

Example: Slack Alerts for IoT Events

DEFINE CONNECTOR MCPSlack WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "npx"
        WITH SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-slack"
        WITH CLIENT_NAME "CorefluxSlack"

Python-based MCP servers use uvx (the uv package runner). These are common for third-party integrations.

Server	LoT Configuration	IoT Use Case
Spotify	`SERVER_COMMAND "uvx"` with `SERVER_ARGUMENTS "spotify-mcp"`	Smart home audio control
Excel	`SERVER_COMMAND "uvx"` with `SERVER_ARGUMENTS "excel-mcp-server"`	Generate reports from sensor data

Example: Excel Reports from Sensor Data

DEFINE CONNECTOR MCPExcel WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "uvx"
        WITH SERVER_ARGUMENTS "excel-mcp-server"
        WITH CLIENT_NAME "CorefluxExcel"

Calling MCP Tools

Once an MCP connector is defined, you can call its tools from within LoT Actions using the CALL MCP syntax. This enables AI-powered automation triggered by MQTT events.

Basic Syntax

The standard syntax to invoke an MCP tool from an Action:

CALL MCP "RouteName.ToolName"
    WITH (arg1 = value1, arg2 = value2)
    RETURN AS {result_variable}

Component	Format	Description
Connector.Tool	`"RouteName.ToolName"`	Connector name and tool name separated by a dot
WITH	`WITH (name = value, ...)`	Named arguments in parentheses
RETURN AS	`RETURN AS {varname}`	Capture the result in a variable

Return Value

RETURN AS always receives a JSON string, also when the call fails. Check success before you use result:

{
  "success": true,
  "tool_name": "send-message",
  "route_name": "MCPSlack",
  "timestamp": "2026-10-23T12:00:00.000Z",
  "execution_time_ms": 150,
  "result": { }
}

Field	Description
`success`	`true` when the server ran the tool
`tool_name`	The tool that was called
`route_name`	The connector that called it
`timestamp`	UTC time of the reply
`execution_time_ms`	Time the call took, in milliseconds
`result`	The MCP server’s tool result. Present only on success
`error`	Why the call failed. Present only when `success` is `false`

A failed call has success: false and an error such as Tool 'X' not found. Available tools: ..., MCP client is not connected, or MCP route 'X' not found or not an MCP route.

CALL MCP "MCPSlack.send-message"
    WITH (channel = "alerts", message = "Line 2 stopped")
    RETURN AS {reply}
SET "sent" WITH (GET JSON "success" IN {reply} AS BOOL)
IF {sent} EQUALS FALSE THEN
    PUBLISH TOPIC "alerts/slack/error" WITH (GET JSON "error" IN {reply} AS STRING)
END IF

Complete Example

This Action monitors a temperature sensor and uses an MCP tool to send a Slack message when the temperature exceeds a threshold:

DEFINE ACTION TemperatureAlert
ON TOPIC "sensors/+/temperature" DO
    SET "temp" WITH (GET JSON "value" IN PAYLOAD AS DOUBLE)
    SET "sensor_id" WITH TOPIC POSITION 2
    
    IF {temp} > 80 THEN
        CALL MCP "MCPSlack.send-message"
            WITH (channel = "alerts", message = "🔥 Sensor " + {sensor_id} + " at " + {temp} + "°C")
            RETURN AS {result}
        
        PUBLISH TOPIC "alerts/temperature/sent" WITH "Sensor: " + {sensor_id} + " Temp: " + {temp} + " Result: " + {result}
    END IF

Syntax Variations

No Arguments

Some tools don’t require arguments:

CALL MCP "MCPSystem.get-status"
    RETURN AS {status}

Multiple Arguments

Pass multiple named parameters:

CALL MCP "MCPFilesystem.write-file"
    WITH (path = "/data/log.txt", content = {payload}, append = true)
    RETURN AS {write_result}

String Concatenation

Build dynamic values using expressions:

CALL MCP "MCPSlack.send-message"
    WITH (message = "Device " + {device_id} + " reported: " + {value} + " at " + TIMESTAMP "UTC")
    RETURN AS {chat_result}

Who Can Call Tools

CALL MCP has no permission check of its own. Any action that runs CALL MCP can call any tool on any configured MCP connector, whichever role deployed the action. So:

Only let trusted administrators add MCP connectors. Every tool those servers expose becomes callable from LoT.
Restrict which roles can add or change actions. A role that can deploy actions can reach every tool on every MCP connector.
To give an agent one tool, grant it one callable action with execute_actions. See Agents and MCP Tools.

Agents and MCP Tools

A DEFINE AGENT cannot call an MCP tool directly. ADD TOOL "execute_routes" does not help: an MCP connector runs nothing when one of its events is fired. Use a callable action as the bridge:

A callable action takes the tool arguments as INPUT, runs CALL MCP, and publishes the reply to a topic.
The agent runs that action with execute_actions, passing the inputs as a JSON object.
The agent reads the reply topic with read_mqtt.

DEFINE CONNECTOR MCPSlack WITH TYPE MCP
    ADD MCP_CONFIG
        WITH SERVER_COMMAND "npx"
        WITH SERVER_ARGUMENTS "-y, @modelcontextprotocol/server-slack"

DEFINE ACTION PostSlackMessage
INPUT channel AS STRING
INPUT message AS STRING
DO
    CALL MCP "MCPSlack.send-message"
        WITH (channel = {channel}, message = {message})
        RETURN AS {reply}
    PUBLISH TOPIC "agents/slack/last_reply" WITH {reply}

DEFINE AGENT ShiftReporter
    USES LLM CONNECTOR Claude
    WITH DESCRIPTION "Posts shift summaries to Slack"
    WITH DEFAULT_USER "shift-reporter"
    ADD TOOL "read_mqtt"
        WITH TOPICS "lines/#, agents/slack/last_reply"
    ADD TOOL "execute_actions"
        WITH TARGET "PostSlackMessage"
        WITH LEVEL "write"

Claude is a TYPE LLM connector. Create shift-reporter with -addUser before you add the agent. execute_actions tells the agent only that the action ran, with the action name and a trace id. It does not return the action’s output, so the reply goes through a topic. Grant one action per tool you want the agent to have. MCP_ROUTES is legacy. A TYPE LLM connector ignores it and logs a warning to use ADD TOOL, and -addAgent refuses it on DEFINE AGENT. Grant tools with ADD TOOL on the agent instead. See Coming from TYPE AGENT.

Tool Discovery

When an MCP connector connects to a server, Coreflux discovers the server’s tools about 10 seconds later and publishes them to MQTT system topics. Discovery runs once, after the connector connects. The broker ignores the server’s tools/list_changed notifications, so a tool the server adds or changes later shows up only after the connector reconnects.

System Topics

Topic	Description
`$SYS/Coreflux/Routes/{name}/Tools`	Summary of all tools for a connector
`$SYS/Coreflux/Routes/{name}/Tools/{tool}`	Detailed info for a specific tool
`$SYS/Coreflux/Routes/{name}/Tools/{tool}/Capability`	Call statistics for one tool, updated after every call

All three are retained. The broker republishes the summary and tool topics with its periodic status updates.

Tools Summary Payload

Subscribe to the summary topic to see all available tools:

{
  "route_name": "MCPSlack",
  "route_type": "MCP",
  "total_tools": 8,
  "tools": ["send-message", "list-channels", "get-channel-history", "add-reaction", ...],
  "capability_overview": {
    "total_executions": 42,
    "fast_tools": 3,
    "reliable_tools": 5,
    "avg_reliability": 97.5
  },
  "timestamp": "2026-10-23T12:00:00.000Z"
}

fast_tools counts tools rated FAST. reliable_tools counts tools rated EXCELLENT.

Individual Tool Payload

Each tool publishes its description, parameters, and call statistics:

{
  "name": "send-message",
  "description": "Send a message to a Slack channel",
  "parameters": {
    "channel": { "type": "string", "description": "Channel name or ID" },
    "message": { "type": "string", "description": "Message text" }
  },
  "route_name": "MCPSlack",
  "tool_type": "MCP",
  "capability": {
    "execution_count": 42,
    "average_latency_ms": 150.25,
    "min_latency_ms": 90,
    "max_latency_ms": 420,
    "success_count": 41,
    "failure_count": 1,
    "reliability_percent": 97.62,
    "performance_rating": "MEDIUM",
    "reliability_rating": "EXCELLENT",
    "first_executed": "2026-10-23T08:00:00.000Z",
    "last_executed": "2026-10-23T11:59:00.000Z",
    "last_error": ""
  },
  "timestamp": "2026-10-23T12:00:00.000Z"
}

Each parameter carries only type and description. An array parameter also carries items, which defaults to { "type": "string" }. The payload does not say which parameters are required. Read the tool’s description or the server’s own documentation for that. A tool that has never been called shows 0 counts, UNKNOWN ratings, and never for both dates. The first publish after discovery also carries usage_example (a ready CALL MCP block) and trigger_example (TRIGGER "MCPSlack" TO PAYLOAD FOR "send-message"). The periodic republish leaves them out.

Capability Payload

…/Tools/{tool}/Capability is published after every call to that tool:

Field	Description
`tool_name`, `route_name`	The tool and its connector
`execution_count`, `success_count`, `failure_count`	Calls since the connector started
`average_latency_ms`, `min_latency_ms`, `max_latency_ms`	Call time in milliseconds
`reliability_percent`	Share of calls that succeeded
`performance_rating`	`FAST` (under 100 ms), `MEDIUM` (under 500 ms), `SLOW` (under 2,000 ms), or `VERY_SLOW`
`reliability_rating`	`EXCELLENT` (95% or more), `GOOD` (85% or more), `FAIR` (70% or more), or `POOR`
`first_executed`, `last_executed`	UTC times of the first and latest call
`last_error`	Error of the latest failed call
`timestamp`	UTC time of this publish

Subscribing to Tool Discovery

Use MQTT Explorer or any MQTT client to discover available tools:

What to Find	Topic Pattern
All tools for a specific connector	`$SYS/Coreflux/Routes/MCPSlack/Tools`
Details for a specific tool	`$SYS/Coreflux/Routes/MCPSlack/Tools/send-message`
Call statistics for a specific tool	`$SYS/Coreflux/Routes/MCPSlack/Tools/send-message/Capability`
All tools across all MCP connectors	`$SYS/Coreflux/Routes/+/Tools/#`

Tool discovery topics are retained messages, so the information is immediately available when you subscribe—you don’t need to wait for the next update.

Use Cases

Alerting and Notifications

Connect to Slack, email, or other messaging MCP servers to send alerts directly from LoT Actions. When a sensor crosses a threshold, the Action calls the messaging tool — no external middleware needed.

File and Data Management

Use filesystem MCP servers to read configuration files, write sensor logs, or manage data exports. LoT Actions can read a config file at startup or append readings to a log file on every event.

Cloud Integration

Connect to Google Drive, Excel, or other cloud MCP servers to back up IoT data, generate reports from sensor readings, or sync configurations with cloud storage.

External Automation

Use Windows Control or custom MCP servers to automate HMI/SCADA interfaces, trigger external scripts, or interact with desktop applications as part of your IoT workflow.

Best Practices

Security Considerations

CALL MCP has no permission check. Restrict which roles can add or change actions, because any action can call any tool on a configured MCP connector. See Who Can Call Tools
SERVER_COMMAND starts any program on the broker host. Only let trusted administrators add MCP connectors
Pass server credentials with SERVER_ENV and GET SECRET, never as plain text in the connector
The broker sends no credentials to a SERVER_URL. Do not expose a remote MCP server that needs no key outside a trusted network
Monitor MCP tool calls through logging
Implement rate limiting for MCP requests

Resource Management

Configure appropriate timeouts for MCP operations
Limit concurrent MCP connections if needed
Monitor memory usage of MCP server processes

Error Handling

Implement graceful fallbacks when the MCP server is unavailable
Log MCP communication errors for debugging
Set up alerts for repeated failures

Troubleshooting

MCP Server Won't Start

Verify SERVER_COMMAND path is correct
Check SERVER_ARGUMENTS syntax (comma-separated)
Ensure required packages are installed (npx, node, python)
Check system PATH includes required executables

Connection Timeout

Verify MCP server is running and responsive
Check network/firewall settings
Increase timeout values if server startup is slow
Check server logs for errors

Tool Execution Fails

Verify the requested tool is available
Check permissions for the operation
Review server logs for detailed error messages
Ensure broker has required access rights

Next Steps

REST API Connectors

Connect to external REST APIs.

Python Integration

Add custom AI/ML logic with Python.

Quick Start

Coreflux MQTT Broker

LoT Language

Coreflux HUB

VS Code - LoT Notebooks

Coreflux Portal

Using AI with Coreflux

Product Updates

Plug Your Broker Into Any MCP Tool

Integration Architecture

How It Works

Basic Syntax

MCP Configuration

MCP_CONFIG Parameters

Configuration Examples

MCP Server Examples

Calling MCP Tools

Basic Syntax

Return Value

Complete Example

Syntax Variations

Who Can Call Tools

Agents and MCP Tools

Tool Discovery

System Topics

Tools Summary Payload

Individual Tool Payload

Capability Payload

Subscribing to Tool Discovery

Use Cases

Best Practices

Troubleshooting

Next Steps

REST API Connectors

Python Integration

​Plug Your Broker Into Any MCP Tool

​Integration Architecture

​How It Works

​Basic Syntax

​MCP Configuration

​MCP_CONFIG Parameters

​Configuration Examples

​MCP Server Examples

​Calling MCP Tools

​Basic Syntax

​Return Value

​Complete Example

​Syntax Variations

​Who Can Call Tools

​Agents and MCP Tools

​Tool Discovery

​System Topics

​Tools Summary Payload

​Individual Tool Payload

​Capability Payload

​Subscribing to Tool Discovery

​Use Cases

​Best Practices

​Troubleshooting

​Next Steps

REST API Connectors

Python Integration

Plug Your Broker Into Any MCP Tool

Integration Architecture

How It Works

Basic Syntax

MCP Configuration

MCP_CONFIG Parameters

Configuration Examples

MCP Server Examples

Calling MCP Tools

Basic Syntax

Return Value

Complete Example

Syntax Variations

Who Can Call Tools

Agents and MCP Tools

Tool Discovery

System Topics

Tools Summary Payload

Individual Tool Payload

Capability Payload

Subscribing to Tool Discovery

Use Cases

Best Practices

Troubleshooting

Next Steps