Architecture Digital Twin Edge Vision Scripting Web Apps & CLI AI Agents Features Databases Quick Start MonsterMQ CLI & Tools (GitHub) MonsterMQ Broker (GitHub)
Factory Automation • Multi-Protocol • Digital Twin

The Industrial Data & MQTT Backbone for
Connected Factories

High-performance, database-backed MQTT broker built on Vert.X, Hazelcast, and Go. Store the live state of every topic, stream pure Go RTSP camera vision with zero CGO, run real-time Python & Starlark scripts, host embedded web apps, and speak MQTT, Kafka, NATS, and Redis natively on one unified datastore.

⚡ Get Started 🌐 Try Demo Server ⌨️ Developer CLI
★ Pure Go RTSP Video Bridge ★ Python & Starlark Scripting ★ OTA HMI File Sync ★ Web Apps Runtime ✓ Kafka Protocol (9092) ✓ Redis Store Protocol ✓ NATS Server Protocol ✓ MQTT 5.0 & 3.1.1 ✓ Last Value Store ✓ Siemens WinCC Unified ✓ WinCC OA SCADA ✓ OPC UA Client ✓ PLC4X Industrial ✓ AI Agents (LangChain4j) ✓ MCP Server ✓ InfluxDB Line Protocol ✓ GraphQL Subscriptions ✓ Multi-Database SQL
Unified Industrial Backbone

One Datastore. Multiple Protocols. Real-Time State.

Bridge OT and IT seamlessly. Field devices and enterprise clients connect directly to MonsterMQ over standard wire protocols with zero intermediate translation bridges.

🏭

Siemens SCADA & PLCs

WinCC Unified, WinCC OA, S7, Modbus

📹

RTSP Video Cameras

H.264 & MJPEG streams, snapshots & trigger feeds

📡

OPC UA & SparkplugB

Direct node IDs, browse paths & decoders

📦

MonsterMQ Edge Nodes

Store-and-forward edge runtimes

📈

Telegraf & InfluxDB

Native high-speed line protocol ingestion

Vert.X + Hazelcast + Go Engines

MonsterMQ Core & Edge Brokers

High-throughput non-blocking routing, pure Go H.264 video decoding, in-broker Python/Starlark scripts & unified digital twin.

MQTT 5.0 / 3.1.1 Kafka Wire (9092) NATS Core & JetStream Redis Store Protocol Pure Go H.264 Decoder Python & Starlark Scripts Embedded Web Apps Last Value Digital Twin
📺

Live Video & Snapshots

WebSocket MJPEG & circular snapshot slots

💻

Embedded Web Apps

Direct HTML/JS hosting & WebSocket streams

🤖

AI Agents & MCP

LangChain4j, Gemini, Claude, Ollama

🗄️

Database Persistence

PostgreSQL, MongoDB, SQLite, CrateDB

⌨️

CLI & Developer Tools

Terminal inspection, tracing, and automation

Live Digital Twin

Always Know Your Factory State

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.

Field Telemetry
🌡️ Temp Sensor 1 72.4 °C
⏱️ Pressure Line A 3.2 bar
⚙️ Motor Drive RPM 1480 RPM
📦 Conveyor State RUNNING
LAST VALUE STORE (PERSISTENT STATE) SNAPSHOT READY
factory/line1/temperature 72.4
factory/line1/pressure 3.2
factory/line1/motor/rpm 1480
factory/line1/conveyor Running
Instant Query APIs
🤖 AI Agents & Tool Calls
💻 Embedded Web Apps
📊 GraphQL & REST APIs
⌨️ mmq CLI State Commands
🤖

Agent-Ready Context

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.

🔍

Multi-Protocol Queries

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.

⚡

Instant Digital Twin

Get a comprehensive picture of your entire manufacturing plant in a single query — temperatures, pressures, active alarms, and motor states across thousands of topics.

🗄️

Pluggable Persistence

Keep last values in memory for lightning speed, in Hazelcast for distributed cluster-wide consistency, or in PostgreSQL/CrateDB across broker restarts.

Edge Vision & Zero-CGO Video

RTSP Camera Bridge & Pure Go H.264 Decoding

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.

