SagooIOT: a Go and Vue platform for multi-protocol device fleets

Device management and data handling, not just a protocol broker

The description of this project is long, and its length is the point. SagooIOT is an enterprise IoT development platform whose stated job is device management and protocol data management, providing cross-platform device access and management so that a whole business system can be assembled from reusable pieces rather than written from the ground up.

The README lists the feature set as device management, data processing, alert notifications, a rule engine, video monitoring and edge computing. The architecture diagram in the README shows three layers: a frontend layer described as Vue 3 with Element Plus and TypeScript, an application service layer on GoFrame 2.9 containing the device manager, data processing, alert and notification, thing model, rule engine, data analysis, permission, data center, real-time push, system management and a task scheduler, and below that a protocol access layer.

The thing model is worth calling out. It is the piece that lets a platform treat devices from different vendors with different schemas as one kind of object, and it sits in the same layer as the rule engine and alerting, so a rule can be written against the thing model rather than against a raw protocol payload.

The backend is Go. The go.mod file declares the module as sagooiot with a Go 1.26.0 directive, and the dependency list is long and specific: the GoFrame framework with its MySQL and Redis drivers, the Eclipse Paho MQTT client, gorilla websocket and sessions, the golang-jwt library, asynq for asynchronous jobs, the hashicorp go-plugin library, the MinIO client, the Taosdata driver for TDengine, excelize and xlsx for spreadsheets, plus the captcha, otel and oauth2 packages. That dependency list is a good map of what the platform actually does.

Twelve protocol families in the access layer

The flexible access claim is specific rather than generic. The README names TCP, UDP, HTTP, Websocket, MQTT, CoAP, OPC UA, Modbus, SNMP, IEC104, JT808 and GB212, and the repository topics list goframe, gwt, iot, modbus, mqtt and vue-admin.

These are grouped by origin, and the grouping matters for what you are actually buying. MQTT, CoAP, HTTP and Websocket are what people usually mean by IoT protocols, and they fit devices that push their own telemetry. Modbus, OPC UA and IEC104 are industrial fieldbus and industrial Ethernet protocols, which means the platform is aimed at plant and building equipment, not just consumer gadgets. SNMP and the Chinese vehicle telemetry standards JT808 and GB212 sit in the same bucket.

The plugin architecture is the second differentiator. The README describes a hot-pluggable plugin system supporting development in C/C++, Python and Go, and the repository root holds a plugins/ directory alongside a plugin_test.go file, which suggests the plugin boundary is exercised by the test suite. The go.mod dependency on hashicorp/go-plugin points at a known host process mechanism for running plugins as separate processes.

The frontend is a separate repository, sagooiot-ui, and the README links it explicitly rather than folding it into this one. GoFrame 2.9 on the server and Vue 3 with TypeScript on the client, split across two repositories, is the layout of a product rather than a library.

Running it locally needs MySQL, Redis and a schema you import by hand

The direct run path starts with the repository and a directory the platform expects to exist. The README's first block clones the project, moves into it and creates the log directory, with a note that the database initialization script in manifest/sql/ has to be imported into MySQL separately:

git clone https://github.com/sagoo-cloud/sagooiot.git
cd sagooiot

# Create necessary directories
mkdir -p resource/log

# Initialize database (refer to manifest/sql/)
# Need to import database initialization script in MySQL

Configuration then comes from an environment file or a YAML file. The README shows a .env in the project root or manifest/config/config.dev.yaml with the database, Redis and MQTT sections:

database:
  mysql:
    host: localhost
    port: 3306
    name: sagooiot
    user: root
    password: your_password

redis:
  host: localhost
  port: 6379
  password: ''

mqtt:
  broker: mqtt://localhost:1883

With that in place the application starts with go mod download followed by go run main.go, and the README states the application will start at http://localhost:8000.

The infrastructure list is the part to read twice. MySQL 5.7+ or 8.0+ and Redis 6.0+ are listed as core dependencies, one for relational business data and one for cache and messaging. PostgreSQL 16.x, TDengine 3.0+, InfluxDB 2.x, an MQTT broker, either Mosquitto or a cloud service, and MinIO are all marked optional. The system requirements ask for 4GB of memory minimum with 8GB recommended, 20GB of disk with 50GB recommended, and Go 1.23.0 or higher even though the module directive says 1.26.0.

