Communication infrastructure for the AI era — one binary, one broker, one storage layer, any protocol

What is RobustMQ • mq9 • Features • Roadmap • Quick Start • Documentation • Contributing • Community

---

⚠️ Development Status RobustMQ is in early development and not yet production-ready. MQTT core is stable and continuing to mature. Kafka, NATS, and AMQP are under active development. Production readiness is targeted for 0.4.0.

---

🌟 What is RobustMQ

RobustMQ is a unified messaging engine built with Rust. One binary, one broker, no external dependencies — deployable from edge devices to cloud clusters. It natively supports MQTT, Kafka, NATS, AMQP, and mq9 on a shared storage layer: one message written once, consumed by any protocol.

MQTT publish  →  RobustMQ unified storage  →  Kafka consume
                                           →  NATS subscribe
                                           →  AMQP consume
                                           →  mq9 Agent mailbox

Five protocols, one system:

Protocol	Best for
MQTT	IoT devices, edge sensors
Kafka	Streaming data pipelines, analytics
NATS	Ultra-low-latency pub/sub
AMQP	Enterprise messaging, RabbitMQ migration
mq9	AI Agent async communication

🤖 mq9 — Agent Mailbox for AI

mq9 is RobustMQ's communication layer designed for AI Agents. Just like people have email — you send a message, the recipient reads it when they're available — Agents need the same. Today, when Agent A sends a message to Agent B and B is offline, the message is gone. Every team works around this with Redis pub/sub, database polling, or homegrown queues.

mq9 solves it directly: send a message, the recipient gets it when they come online.

Operation	Subject	What it does
MAILBOX.CREATE	$mq9.AI.MAILBOX.CREATE	Create a private or public mailbox
Send	$mq9.AI.MAILBOX.{mail_id} / $mq9.AI.MAILBOX.{mail_id}.urgent / $mq9.AI.MAILBOX.{mail_id}.critical	Deliver a message — three levels: critical / urgent / normal (default, no suffix)
Subscribe	$mq9.AI.MAILBOX.{mail_id}.*	Receive all non-expired messages; new arrivals pushed in real time

# Create a private mailbox — returns mail_id
nats pub '$mq9.AI.MAILBOX.CREATE' '{"ttl":3600}'
# → {"mail_id": "m-uuid-001"}

# Send to another Agent's mailbox (works even if they're offline)
nats pub '$mq9.AI.MAILBOX.m-uuid-002' '{"msg_id":"msg-001","from":"m-uuid-001","type":"task_result","payload":"done","ts":1234567890}'

# Create a public mailbox (task queue), discoverable via PUBLIC.LIST
nats pub '$mq9.AI.MAILBOX.CREATE' '{"ttl":3600,"public":true,"name":"task.queue","desc":"Task queue"}'
nats pub '$mq9.AI.MAILBOX.task.queue' '{"msg_id":"t-001","type":"data_analysis"}'

# Subscribe to your own mailbox — receives all non-expired messages immediately
nats sub '$mq9.AI.MAILBOX.m-uuid-001.*'

Multiple integration paths: any NATS client connects directly; the RobustMQ SDK covers Go, Python, Rust, JavaScript, Java, and C#; the langchain-mq9 toolkit plugs into LangChain and LangGraph; and an MCP Server provides JSON-RPC 2.0 access for tools like Dify.

mq9 is RobustMQ's fifth native protocol, alongside MQTT, Kafka, NATS, and AMQP, built on the same unified storage layer. Deploy one RobustMQ instance — mq9 is ready.

📖 mq9 Documentation

---

✨ Features

• 🤖 mq9 — AI Agent communication: Agent mailboxes, priority queuing, public discovery — async Agent-to-Agent messaging, no simultaneous online required
• 🦀 Rust-native: No GC, stable and predictable memory footprint, no periodic spikes — consistent from edge devices to cloud clusters
• 🗄️ Unified storage layer: All protocols share one storage engine — data written once, consumed by any protocol, no duplication
• 🔌 Native multi-protocol: MQTT 3.1/3.1.1/5.0, Kafka, NATS, AMQP, mq9 — natively implemented, full protocol semantics
• 🏢 Native multi-tenancy: Unified across all protocols — full data isolation and independent permission management per tenant
• 🌐 Edge-to-cloud: Single binary, zero dependencies, offline buffering with auto-sync — same runtime from edge gateways to cloud clusters
• ⚡ Ultra-low-latency dispatch: NATS pure in-memory routing — no disk writes, millisecond to sub-millisecond latency
• 💾 Multi-mode storage: Memory / RocksDB / File, per-topic configuration, automatic cold data tiering to S3
• 🔄 Shared subscription: Break the "concurrency = partition count" limit — consumers scale elastically at any time
• 🛠️ Minimal operations: Single binary, zero external dependencies, built-in Raft consensus, ready out of the box

🗺️ Roadmap

Phase 1 — MQTT (current)
  MQTT core production-ready, continuously refined to be the best MQTT Broker available
  Architecture and infrastructure hardened in parallel