RTSP STREAM INGRESS
rtsp://camera.local:554/stream1
LIVE FEED (H.264 / MJPEG)
1080p @ 30fps RFC 6184 NAL / STAP-A / FU-A
MONSTERMQ EDGE (PURE GO)

Built-in H.264 & MJPEG Engine

Zero CGO • No FFmpeg/GStreamer • ARM64 & ARMv7 Native

Baseline / Main / High 8-bit CAVLC & CABAC I/P/B Frames
⏱️
Continuous Mode

Configurable interval (e.g. 1 fps) to rotating slot topics

⚡
MQTT Trigger Topic

Photo-eye, PLC alarm, or AI trigger on cameras/cam1/trigger

CIRCULAR SNAPSHOT SLOTS & WEBSOCKET
📌 LATEST POINTER cameras/cam1/capture/latest
{"slot": 3, "trigger": "sensor", "bytes": 142800}
Slot 1 .../frames/1 & .../frames/1/meta
Slot 2 .../frames/2 & .../frames/2/meta
Slot 3 (Active) .../frames/3 & .../frames/3/meta
📡 Live WebSocket MJPEG ws://edge:4000/api/camera/.../stream
🚀

100% Pure Go — Zero CGO

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.

🔄

Circular Buffer Slot Topics

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.

⚡

Sensor-Triggered Captures

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.

📺

Live WebSocket Streaming

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.

On-Broker Computation

Embedded Scripting Engines (Python, Starlark, JS)

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.

Python (GraalPy) Starlark (Pure Go Edge) JavaScript (GraalJS)

Intelligence at the Message Layer

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.

  • ✓
    Real-Time Message Hooks: Intercept and transform payloads on publish before storing or forwarding.
  • ✓
    Zero CGO Edge Scripting: Starlark runs with zero external dependencies on MonsterMQ Edge.
  • ✓
    AI Prompt Skills & Docs: Built-in AI generation skills and dynamic documentation exposed via GraphQL (scriptLanguages).
  • ✓
    Interactive Dashboard Sandbox: Test scripts directly in the web dashboard against sample payloads with instant outputs.
🐍 on_message.py — Python / Starlark Hook
ACTIVE HOOK 
# 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)
Developer Experience & Edge Applications

Embedded Web Apps & MonsterMQ CLI

Serve responsive web applications directly from the broker, and manage your entire messaging infrastructure from the terminal with our dedicated developer tools.

💻

Embedded Web Apps

Broker Native

Host and serve responsive web applications, custom SCADA dashboards, and operator HMIs directly from MonsterMQ without separate NGINX or Node.js web servers.

  • ✓
    Zero Extra Web Servers: Package HTML, CSS, and JS directly in MonsterMQ for instant local serving.
  • ✓
    Over-the-Air (OTA) MQTT File Sync: Push HMI UI bundles and web apps directly to edge panels over MQTT topics with zero SSH or external file servers.
  • ✓
    Instant State Hydration: Web apps immediately load current topic states from the Last Value Store upon connection.
  • ✓
    Real-Time Data Streaming: Sub-millisecond updates over native WebSockets, SSE, and GraphQL subscriptions.
  • ✓
    Integrated Security: Inherit broker-level authentication, role-based ACLs, and TLS protection.
🌐 Browser / Operator HMI HTTP / WebSocket
⚡ MonsterMQ Web App Engine Direct Hosting & SSE
📌 Last Value Store & Topics Unified Real-Time State
⌨️

MonsterMQ CLI

Developer Toolset

High-productivity terminal tooling for developers and automation engineers. Inspect live topic trees, stream message payloads, manage AI agents, and automate deployments.

  • ✓
    Live Topic Tree & Inspection: Interactive terminal browser with syntax-highlighted JSON decoding.
  • ✓
    Snapshot & Archive Queries: Fast terminal reads against the Last Value Store and database archives.
  • ✓
    AI Agent Diagnostics: Trigger agents, inspect execution traces, and view tool calls in real time.
  • ✓
    CI/CD & Scripting: Easily automate topic provisioning, schema enforcement, and health monitoring.
