Run the full-featured JVM Core broker where data comes together. Put the lightweight Go Edge broker close to machines and cameras. Both speak MQTT, NATS and Redis; connect them with PeerLink to move messages between sites.
Deploy either broker on its own, or connect them across your factory with PeerLink.
The larger, full-featured broker for plant and enterprise workloads.
HTTP interfaces: GraphQL, REST with InfluxDB line-protocol ingestion, MCP, Redfish, CESMII I3X and Prometheus.
Federation: PeerLink and live Zenoh.
A lightweight, single-binary broker for gateways and constrained devices.
HTTP interfaces: GraphQL, REST with InfluxDB line-protocol ingestion, MCP, Redfish and Prometheus.
Also: PeerLink federation and a Kafka client bridge.
Link Edge and Core over the shared mmq-peer/1 protocol. Forward selected topics between brokers in either direction, with interest routing and replay after a disconnect.
Bridge OT and IT through MonsterMQ Core. Field devices and enterprise clients use standard wire protocols, while Go Edge brokers can forward remote data through PeerLink.
WinCC Unified, WinCC OA, S7, Modbus
H.264 & MJPEG snapshots via Go Edge and PeerLink
Direct node IDs, browse paths & decoders
Peer links with interest routing & replay
Native high-speed line protocol ingestion
The full-featured central broker: high-throughput routing, multi-protocol access, in-broker scripting and a unified digital twin. Go Edge brokers connect through PeerLink.
WebSocket MJPEG & circular snapshot slots
Direct HTML/JS hosting & WebSocket streams
LangChain4j, Gemini, Claude, Ollama
PostgreSQL, MongoDB, SQLite, CrateDB
Terminal inspection, tracing, and automation
Federate distributed edge brokers and enterprise clusters into a unified, resilient messaging fabric over authenticated mmq-peer/1 links. Featuring zero-loss sequence replay, active/standby redundancy, and intelligent interest routing that cuts edge uplink traffic by up to 90%.
factory/+/telemetry, +/alarms/#
Edge nodes forward only the topics downstream peers currently subscribe to. When cloud applications subscribe or unsubscribe, compact interest snapshots and delta frames update edge filters in sub-milliseconds—slashing cellular and edge bandwidth by up to 90%.
Every publish is assigned a monotonic 64-bit sequence offset in a high-speed ring buffer log. If an edge network or cellular link disconnects, peers resume seamlessly from their exact acknowledgment cursor with zero dropped messages and zero duplicates.
Deploy redundant edge or central pairs with automated role election, heartbeat liveness, and hot/cold standby switching. Inflight queues, retained state, and persistent MQTT sessions survive transparently across failovers.
Seamlessly bridge single-binary Go edge brokers on Raspberry Pi and Siemens Industrial Edge with high-throughput Kotlin/Vert.X clusters in the cloud. Unified by the lightweight, binary mmq-peer/1 protocol over mutual TLS.
Unlike traditional brokers that discard messages after delivery, MonsterMQ captures and persists the most recent value for every topic. Query current factory state anytime without waiting for the next sensor publish.
AI agents can query topic snapshots instantaneously before executing decisions. Ask "What is the temperature on Line 1?" and get current state without waiting for the next telemetry broadcast.
Access the last known value through GraphQL queries, REST endpoints, the Model Context Protocol (MCP) server, or direct SQL in database backends. All interfaces share the exact same state.
Get a comprehensive picture of your entire manufacturing plant in a single query — temperatures, pressures, active alarms, and motor states across thousands of topics.
Keep last values in memory for lightning speed, in Hazelcast for distributed cluster-wide consistency, or in PostgreSQL/CrateDB across broker restarts.
Transform any RTSP IP camera stream into MQTT topics directly at the edge. MonsterMQ Edge features a custom, 100% pure Go H.264 decoder with zero CGO, publishing continuous or triggered snapshots to circular buffer topics and streaming live MJPEG over WebSockets.
Zero CGO • No FFmpeg/GStreamer • ARM64 & ARMv7 Native
Configurable interval (e.g. 1 fps) to rotating slot topics
Photo-eye, PLC alarm, or AI trigger on cameras/cam1/trigger
{"slot": 3, "trigger": "sensor", "bytes": 142800}
Compiled with CGO_ENABLED=0 into a single, dependency-free binary. Runs out of the box on Raspberry Pi 4/5 (ARM64), industrial gateways, and legacy ARMv7 edge hardware without installing FFmpeg, OpenCV, or external C shared libraries.
Configurable number of round-robin slots ($N = 5, 10, 50$). Each slot provides paired binary picture (/frames/k) and JSON metadata (/frames/k/meta) topics, preventing memory leaks and unbounded storage growth.
Publish to <topic>/trigger from any PLC, edge rule, or vision sensor to capture immediate high-resolution snapshots directly into <topic>/capture/snapshot/pic and slot buffers.
Built-in WebSocket MJPEG broadcaster allows web dashboards, operator panels, and AI inspection apps to preview real-time video streams at /api/camera/<name>/stream with minimal latency.
Execute event-driven scripts directly inside the broker runtime with sub-millisecond overhead. Transform, filter, enrich, and route MQTT messages on the fly without deploying external services.
Whether running on a central MonsterMQ cluster via GraalVM polyglot runtimes, or at the edge on a Raspberry Pi using the lightweight Starlark engine (a deterministic, memory-safe Python dialect), scripts run natively alongside broker message routing.
scriptLanguages).# Triggered on message arriving at factory/+/telemetry
def on_message(topic, payload, properties):
# Parse incoming JSON payload
data = json.loads(payload)
temp = data.get("temperature", 0.0)
# Evaluate critical threshold condition
if temp > 85.0:
alarm_payload = json.dumps({
"source": topic,
"severity": "CRITICAL",
"value": temp,
"alert": "Overheating detected on production line"
})
# Publish alert & trigger camera snapshot
broker.publish("factory/alarms/critical", alarm_payload, qos=1)
broker.publish("cameras/inspection/trigger", "ALERT_TRIGGER")
# Return transformed payload for downstream routing
data["processed_at"] = timestamp()
return json.dumps(data)Serve responsive web applications directly from the broker, and manage your entire messaging infrastructure from the terminal with our dedicated developer tools.
Host and serve responsive web applications, custom SCADA dashboards, and operator HMIs directly from MonsterMQ without separate NGINX or Node.js web servers.
High-productivity terminal tooling for developers and automation engineers. Inspect live topic trees, stream message payloads, manage AI agents, and automate deployments.
A live production example of an embedded web application running directly on a Siemens WinCC Unified Comfort Panel via MonsterMQ Edge as a Siemens Industrial Edge App. It delivers a real-time SCADA dashboard connecting dual PV inverters, grid power meters, environmental sensors, and live camera vision streams — communicating with the local broker over WebSocket and GraphQL at http://panel:4000/graphql with instant Last Value Store hydration.
Deploy intelligent LLM agents inside MonsterMQ. Agents subscribe to MQTT topics, reason with AI models, call broker tools, and publish automated actions — with zero external orchestration.
Choose from Gemini, Claude, OpenAI, or local models via Ollama. Assign different models to individual agents and switch providers without changing agent code.
Agents subscribe to topic filters and react to live telemetry in real-time. When an anomaly or sensor threshold is reached, agents reason and respond instantly.
Schedule agents with cron expressions or fixed intervals for automated shift summaries and predictive analysis. Trigger on demand via GraphQL or REST.
Agents can query the Last Value Store, read message archives, publish control commands, and invoke custom business tools through LangChain4j annotations.
Expose MonsterMQ as an MCP Server and connect agents to external MCP tools. Seamlessly integrate third-party enterprise tools and diagnostic workflows.
Orchestrate multi-agent hierarchies over MQTT. Master supervisor agents delegate sub-tasks to specialized inspection agents and synthesize responses.
Sliding-window conversational memory with live plant snapshots injected from the Last Value Store, giving agents context on recent operations.
Configure, test, and monitor agents from the web dashboard or CLI. Live trace reasoning steps, token usage, and tool invocations without broker restarts.
Explore MonsterMQ's complete capability matrix across protocols, SCADA integration, edge computing, and enterprise data storage.
Inter-broker forwarding over the mmq-peer/1 protocol connecting Go Edge nodes and JVM clusters. Features zero-loss monotonic sequence replay, dynamic subscription interest routing, and active/standby high availability.
MonsterMQ Core shares live MQTT publications over Zenoh with peer discovery on a LAN or router-backed connections across networks. Native Zenoh apps can publish, subscribe and query retained or last-value state. Zenoh federation does not replay messages missed during an outage.
Zero CGO RTSP camera bridge for MonsterMQ Edge. Built-in pure Go H.264 & MJPEG decoder with ARM64/ARMv7 support, round-robin slot topics, MQTT snapshot triggers, and live WebSocket streaming.
Execute real-time event scripts directly inside the broker. Run Starlark (pure Go Python dialect) on Edge with zero CGO, or Python (GraalPy) and JavaScript (GraalJS) on MonsterMQ Core on incoming message hooks.
Synchronize and push HMI web application bundles directly across central brokers and remote edge panels over MQTT topics. Zero SSH, zero extra web servers, and instant browser hydration.
High-throughput HTTP REST endpoints for raw binary payload retrieval and wildcard topic reads, accompanied by low-latency WebSocket live streaming for images, sensors, and telemetry.
Deploy and host custom web applications, operator HMIs, and diagnostic dashboards directly from MonsterMQ. Instant WebSocket/SSE data streaming combined with Last Value Store state hydration.
High-productivity command-line tooling for developers and automation engineers. Live trace topic streams with colorized payloads, query factory state snapshots, and automate CI/CD pipelines via vogler/monster-mq-tools.
Natively speaks the Kafka wire protocol on port 9092. Standard Kafka clients publish and subscribe directly, with record keys mapped to MQTT topics for bi-directional routing without bridges.
MonsterMQ natively acts as a Redis Store. Redis clients can read and write keys directly to the broker while MQTT clients interact with the same data through topics. One datastore, two protocols.
Ultra-lightweight Go-based broker for constrained edge devices, Raspberry Pis, and Siemens Industrial Edge panels. Buffers data with store-and-forward routing to central clusters.
Persistently stores the most recent value for every topic. AI agents, web apps, and external systems can query current factory snapshots on demand without waiting for updates.
Built-in LangChain4j AI agent framework with multi-model support (Gemini, Claude, OpenAI, Ollama), broker tool execution, and MQTT event triggers.
Native OPC UA client with browse paths, node ID resolution, and wildcard subscriptions. Unifies industrial machine telemetry into standard MQTT topics.
High-performance continuous bulk transfer from Siemens WinCC Open Architecture via dpQueryConnectSingle. Streams millions of tag values and alerts with minimal overhead.
Modern SCADA streaming via GraphQL/WebSocket for Siemens WinCC Unified. Real-time tag subscriptions, active alarm streaming, and OPC UA quality code preservation.
Accept standard NATS clients on a dedicated port with automatic topic separator translation (/ to .). Supports NATS pub/sub and JetStream Key-Value buckets.
Bidirectional bridging between MQTT and external NATS servers with durable JetStream consumers and at-least-once delivery guarantees.
Bidirectional message forwarding between remote MQTT brokers with topic filters and transformation rules for hierarchical architectures.
Bidirectional MQTT-to-Redis bridging with PSUBSCRIBE glob matching, outbound publishing, and wildcard SCAN key synchronization.
Direct communication with Siemens S7, Allen-Bradley, and Modbus PLCs without gateways, bridging operational equipment directly into MQTT topics.
Automatically decodes compressed SparkplugB payloads and expands them into granular standard MQTT topics for standard clients and analytics.
Visual drag-and-drop flow-based programming with JavaScript runtime. Transform, filter, and aggregate real-time MQTT message streams.
Exposes MQTT topic structures as industrial object instances with parent-child hierarchies, historical telemetry, and Server-Sent Events.
Full GraphQL API with real-time subscriptions, REST endpoints, and native high-throughput InfluxDB Line Protocol ingestion.
Pluggable storage engines supporting PostgreSQL, MongoDB, CrateDB, and SQLite with full SQL querying across archived messages.
Built-in clustering for seamless horizontal scale, automatic node discovery, distributed session replication, and zero-downtime failover.
Validate MQTT payloads against reusable JSON Schema specifications with strict rejection, warning emission, or audit logging modes.
Exposes broker I/O stats, device metrics, and gauge topics. Includes a Prometheus HTTP API subset allowing Grafana to query historical data directly.
Converts MQTT topic hierarchies into graph nodes and relationships for topology mapping, path-based queries, and device connectivity analysis.
MonsterMQ adapts to your infrastructure. Choose the storage backend that fits your production workload — from lightweight embedded SQLite to distributed CrateDB and PostgreSQL.
| Backend / Protocol | Session Store | Retained Store | Last Value Store | Message Archive | Clustering Support |
|---|---|---|---|---|---|
| PostgreSQL | ✓ | ✓ | ✓ | ✓ | ✓ |
| MongoDB | ✓ | ✓ | ✓ | ✓ | ✓ |
| SQLite | ✓ | ✓ | ✓ | ✓ | ✗ |
| Redis Store Protocol | ✓ | ✓ | ✓ | ✗ | ✓ |
| Hazelcast In-Memory | ✓ | ✓ | ✓ | ✗ | ✓ |
Run MonsterMQ anywhere with Docker, Docker Compose, or deploy the CLI tools locally.
Launch MonsterMQ with the web dashboard, Last Value Store, and SQLite persistence:
docker run -d \
-p 1883:1883 \
-p 8080:8080 \
-p 9092:9092 \
-p 4222:4222 \
-p 6379:6379 \
--name monstermq \
vogler75/monster-mq:latestClone, compile with Go, and inspect topic streams or automate pipelines from your terminal:
# Clone and compile MonsterMQ Tools (Go 1.21+)
git clone https://github.com/vogler75/monster-mq-tools.git
cd monster-mq-tools
go build -o mmq .
# Subscribe to live topic streams
./mmq sub -t "factory/#" -b localhost:1883
# Or publish a test telemetry message
./mmq pub -t "factory/line1/temp" -m '{"value": 72.4}' -b localhost:1883