Docker Compose brings up the stack, and the default password is published

There is a second path for people who would rather not assemble the dependencies by hand, and it is the one the README recommends first. After checking that Docker and Docker Compose are installed, you move into the compose directory and bring the stack up:

cd manifest/docker-compose

# Use docker-compose to start all services (MySQL, Redis, SagooIOT, etc.)
docker-compose -f docker-compose.yml up -d

# View logs
docker-compose logs -f sagooiot

# Stop services
docker-compose down

The comment on the up command is the useful part, since it names the services that come up together: MySQL, Redis and SagooIOT among others.

First access is then at http://localhost:8000 for the web interface and http://localhost:8000/api for the API, with the default account given in the README as admin / admin123456. The README attaches a warning to change that password after the first login, and it is worth taking seriously. A platform that speaks MQTT and HTTP on port 8000 with a documented default credential is not something to expose beyond a trusted network without changing that credential first.

The documentation lives at iotdoc.sagoo.cn, and the community channel is a QQ group rather than a forum or a chat service, which tells you something about who the audience is.

The licence wording is worth reading before you deploy it

The licence question here has a wrinkle that a badge does not settle. The README's copyright notice says the project is released under the GPL-3.0 open source licence, and the README badge points at a LICENSE file described as GPL3.0. The licence field on the repository itself reads LGPL-3.0. Those are two different licences with different obligations, and the copyright notice in the README is the one that spells out the practical effect: modified or derived code from SagooIOT may not be released or sold as closed source commercial software, and the README directs anyone wanting commercial use to contact the project manager for a commercial licence.

Whatever the exact file contents, the practical question is settled by the README: if you intend to run this unmodified inside your own organisation, the notice does not appear to restrict that. If you intend to modify it and ship the result as a closed product, the notice tells you to get a commercial licence first. Read the LICENSE file itself before relying on either reading.

On maintenance, the repository is not archived and the last push was on 2026-08-12, so work is continuing. There are no GitHub releases, so there is no tag to pin, and the project version is not tracked through that channel. The README also describes the codebase as SagooIOT Community V2, with a separate README_ZH.md for the Chinese documentation, and the GoFrame badge reads 2.9 while the go.mod dependency resolves GoFrame v2 at 2.10.2.

Where SagooIOT is the wrong tool

The first wrong-tool case is scale mismatch. A platform with a rule engine, thing models, a task scheduler, real-time push, permission management and optional time series databases is built for fleets, not for a hobby project with three sensors. The install path asks for MySQL, Redis and a schema import before you see anything, and the recommended footprint is 8GB of memory and 50GB of disk. That is a reasonable price for a business platform and a heavy one for a small deployment.

The second is the single protocol case. If all you need is an MQTT broker that writes to a database, or a Modbus to MQTT bridge, the full platform is more moving parts than the job. The optional dependency list makes the shape of the platform visible: PostgreSQL, TDengine, InfluxDB, an MQTT broker and MinIO are all there because the platform wants to be the whole system, and each one you switch on is another thing to operate and back up.

The third is the frontend split. The web interface lives in a different repository, sagooiot-ui, so a team that wants to change the interface is taking on a second codebase, and the build story for the frontend is not described in this repository's documentation.

What the project does offer is the thing that is genuinely hard to assemble otherwise: industrial protocol coverage, a plugin model that accepts C, Python and Go extensions, and a rule engine sitting next to it, with the whole stack deployable in one compose file for teams that want no external service.

Editorial conclusion

SagooIOT suits a team that wants an entire IoT backend, including device management, rules, alerts and time series storage, deployed on its own infrastructure, and it does not suit a project that only needs a protocol bridge or a small device fleet with a handful of readings per day. Before you evaluate it, confirm you can run the required stack, since MySQL and Redis are listed as core dependencies and PostgreSQL, TDengine, InfluxDB, an MQTT broker and MinIO are all optional, and change the default admin credentials from the published admin / admin123456 pair before the platform is reachable on anything but your own machine.

Frequently asked questions

Official sources

1. Issues
2. License: LGPL-3.0
3. Project website
4. README
5. sagoo-cloud/sagooiot on GitHub