monster-mq-tools — terminal
$ go build -o mmq .
✔ Compiled mmq CLI binary for local architecture $ ./mmq sub -t "factory/+/alarms" -b localhost:1883
{"level":"WARN","source":"motor/rpm","val":1480,"ts":"16:01:25Z"} $ ./mmq pub -t "factory/line1/cmd" -m "START" -b localhost:1883
✔ Published message to factory/line1/cmd (QoS 1)
View vogler/monster-mq-tools on GitHub
Siemens Industrial Edge WinCC Unified Comfort Panel MonsterMQ Edge SCADA

Real-World Web App: Deployed on Siemens WinCC Unified Comfort Panel

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.

🔒 http://panel:4000/ • SmartHome OS (MonsterMQ Edge SCADA)
LIVE BROKER
MonsterMQ Web App deployed on Siemens WinCC Unified Comfort Panel as a Siemens Industrial Edge App
Autonomous Intelligence

AI Agents Built Directly into the Broker

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.

🧠

Multi-Provider LLMs

Choose from Gemini, Claude, OpenAI, or local models via Ollama. Assign different models to individual agents and switch providers without changing agent code.

📡

MQTT Event Triggers

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.

⏱️

Cron & Manual Execution

Schedule agents with cron expressions or fixed intervals for automated shift summaries and predictive analysis. Trigger on demand via GraphQL or REST.

🔧

Broker Tools & LangChain4j

Agents can query the Last Value Store, read message archives, publish control commands, and invoke custom business tools through LangChain4j annotations.

🔗

Model Context Protocol (MCP)

Expose MonsterMQ as an MCP Server and connect agents to external MCP tools. Seamlessly integrate third-party enterprise tools and diagnostic workflows.

🤝

Agent-to-Agent (A2A)

Orchestrate multi-agent hierarchies over MQTT. Master supervisor agents delegate sub-tasks to specialized inspection agents and synthesize responses.

💾

Memory & Live Context

Sliding-window conversational memory with live plant snapshots injected from the Last Value Store, giving agents context on recent operations.

🖥️

Live Dashboard Monitoring

Configure, test, and monitor agents from the web dashboard or CLI. Live trace reasoning steps, token usage, and tool invocations without broker restarts.

Complete Feature Set

Built for Industrial Scale & Reliability

Explore MonsterMQ's complete capability matrix across protocols, SCADA integration, edge computing, and enterprise data storage.

EDGE VISION
📹

RTSP Camera Bridge & Pure Go H.264

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.

SCRIPTING
🐍

Python, Starlark & JS Scripting

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 Main broker on incoming message hooks.

🔄

Over-the-Air (OTA) HMI Sync

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.

⚡

Raw Binary REST & WebSocket Streams

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.

WEB APPS
💻

Embedded Web Apps

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.

CLI TOOLS
⌨️

MonsterMQ CLI & Tools

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.

KAFKA
📨

Kafka Streaming Broker

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.

REDIS
🔴

Redis Store Protocol

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.

EDGE
📦

MonsterMQ Edge

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.

DIGITAL TWIN
📌

Last Value Store

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.

🤖

AI Agent Runtime

Built-in LangChain4j AI agent framework with multi-model support (Gemini, Claude, OpenAI, Ollama), broker tool execution, and MQTT event triggers.

🏭

OPC UA Client

Native OPC UA client with browse paths, node ID resolution, and wildcard subscriptions. Unifies industrial machine telemetry into standard MQTT topics.

🏭

WinCC OA SCADA Integration

High-performance continuous bulk transfer from Siemens WinCC Open Architecture via dpQueryConnectSingle. Streams millions of tag values and alerts with minimal overhead.

🏭

WinCC Unified SCADA Integration

Modern SCADA streaming via GraphQL/WebSocket for Siemens WinCC Unified. Real-time tag subscriptions, active alarm streaming, and OPC UA quality code preservation.

⚡

Native NATS Protocol

Accept standard NATS clients on a dedicated port with automatic topic separator translation (/ to .). Supports Core NATS and JetStream.

🔗

NATS Client Bridge

Bidirectional bridging between MQTT and external NATS servers with durable JetStream consumers and at-least-once delivery guarantees.

