https://github.com/robustmq/robustmq
Next-generation unified communication infrastructure for AI, IoT, and big data
https://github.com/robustmq/robustmq
ai amqp data infra kafka message message-queue middleware mq mqtt mqtt-broker queue rust serverless storage streaming
Last synced: about 14 hours ago
JSON representation
Next-generation unified communication infrastructure for AI, IoT, and big data
- Host: GitHub
- URL: https://github.com/robustmq/robustmq
- Owner: robustmq
- License: apache-2.0
- Created: 2023-08-03T05:47:54.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2026-02-17T01:34:32.000Z (about 1 month ago)
- Last Synced: 2026-02-17T08:03:54.722Z (about 1 month ago)
- Topics: ai, amqp, data, infra, kafka, message, message-queue, middleware, mq, mqtt, mqtt-broker, queue, rust, serverless, storage, streaming
- Language: Rust
- Homepage: http://robustmq.com/
- Size: 59 MB
- Stars: 1,515
- Watchers: 30
- Forks: 213
- Open Issues: 104
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- trackawesomelist - RobustMQ (⭐69) - Next generation cloud-native converged message queue. (Recently Updated / [Sep 16, 2024](/content/2024/09/16/README.md))
- awesome-rust - RobustMQ - Next generation cloud-native converged message queue. (Applications / Message Queue)
- fucking-awesome-rust - RobustMQ - Next generation cloud-native converged message queue. (Applications / Message Queue)
- awesome-rust-with-stars - RobustMQ - native converged message queue. | 2026-01-29 | (Applications / Message Queue)
README
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.**
| Primitive | What it does |
|-----------|-------------|
| **Mailbox** | Each Agent has its own inbox. Messages wait until the Agent comes online. |
| **Broadcast** | Publish once, any interested Agent subscribes. No need to know who's listening. |
| **Priority** | `urgent` / `normal` / `notify` — critical messages are never buried. |
```bash
# Give an Agent an identity and mailbox — one call, no registration
nats req '$mq9.AI.MAILBOX.CREATE' '{}'
# → {"agent_id": "agt-uuid-001", "token": "tok-xxx"}
# Send to another Agent's mailbox (works even if they're offline)
nats pub '$mq9.AI.INBOX.agt-uuid-002.normal' '{"from":"agt-uuid-001","payload":"task done"}'
# Broadcast an event — anyone interested will receive it
nats pub '$mq9.AI.BROADCAST.task.available' '{"task_id":"t-001"}'
# Subscribe to your own mailbox
nats sub '$mq9.AI.INBOX.agt-uuid-001.*'
```
**Any NATS client — Go, Python, Rust, Java, JavaScript — is already an mq9 client.** No new SDK needed.
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](https://robustmq.com/en/mq9/)
---
## ✨ Features
- 🤖 **mq9 — AI Agent communication**: Agent mailbox, broadcast, priority queue — 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 & broadcast
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
```bash
curl -fsSL https://raw.githubusercontent.com/robustmq/robustmq/main/scripts/install.sh | bash
broker-server start
```
### Multi-Protocol in Action
```bash
# 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
```bash
# Agent A gets a mailbox
nats req '$mq9.AI.MAILBOX.CREATE' '{}'
# Agent B sends to Agent A (even if A is offline)
nats pub '$mq9.AI.INBOX.{agent_a_id}.normal' '{"from":"agent-b","payload":"hello"}'
# Agent A subscribes and receives
nats sub '$mq9.AI.INBOX.{agent_a_id}.*'
```
### 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](https://robustmq.com/)**
## 🔧 Development
```bash
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](https://robustmq.com/QuickGuide/Build-and-Package.html)**
## 📚 Documentation
- **📖 [Official Documentation](https://robustmq.com/)** — Comprehensive guides and API references
- **🤖 [mq9 — AI Agent Communication](https://robustmq.com/en/mq9/)** — Agent mailbox, broadcast, priority queue
- **🚀 [Quick Start Guide](https://robustmq.com/QuickGuide/Overview.html)** — Get up and running in minutes
- **🔧 [MQTT Documentation](https://robustmq.com/RobustMQ-MQTT/Overview.html)** — MQTT-specific features and configuration
- **💻 [Command Reference](https://robustmq.com/RobustMQ-Command/Mqtt-Broker.html)** — CLI commands and usage
- **🎛️ [Web Console](https://github.com/robustmq/robustmq-copilot)** — Management interface
## 🤝 Contributing
We welcome contributions. See our [Contribution Guide](https://robustmq.com/en/ContributionGuide/GitHub-Contribution-Guide.html) and [Good First Issues](https://github.com/robustmq/robustmq/labels/good%20first%20issue).
## 🌐 Community
- **🎮 [Discord](https://discord.gg/sygeGRh5)** — Real-time chat and collaboration
- **🐛 [GitHub Issues](https://github.com/robustmq/robustmq/issues)** — Bug reports and feature requests
- **💡 [GitHub Discussions](https://github.com/robustmq/robustmq/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](LICENSE). See [LICENSING.md](LICENSING.md) for details.
---