Phase 2 — NATS + mq9 AI Agent (in progress)
  NATS protocol compatibility + mq9 Agent mailbox with priority & public discovery
  Native Agent async communication layer

Phase 3 — Kafka (in progress)
  Full Kafka protocol compatibility
  Complete the IoT-to-streaming data path, edge-to-cloud data flow

Phase 4 — AMQP (planned)
  Full AMQP protocol compatibility
  Traditional enterprise messaging migration path

Feature	Status
MQTT 3.x / 5.0 core	✅ Available
Session persistence and recovery	✅ Available
Shared subscription	✅ Available
Authentication and ACL	✅ Available
Grafana + Prometheus monitoring	✅ Available
Web management console	✅ Available
Kafka protocol	🚧 In development
NATS protocol	🔬 Demo validated, in development
AMQP protocol	🔬 Demo validated, in development
mq9 — AI Agent mailbox	🔬 Demo validated, in development

🏗️ Architecture

RobustMQ has three components with fixed, clean boundaries:

• Meta Service — metadata management, Raft-based consensus
• Broker — protocol parsing and routing (MQTT / Kafka / NATS / AMQP / mq9)
• Storage Engine — unified data storage with pluggable backends

Adding a new protocol means implementing only the Broker parsing layer. Adding a new storage backend means implementing only the Storage Engine interface. The core architecture does not change.

🚀 Quick Start

One-Line Installation

curl -fsSL https://raw.githubusercontent.com/robustmq/robustmq/main/scripts/install.sh | bash
broker-server start

Multi-Protocol in Action

# Publish via MQTT
mqttx pub -h localhost -p 1883 -t "robustmq.multi.protocol" -m "Hello RobustMQ!"

# Consume the same message via Kafka
kafka-console-consumer.sh --bootstrap-server localhost:9092 \
  --topic robustmq.multi.protocol --from-beginning

# Consume the same message via NATS
nats sub "robustmq.multi.protocol"

mq9 Agent Mailbox in Action

# Agent A creates a mailbox — returns mail_id
nats pub '$mq9.AI.MAILBOX.CREATE' '{"ttl":3600}'

# Agent B sends to Agent A (works even if A is offline)
nats pub '$mq9.AI.MAILBOX.{mail_id_a}' '{"msg_id":"msg-001","from":"m-uuid-b","type":"hello","payload":"hi","ts":1234567890}'

# Agent A subscribes and receives all non-expired messages
nats sub '$mq9.AI.MAILBOX.{mail_id_a}.*'

Web Dashboard

Access http://localhost:8080 for cluster monitoring and management.

Try Online Demo

• MQTT Server: 117.72.92.117:1883 (admin/robustmq)
• Web Dashboard: http://demo.robustmq.com:8080

📚 Full installation and usage guide: Documentation

🔧 Development

git clone https://github.com/robustmq/robustmq.git
cd robustmq
cargo run --package cmd --bin broker-server

make build           # Basic build
make build-full      # With frontend

📚 Build Guide

📚 Documentation

• 📖 Official Documentation — Comprehensive guides and API references
• 🤖 mq9 Overview — Design rationale and core concepts
• ⚡ mq9 Quick Start — CLI walkthrough in 10 minutes
• 🔌 mq9 SDK Integration — Python, Go, JavaScript, Java, Rust, C#
• 🧩 mq9 NATS Client Usage — Use any NATS client directly
• 🔗 mq9 LangChain Integration — LangChain & LangGraph toolkit
• 🗺️ mq9 Roadmap — Semantic routing, intent policy, context awareness
• 🚀 Quick Start Guide — Get up and running in minutes
• 🔧 MQTT Documentation — MQTT-specific features and configuration
• 💻 Command Reference — CLI commands and usage
• 🎛️ Web Console — Management interface

mq9 SDK

Install the mq9 SDK for your language:

# Python
pip install robustmq

# JavaScript / TypeScript
npm install @robustmq/sdk

# Rust
cargo add robustmq

# Go
go get github.com/robustmq/robustmq-sdk/go

# Java (Maven)
# <dependency><groupId>com.robustmq</groupId><artifactId>robustmq</artifactId><version>0.3.5</version></dependency>

# C# (.NET)
dotnet add package RobustMQ

Or use any NATS client library directly — no SDK required.

🤝 Contributing

We welcome contributions. See our Contribution Guide and Good First Issues.

🌐 Community

• 🎮 Discord — Real-time chat and collaboration
• 🐛 GitHub Issues — Bug reports and feature requests
• 💡 GitHub Discussions — General discussions

🇨🇳 Chinese Community

• 微信群: Join our WeChat group for Chinese-speaking users

  

• 开发者微信: If the group QR code has expired, follow our official WeChat account

  

License

RobustMQ is licensed under the Apache License 2.0. See LICENSING.md for details.

---

_{Built with ❤️ by the RobustMQ team and contributors.}