🔗

MQTT Broker Bridge

Bidirectional message forwarding between remote MQTT brokers with topic filters and transformation rules for hierarchical architectures.

🔴

Redis Pub/Sub & Key Sync

Bidirectional MQTT-to-Redis bridging with PSUBSCRIBE glob matching, outbound publishing, and wildcard SCAN key synchronization.

🔧

Apache PLC4X Direct Connectivity

Direct communication with Siemens S7, Allen-Bradley, and Modbus PLCs without gateways, bridging operational equipment directly into MQTT topics.

⚡

SparkplugB Decoder

Automatically decodes compressed SparkplugB payloads and expands them into granular standard MQTT topics for standard clients and analytics.

🔀

Workflows & Flow Engine

Visual drag-and-drop flow-based programming with JavaScript runtime. Transform, filter, and aggregate real-time MQTT message streams.

🔌

CESMII I3X REST API

Exposes MQTT topic structures as industrial object instances with parent-child hierarchies, historical telemetry, and Server-Sent Events.

🌐

GraphQL & InfluxDB Line Protocol

Full GraphQL API with real-time subscriptions, REST endpoints, and native high-throughput InfluxDB Line Protocol ingestion.

🗄️

Multi-Database Backends

Pluggable storage engines supporting PostgreSQL, MongoDB, CrateDB, and SQLite with full SQL querying across archived messages.

🔄

Horizontal Hazelcast Clustering

Built-in clustering for seamless horizontal scale, automatic node discovery, distributed session replication, and zero-downtime failover.

🛡️

JSON Schema Governance

Validate MQTT payloads against reusable JSON Schema specifications with strict rejection, warning emission, or audit logging modes.

📈

Prometheus Metrics Endpoint

Exposes broker I/O stats, device metrics, and gauge topics. Includes a Prometheus HTTP API subset allowing Grafana to query historical data directly.

🕸️

Neo4j Graph Conversion

Converts MQTT topic hierarchies into graph nodes and relationships for topology mapping, path-based queries, and device connectivity analysis.

Pluggable Datastores

Flexible Storage Backends & Redis Protocol

MonsterMQ adapts to your infrastructure. Choose the storage backend that fits your production workload — from lightweight embedded SQLite to distributed CrateDB and PostgreSQL.

PostgreSQL

PostgreSQL

  • ✓ Full relational SQL capabilities
  • ✓ Production-proven enterprise ACID
  • ✓ Cluster & replication support
  • ✓ Advanced time-series extensions
Best for: Production enterprise deployments with SQL requirements
MongoDB

MongoDB

  • ✓ Flexible JSON document store
  • ✓ Dynamic schema adaptation
  • ✓ High write throughput
  • ✓ Built-in horizontal sharding
Best for: Flexible NoSQL payloads and high-volume JSON streams
SQLite

SQLite

  • ✓ Zero configuration setup
  • ✓ Embedded single-file database
  • ✓ Lightweight memory footprint
  • ✓ Fast local read/write performance
Best for: Development, edge devices, and single-instance nodes
Redis

Redis Store Protocol

  • ✓ Native Redis wire protocol support
  • ✓ Direct read/write to broker state
  • ✓ Identical data shared with MQTT topics
  • ✓ Sub-millisecond in-memory speed
Best for: Dual Redis & MQTT client access against unified broker state

Backend Capability & Persistence Matrix

Backend / Protocol Session Store Retained Store Last Value Store Message Archive Clustering Support
PostgreSQL ✓ ✓ ✓ ✓ ✓
MongoDB ✓ ✓ ✓ ✓ ✓
SQLite ✓ ✓ ✓ ✓ ✗
Redis Store Protocol ✓ ✓ ✓ ✗ ✓
Hazelcast In-Memory ✓ ✓ ✓ ✗ ✓
Deployment in Seconds

Get Started with MonsterMQ

Run MonsterMQ anywhere with Docker, Docker Compose, or deploy the CLI tools locally.

🐳 Docker Run (Standalone)

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:latest

⌨️ MonsterMQ CLI Toolset (Go)

Clone, 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