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, Redis and Kafka; 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, a Kafka client bridge, and embedded Kafka protocol server.
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.
Both brokers natively speak MQTT, NATS, Redis, and Kafka protocols with shared GraphQL APIs and byte-compatible database schemas. Choose Core for enterprise clustering and SCADA protocols, or Edge for lightweight gateways and camera vision.
|
Architecture Matrix
Capability & Specification
|
Central platform · JVM
MonsterMQ CoreKotlin • JVM • Vert.x Event Loop |
At the machine · Go
MonsterMQ EdgePure Go • Zero CGO • Single Binary |
|---|---|---|
| Runtime & Architecture | ||
|
Engine & Language
Underlying runtime and concurrency model
|
Kotlin & Java 21+ (Vert.x) |
Pure Go (1.22+, Zero CGO) |
|
Memory Footprint
Typical baseline operational RAM consumption
|
✓~256 MB – 1 GB+ (high-throughput scale) |
✓< 35 MB RAM (ultra-low embedded footprint) |
|
Deployment Packaging
Executable delivery format and image size
|
✓Multi-platform JAR / Docker (~300 MB) |
✓Single static binary (~25 MB) / Docker (~30 MB) |
|
Target Environments
Recommended hardware and operating profiles
|
✓Cloud, Kubernetes, VMs, IPCs, Plant Servers |
✓Raspberry Pi, Siemens Comfort Panels, Gateways |
| Client Wire Protocols (Inbound Servers) | ||
|
MQTT 3.1, 3.1.1 & 5.0
TCP, TLS, WebSocket (WS), and Secure WSS
|
✓Native engine (QoS 0/1/2, retain, user props) |
✓Native pure-Go engine (QoS 0/1/2, retain, props) |
|
Kafka Protocol Server (9092)
Standard Kafka clients produce & consume to MQTT topics
|
✓Embedded Kafka wire protocol server |
✓Embedded Kafka wire protocol server NEW |
|
NATS Protocol Server (4222)
NATS pub/sub, JetStream KV & automatic separator mapping
|
✓Native NATS listener + topic translation |
✓Native NATS listener + topic translation |
|
Redis Store Protocol (6379)
RESP wire protocol, GET/SET/SCAN directly on topic state
|
✓Redis RESP server protocol |
✓Redis RESP server protocol |
|
OPC UA Server
Direct node server exposing broker variables to SCADA
|
✓Embedded OPC UA server |
—Route via Core |
| Broker Federation & Industrial Bridges | ||
|
PeerLink Mesh (mmq-peer/1)
Dynamic interest routing, 64-bit sequence replay, mTLS
|
✓Full PeerLink mesh (Central / Active) |
✓Full PeerLink mesh (Edge / Source) |
|
Zenoh Live Federation
Live distributed pub/sub and storage queries
|
✓Zenoh live router & peer discovery |
—Connect via PeerLink to Core |
|
Kafka Client Bridge
Bidirectional link to external Apache Kafka clusters
|
✓Native Kafka producer/consumer bridge |
✓Pure-Go franz-go Kafka bridge |
|
MQTT-to-MQTT Bridge
Forward topics between remote MQTT brokers
|
✓Bidirectional MQTT broker bridge |
✓Bidirectional MQTT broker bridge |
|
Siemens WinCC OA
High-throughput SCADA tag bulk streaming
|
✓dpQueryConnectSingle over GraphQL/WS |
✓GraphQL/WS + embedded C++ API manager |
|
Siemens WinCC Unified
Industrial Edge runtime tag & alarm streaming
|
✓GraphQL/WS tag streaming |
✓GraphQL/WS & Open Pipe transport |
|
PLC4X & Sparkplug B
S7, Modbus, Allen-Bradley & Sparkplug B decoding
|
✓Direct PLC drivers & Sparkplug B decoder |
—Route via Core |
|
OPC UA Client
Browse paths, node IDs, wildcard subscriptions
|
✓High-performance OPC UA client |
—Route via Core |
| Edge Vision & Camera Streaming | ||
|
RTSP IP Camera Ingress
Direct H.264 / MJPEG network camera ingest
|
—Receives from Edge via PeerLink |
✓Native RTSP camera ingest |
|
Pure-Go H.264 Decoder
Zero CGO, no FFmpeg or GStreamer dependencies
|
—External decoder |
✓Pure Go decoder (ARM64/ARMv7 native) |
|
Circular Snapshot Slots
Round-robin picture buffer topics with JSON metadata
|
—Receives via PeerLink |
✓Configurable rotating slot buffers |
|
Live WebSocket MJPEG Stream
Direct browser stream at /api/camera/
|
—Stream via Edge |
✓Embedded low-latency MJPEG streaming |
| Storage, Persistence & Clustering | ||
|
Last Value Store (Digital Twin)
Persist latest topic value for instant queries
|
✓Full digital twin state persistence |
✓Full digital twin state persistence |
|
Pluggable Databases
Byte-compatible schemas across implementations
|
✓PostgreSQL, MongoDB, SQLite, CrateDB |
✓SQLite (pure Go), PostgreSQL, MongoDB, CrateDB, QuestDB |
|
Horizontal Clustering
Distributed node discovery & state replication
|
✓Hazelcast clustering (multi-node) |
—Mesh via PeerLink |
|
Neo4j & Time-Series Loggers
Graph topology export, InfluxDB/JDBC loggers
|
✓Neo4j, InfluxDB, JDBC & TimeBase |
—Log via Core |
| Web Apps, Scripting, AI & Developer Tools | ||
|
Embedded Scripting
Event-driven interceptors & message transforms
|
✓Python (GraalPy) & JavaScript (GraalJS) |
✓Starlark (pure Go deterministic Python) |
|
Visual Flow Engine
Drag-and-drop node-based message transformation
|
✓Built-in graphical Flow Engine |
—Process in Core |
|
Autonomous AI Agents
Agent-to-Agent hierarchy, triggers & memory (LangChain4j)
|
✓Full LangChain4j autonomous agent framework |
—Triggered via Core or MCP |
|
GenAI Assistant & MCP
Multi-provider LLM chat and Model Context Protocol server
|
✓Gemini, Claude, OpenAI, Ollama + MCP server |
✓Gemini, Claude, OpenAI, Ollama, LlamaCpp + MCP |
|
Embedded Web Apps & OTA Sync
Host static HMI dashboards & deploy bundles via MQTT
|
✓Direct web hosting & OTA bundle distribution |
✓Direct web hosting & local receiver sync |
|
GraphQL & REST APIs
Complete schema parity, InfluxDB line protocol & SSE
|
✓Full GraphQL subscriptions & REST API |
✓Full GraphQL subscriptions, REST & Raw Binary |
|
Prometheus & Grafana PromQL
Metrics scrape endpoint and Grafana query API
|
✓Prometheus /metrics scrape endpoint |
✓Prometheus /metrics + PromQL HTTP API |
|
MonsterMQ Developer CLI (mmq)
Terminal inspection, pub/sub, and state queries
|
✓Full mmq CLI support |
✓Full mmq CLI support |
Deploy MonsterMQ Edge close to machines and cameras, and MonsterMQ Core in the data center — federate both seamlessly over mmq-peer/1.
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.
Both Core and Edge natively speak the Kafka wire protocol on port 9092. Standard Kafka clients publish and subscribe directly, with record keys mapped to MQTT topics for bi-directional streaming without external 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