# easyaiot **Repository Path**: nbb/easyaiot ## Basic Information - **Project Name**: easyaiot - **Description**: 我希望全世界都能使用这个系统，实现AI的真正0门槛，人人都能体验到AI带来的好处，而并不只是掌握在少数人手里。支持上千种垂直场景，支持AI模型定制化和AI算法定制化开发深度融合，赋能万物智视：EasyAIoT 构筑了物联网设备（尤其是海量摄像头）的高效接入与管控网络。我们深度融合流媒体实时传输技术与前沿人工智能（AI），打造一体化服务核心。 - **Primary Language**: Java - **License**: MIT - **Default Branch**: main - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 1010 - **Created**: 2026-09-03 - **Last Updated**: 2026-09-03 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # EasyAIoT (Cloud-Edge-Device Integrated Intelligent Algorithm Application Platform) [![Gitee star](https://gitee.com/volara/easyaiot/badge/star.svg?theme=gvp)](https://gitee.com/soaring-xiongkulu/easyaiot/stargazers) [![Gitee fork](https://gitee.com/volara/easyaiot/badge/fork.svg?theme=gvp)](https://gitee.com/soaring-xiongkulu/easyaiot/members)

My vision is for this system to be accessible worldwide, achieving truly zero barriers to AI. Everyone should experience the benefits of AI, not just a privileged few.

English | 简体中文 | 繁體中文 | Русский | Français | 한국어

## 🌐 Official Website EasyAIoT Official Website: [http://36.111.47.113:8090/](http://36.111.47.113:8090/) Product introduction, feature overview, four hardware tiers, installer downloads, and documentation entry—so you can quickly understand the platform and start deploying. ## 📖 Project Overview

EasyAIoT (Easy AI Internet of Things) is a cloud-edge-device integrated intelligent algorithm application platform dedicated to deeply fusing artificial intelligence with the Internet of Things—enabling cameras, sensors, and edge compute to work together on site. From device onboarding and data collection to real-time visual analysis, intelligent assessment, and alert orchestration, the entire chain runs on a single software stack.

Many smart IoT projects hit the same wall at deployment: video systems, device platforms, and algorithm services live in silos—integration is costly, operations are fragmented, and scaling is painful. EasyAIoT resolves this with one platform—the same software can run a closed smart loop on a 2 GB edge standalone (edge), land on a 4–8 GB edge box (mini) for single-point intelligence, ride AI all-in-one cameras for floor-level coverage, or pack into an enterprise full-stack appliance with IoT management, massive video access, and AI analysis—no multiple versions to maintain, no repeated integration across heterogeneous systems.

The platform comprises core modules including WEB, APP, DEVICE, EDGE, SENTINEL, VIDEO, RTC, AI, RUNTIME, POST, VISUALIZE, TRANSFORM, PANEL, IDEA, HARNESS, and SITE, with COMPILE handling multi-platform packaging and delivery (including Ubuntu / CentOS·RHEL 7–9 (x86 + CentOS ARM, packages per el7/el8/el9) / Kylin (麒麟) / openEuler (欧拉) / Windows / macOS / ARM). On the capability side, the platform covers GB28181 / ONVIF multi-protocol camera access, RTC consumer-camera P2P bridging (based on go2rtc, covering Tapo, Tuya, Ring, Nest, Xiaomi, Wyze, DoorBird, GoPro, and Roborock—store Tapo fill-in, Tuya white-label onboarding, overseas Ring/Nest doorbells, Xiaomi reuse, Wyze low-cost scale-out, DoorBird intercom, GoPro mobile views, Roborock vacuum cameras—with one-click Web onboarding into unified video and AI judgment), DJI dock and drone aerial view access, real-time / snapshot / patrol algorithm tasks, RUNTIME native high-speed execution layer (compiled binary owns pull/decode, YOLO inference, boxed push, and multi-channel raw forward—lower CPU/memory and steadier latency than interpreted paths; one binary covers realtime / snap / patrol / forward), YOLO object detection and SAM zero-shot auto-annotation, face/plate recognition, POST custom judgment (after detection, filter and composite rules before alerting—change rules without retraining models), federated compute cluster scheduling, SENTINEL cluster-node sentinel (continuously reveals per-node readiness and schedulable business capacity, requests environment fill-in when gaps appear, and dispatches work by real capability), and Infinite Federated Edge Cluster mode (ordinary development boards ready out of the box, on-site intelligence for local decisions, alerts and evidence automatically aggregated to the cloud, compute scaling with business as needed), plus MQTT / TCP / HTTP / Modbus-TCP / Modbus-RTU / OPC UA IoT device lifecycle management, with the EDGE C# edge collection runtime handling Modbus RTU/TCP, OPC UA, and other on-site industrial protocols via pluggable collectors, local scheduling, and MQTT cloud-edge integration, plus visualization dashboards and Web SCADA configuration, so device data can be displayed as command-center situational awareness and mapped back to process screens; plus the new POST custom judgment service, which turns detections into field-ready business events—fewer false alarms, configurable rules, trial runs before go-live; plus the TRANSFORM multidirectional data-flow engine, which delivers platform-side business events to external systems such as MES / ERP / CRM / WMS by contract—multi-party integration that is configurable, traceable, and reusable; and the companion PANEL delivery & watch entry, so appliances can be installed and accepted on arrival day, and watch/troubleshooting no longer wait on developers running remote commands every time; plus the SITE official website to present product value, four hardware tiers, and installer entry—so visitors understand first, then download and deploy; and IDEA community cloud IDE so contributors can open the full repo in a browser, co-create with GitHub Copilot, publish local changes, and submit PRs—turning open-source collaboration from “set up the environment first” into “open and edit”. On the experience side, the Web console and mobile App / mini-program are capability-aligned, so command centers and field inspections share the same business logic—handle incidents anytime, anywhere; and the new ANDROID / IOS / HARMONYOS packaging shells ship that mobile experience as installable apps on every mainstream phone OS (APK / IPA / HAP) from one frontend codebase, with one-command builds and unified version management.

In one sentence: EasyAIoT = AI + IoT—interconnect everything while enabling intelligent vision and intelligent control for everything.

📄 For a more complete illustrated introduction, see EasyAIoT Project Introduction V2.0 (PPT), and AI Video Surveillance Analytics Platform (PDF). For day-to-day platform operations after deployment, see the Platform Operations Manual.

### 🏆 Certificates | | | | | |:---:|:---:|:---:|:---:| | Gitee Annual OSS Award 2025 · Industrial Software Track Top 1

Gitee GVP 2025 · Most Valuable Open Source Project

| ## 🚀 Quick Start

Open the README and mutter: “Can my little box even run this?” — Yes. Don’t panic.

Lightest tier, containers use about 1 GB total. Cameras, real-time analysis, smart alerts—small machines still close the loop. Spin up that old laptop first; upgrade later when you’re hooked.

Three steps (Linux):

```bash git clone https://gitee.com/volara/easyaiot.git cd easyaiot # Option A (recommended) EASYAIOT_DEPLOY_PROFILE=edge sudo bash .scripts/docker/install_linux.sh install # Option B # sudo bash .scripts/docker/install_linux.sh edge install ```

Then open https://<server-ip>:8888 — default admin / admin123. Sanity-check:

```bash .scripts/docker/install_linux.sh verify # Optional: peek at memory vs the tier budget .scripts/docker/install_linux.sh resources ```

All green? You’re done—easier than you feared. Go grab that coffee early.

## 🌟 Some Thoughts on the Project ### 📍 Project Positioning

EasyAIoT is a cloud-edge-device integrated intelligent IoT platform that focuses on the deep integration of AI and IoT. Through core capabilities such as algorithm task management, real-time stream analysis, and model service cluster inference, the platform achieves a complete closed-loop from device access to data collection, AI analysis, and intelligent decision-making, truly realizing interconnected everything and intelligent control of everything.

### 🎛️ PANEL: Install & Accept on Arrival Day—Watch Duty Without Waiting for Remote Devs

Smart IoT projects most often stall at the last mile: the machine is on site, yet it won't install, won't pass acceptance, and when something breaks you can only wait for developers to run remote commands—on-site cost and acceptance cycles are held hostage by people. PANEL is an independent delivery and watch entry for integrators and field ops—one-click install by tier, see whole-machine health and dependencies, start/stop services and inspect logs on the spot; even before the business console is ready, you can bring up, hold, and hand over the appliance, turning “machine on site → platform usable → acceptance-ready” from waiting on people into a same-day closed loop.

Shorter acceptance cycles: On arrival pick edge / mini / standard / full, install, and see progress and results on the spot—fewer “stuck halfway, unsure where” cases from incomplete commands or skipped steps; PoC and production delivery clear acceptance faster
Lower on-site and remote cost: Whether containers are running, resources are tight, and where logs stall is obvious at a glance—restart, clean cache, and pull images without first hunting docs or waiting for developer support; watch staff can self-serve common faults
One playbook across projects: The same install and ops entry reuses across appliances and rooms—delivery, watch, and handoff share one standard, avoiding “each site has its own oral tradition”

📦 Installer download: Packages for Ubuntu / Debian, CentOS / RHEL 7–9 (x86 + CentOS ARM, el7/el8/el9 RPMs), Windows, macOS, and ARM / Kylin (麒麟) / openEuler (欧拉) targets are on Gitee Releases.

In homes, retail stores, and light-security deployments, many devices already in use come from Tapo, Tuya, Ring, Nest, Xiaomi, Wyze, DoorBird, GoPro, and Roborock—they rely on vendor-private P2P protocols and do not expose standard RTSP. Traditional VMS platforms often push users toward Micam, Home Assistant, or other middleware, leaving long integration chains, fragmented ops, and no path to AI judgment. EasyAIoT adds a dedicated RTC module built on go2rtc, that unifies streaming and two-way audio for all nine brands—consumer devices can register, preview, relay, run AI tasks, and trigger alerts just like GB28181/ONVIF cameras.

Supported brands and typical value:

Brand	Vendor	Typical devices	Value
Tapo	TP-Link	Home/store IPC, indoor/outdoor cams	Low-cost blind-spot fill for shops; cloud-password connect; two-way audio
Tuya	Tuya Smart	Tuya-ecosystem IPC, doorbells	Mass white-label/OEM onboarding; one integration for countless rebranded cameras
Ring	Amazon	Doorbells, outdoor cams	Overseas doorbell monitoring in platform; local P2P after OAuth; remote talk
Nest	Google	Nest Cam, Doorbell	Google-ecosystem premium sites unified with pro cameras on one screen
Xiaomi	Mi Home	Mi Home cams, doorbells	Reuse installed Mi Home fleet; no Micam middleware; attach AI directly
Wyze	Wyze	Wyze Cam v3/v4, doorbells	Ultra-low-cost scale-out; local P2P; two-way audio for pilots
DoorBird	DoorBird	Smart doorbells, door stations	Premium entry intercom + video; MJPEG/audio/talk in one bridge
GoPro	GoPro	HERO9–12 (USB / Wi-Fi)	Mobile tactical views for patrol and emergency survey
Roborock	Roborock	S6/S7/Qrevo MaxV vacuums with cameras	Moving under-furniture views fixed cameras cannot reach; talk on supported models

One-click Web onboarding: "Connect RTC camera" in the console with per-brand dynamic forms; OAuth brands (Ring/Nest/Xiaomi/Wyze/Roborock) bind via go2rtc WebUI then paste stream URL
Full pipeline wired: WEB → VIDEO /register/device/rtc-live → RTC API → go2rtc P2P → RTSP → SRS relay → Jessibuca + AI—same flow for all nine brands
Two-way audio: Tapo, Tuya, Ring, Wyze, DoorBird, Roborock support go2rtc intercom for remote talk and doorbell scenarios
Lifecycle sync: Deleting a device cleans up go2rtc streams; works with device tree, map pins, and algorithm tasks
Docker all-in-one: bash RTC/install_linux.sh start runs go2rtc + management API; host network for P2P LAN

### 🏷️ LLM Smart Labeling: Describe the Business Scene, Train a Field-Specific Small Model

Conventional auto-labeling usually accepts only class words such as “person,” “vehicle,” or “helmet.” It can locate generic objects, but cannot precisely express what a customer actually cares about on site. EasyAIoT adds an independent LLM Smart Labeling workflow built on the existing HARNESS model foundation. Users describe a real business scene in natural language—for example, “label people who enter the construction area without correctly wearing a helmet, and exclude compliant workers.” The LLM understands objects, actions, relationships, conditions, and exclusions before producing structured annotations. After users review the bootstrap results, the platform automatically trains, publishes, binds, and applies a YOLO small model, turning one scene description into a dedicated capability that can run continuously and efficiently in production.

Natural language matches real requirements better than class labels: It can describe where an object is, what it is doing, its relationships, required conditions, and explicit exclusions—not merely what category it belongs to
Better cold starts for customized datasets: No mature detector or large manually labeled dataset is required up front; users describe the scene, review the first candidate annotations, and immediately feed field knowledge into training
LLM understanding with small-model runtime efficiency: The LLM handles complex semantics on a small bootstrap set, while the reviewed results teach a small model that supports fast, economical, and edge-friendly production inference
Models fit the customer's actual site: Training targets come from the user's language, images, and review decisions instead of broad classes from generic datasets, aligning the resulting detector with the project's real acceptance criteria
A full learning loop, not a one-off AI call: Scene description → LLM candidate annotations → human review → small-model training → automatic publishing and dataset binding → batch relabeling, with traceable model versions and origins

How it differs from SAM3 Smart Labeling: SAM3 uses concise visual prompts and excels at locating or segmenting “things that look like this target.” LLM Smart Labeling accepts a complete business description and determines “which target, under which conditions, is the one the user actually wants labeled.” The two workflows have separate entries and tasks but share the review, training, and small-model relabeling pipeline. Use SAM3 for fast generic-object extraction; use LLM Smart Labeling when the scene depends on actions, relationships, conditions, exceptions, or domain semantics.

### 🔌 EDGE: C# Edge Collection Runtime

On industrial and building sites, PLCs, meters, and sensors often hang on RS-485 or Ethernet while the cloud platform still needs a separate data-acquisition stack—protocols written one-off, every config change requiring a site visit. Long access chains, fragmented ops, and cloud-edge metric drift are the norm. EasyAIoT adds a dedicated EDGE module (C#) as an independently deployable edge collection runtime: pluggable multi-protocol collectors, local scheduling, config-driven parsing, and MQTT integration with the EasyAIoT cloud platform—lifting on-site Modbus RTU/TCP, OPC UA, and other points into a unified thing model uplink, with cloud config push and property writes reaching the edge for execution.

Difference from Device Management "gateway": In device management, a gateway is a cloud-side product/device type (GATEWAY + SUBSET sub-device topology) for provisioning, shadow, binding, and downlink. EDGE has no separate device page—it is the on-site process that acts as that gateway; collected data appears in the same device management UI. Another path is iot-sink cloud-side polling of Modbus/OPC UA (the platform must reach field devices); EDGE collects on site and uplinks via MQTT only—suited to OT isolation and RS-485. Gateway property uplink/downlink, sub-device property proxy reporting, and config push are already aligned for use as an on-site industrial gateway; proactive topology reporting, sub-device event/service passthrough, OTA, and the full gateway protocol surface are still evolving.

Why C# for edge IoT acquisition?

Industrial site affinity: C# has a mature ecosystem in industrial control, SCADA, and HMI—rich protocol libraries and engineering practice for Modbus, OPC UA, serial communication, and more; low onboarding cost for integrators and automation engineers
Strong typing + structured engineering: Point mapping, register parsing, and config validation surface errors at compile time—more stable and testable than script languages when maintaining multi-protocol collectors long term
Async concurrency without blocking: async/await fits multi-device polling and concurrent serial/network I/O—a single gateway can schedule dozens of sub-device collection jobs without the throughput bottlenecks of interpreted paths like Python GIL under high-frequency polling
Long-running service stability: The .NET runtime suits 7×24 edge gateway daemons with predictable memory and GC behavior; dependency injection and plugin architecture let collectors hot-swap and version without restarting the whole site
Cross-platform deliverability: The same C# codebase publishes to Linux x86_64 / ARM64 industrial PCs and edge boxes—single-file/self-contained deployment without Python virtualenvs or JVM on site
Clear division with the cloud platform: The edge focuses on collect—parse—publish; DEVICE focuses on thing models and device lifecycle—C# does not carry heavy platform business or AI inference, stays lightweight, and runs independently on RS-485 bus sides or low-power gateways

Collector	Protocol / Scenario
`modbus-rtu`	Modbus RTU (RS485/serial)—meters, instruments, PLCs on the bus
`modbus-tcp`	Modbus TCP—Ethernet-side industrial devices, VFDs, gateways
`opc-ua`	OPC UA—modern industrial control and upper-system interconnect

Plugin collection architecture: Implement ICollector to extend new protocols; the Host handles registration, scheduling, and result reporting—collection logic decoupled from the runtime
Dual config channels: Local device-jobs.json for offline operation; cloud MQTT config/downstream/push can remotely override collection jobs—no site visit to change config
MQTT cloud-edge integration: Joins as platform GATEWAY—gateway property reporting, sub-device property proxy reporting, cloud property write downlink via EMQX to DEVICE/iot-sink; sub-devices auto-created with shadow persistence; data shown in Device Management
Standalone packaging: pack_linux.sh produces x86_64 / ARM64 Linux deployment packages for industrial PCs and edge gateways—decoupled from the main platform stack
E2E integration out of the box: bash EDGE/demo/run_e2e.sh validates the full chain—collection → MQTT uplink → cloud persistence

### 🛰️ SENTINEL: Cluster-Node Sentinel—Onboard Ready, Schedule by Real Capability

Federated scale-out often fails at “the machine joined, but nobody knows if it can take work”—video analytics, stream forwarding, and model training each need different readiness; jobs land only to discover missing environment pieces, and sites keep boarding servers to install dependencies until acceptance stalls on “installed but won’t run.” EasyAIoT adds a dedicated SENTINEL module as a business-readiness sentinel that travels with every schedulable node: it continuously checks whether the box can truly take the selected workloads, aggregates schedulable capacity into the console, and can request environment fill-in when gaps appear—so ops board fewer machines, jobs hit fewer dead ends, and scale-out can be accepted the same day.

Capability by business choice: Video analytics, stream forwarding, live ingest, model training, LLMs, smart labeling—whatever business you select is what readiness tracks; no more guessing by role what a machine “probably” can do
Monitor on onboard: After a node joins the platform, sentinel inspection starts automatically—see “can it take work?” the same day, shortening the idle window of “add machine → wait for integration → discover it can’t run”
Schedule by real capability: Only truly ready nodes enter the schedulable pool, cutting rework and complaints from “dispatched but won’t start”
Self-serve gap fill-in: When expected environment is missing, the platform can be asked to fill it in—turning manual on-site installs into a closed loop and fewer server logins for duty staff
Scale without public internet: Air-gapped or restricted sites can still onboard offline and sync environments—edge expansion is not blocked by WAN access
Acceptance at a glance: Component health and schedulable functions share one console view—less guessing, less machine hopping, one delivery language

### 🧭 POST: Custom Judgment—Turn “Detections” into Operable Business Events

Vision projects often stall at “the model already boxed people/vehicles/objects, but alerts are unusable”—passers-by outside the zone still alarm, normal work still alarms, and customers need line-crossing, loitering, or people-over-limit, yet teams keep retraining models, stopping tasks, and waiting on developers. EasyAIoT adds a dedicated POST custom judgment service that separates visual perception from business judgment: detection keeps focusing on “seeing,” while judgment orchestrates per task “whether to alert and what to report”—change rules without retraining, and analysis keeps running, so alerts finally match site, campus, traffic, and plant management standards.

Orchestrate judgment per task: Each algorithm task can configure its own post-processing steps—default filter by detection regions, then enter standard alerting; insert business scripts or industry plugins to compose people counting, line-crossing, dwell timeout, area loitering, and multi-condition composite alerts into field-ready rule chains—configure once per scenario, reuse across tasks
Alert only where business cares: Linked with device “region detection,” targets outside regions are filtered out—no screen flood; with no regions drawn, alerts are not blocked—avoid “no regions configured, everything goes silent.” Duty attention stays on forbidden zones, passages, and workstations that truly matter; false alarms and manual review drop sharply
Business scripts and rule chains can coexist: Base-config scripts express judgment in field language; the rules page owns filtering and step order. Both capabilities are independent and can run together—delivery need not choose between “write a script” and “configure steps”; complex sites can state the standard once
Pluggable industry logic: Differentiated judgment for campuses, sites, and traffic need not change the platform core. Integrators and solution providers can register, start/stop their own judgment capabilities and attach them per task—one detection model serves many customer projects, turning “rewrite analysis per site” into “configure rules, attach capability, accept the standard”
Trial-run before go-live: Replay current rules online with sample or real detection events—step through pass vs drop and whether an alert will fire. Integration and acceptance can answer “what did this rule actually block,” instead of tuning after go-live from complaints
Rule changes take effect immediately: Saving rules on a running task adopts the new standard—no need to stop analysis or re-push video. Temporary forbidden-zone changes or an extra judgment step can be operated the same day, shortening the “wait for a maintenance window → change → re-accept” idle gap
Perception and judgment do not drag each other down: Monitoring keeps analyzing smoothly while business judgment scales on demand; on judgment failure choose “skip this step and keep alerting” or “prefer no alert over a wrong one,” matching field risk preference between misses and false alarms. Floor-level (standard) and full-stack appliances (full) include this capability by default; light standalones can first close the detection-alert loop and upgrade when deeper operations are needed
Four built-in judgment plugins (no registration): line_cross (line crossing with line detection lines + tracking), region_enter_exit (enter/exit polygon zones), dwell_timer (dwell/loiter timeout in zone), headcount_gate (headcount threshold in zone)—compose with region gate, pass-through, business scripts, and industry plugins into field-ready rule chains

### 📱 ANDROID / IOS / HARMONYOS: One Frontend, Three Native Shells—Every Phone, One App

Mobile delivery often stalls on platform coverage: an app that only runs on one OS chains field staff to company-issued devices, and maintaining a separate native codebase per platform triples cost while the feature sets drift apart. EasyAIoT's mobile side is one uni-app frontend + three native shells: the same APP pages compile into installable apps for ANDROID (DCloud offline runtime + Gradle → APK), IOS (WKWebView shell + xcodebuild → .app / .ipa), and HARMONYOS (ArkWeb shell + hvigor → HAP)—one set of business logic, native installers on every mainstream phone OS, without maintaining three codebases.

Platform	Shell technology	Build output	One-command script
ANDROID	DCloud uni-app offline runtime + Gradle	`easyaiot-<version>-<env>-android.apk`	`ANDROID/make-apk.sh` / `make-apk.bat`
IOS	WKWebView shell + xcodebuild (Xcode 16+)	`.app` (simulator, no signing) / `.ipa` (device)	`IOS/make-ipa.sh`
HARMONYOS	ArkWeb shell + hvigor (DevEco Studio)	`easyaiot-<version>-<env>-harmonyos.hap`	`HARMONYOS/make-hap.sh`

One codebase, zero divergence: All three shells share the same APP pages and admin-api—device management, live preview, stream forwarding, algorithm tasks, alert center, model inference/training—matching the PC console feature-for-feature on Android, iOS, and HarmonyOS alike; frontend capability differences are isolated in conditional compilation, so one change ships to every platform
System-native rendering on each platform: Android runs the uni-app offline runtime for a native App experience; iOS serves the H5 build through a custom easyiot:// scheme so pages run as a normal website (ES Modules, localStorage, and cross-origin admin-api behave as on a real deployment); HarmonyOS maps rawfile resources to the http://appassets.local/ virtual host in ArkWeb—no third-party engines, no file:// quirks, no behavior forks
One-command packaging per platform: make-apk.sh / make-ipa.sh (simulator .app or device .ipa) / make-hap.sh each run version-consistency check → frontend build → resource sync → native build → named artifact; prod / test / dev environments produce independent packages that never overwrite each other
Unified management entry: .scripts/docker/mobile.sh covers all three ends—status (version consistency + toolchain readiness + existing artifacts), build android|ios|harmonyos|all, bump, artifacts, and clean—daily operations never need to enter each module separately
One command to bump all five version fields: APP manifest + Android build.gradle + dcloud_control.xml + iOS pbxproj (Debug/Release) + HarmonyOS app.json5—.scripts/docker/mobile.sh bump 1.0.1 101 updates every copy and re-reads to verify; each packaging script refuses to build when the copies disagree, so a mismatched version never ships
Standardized artifact naming: lowercase kebab-case easyaiot-<version>-<env>-<platform>.<ext>—sorted-stable for archiving, friendly to object storage / CDN and CI artifact collection; mobile.sh artifacts/clean/status recognize both new and legacy names
CI-friendly split pipeline: any Linux runner can run --skip-native to build and sync the frontend resources, then hand the prepared project to a macOS runner (iOS) or a self-hosted DevEco runner (HarmonyOS) for the native compile—one pipeline, three platforms, no platform toolchain on every machine
Signing and distribution ready: Android signs with the built-in iot.jks (DCloud AppKey registered); iOS simulator builds need no account while device / App Store builds use automatic signing with a Team ID; HarmonyOS auto-generates debug signatures in DevEco and supports release signing via AppGallery Connect
Per-module docs and troubleshooting: each module ships its own README covering environment prep (JDK / Xcode 16+ / DevEco), version management, signing, and a FAQ table; the unified three-end guide lives in MOBILE.md

### 🎯 Four Hardware Tiers, One Platform

Many intelligent IoT projects stall at deployment: full features won't fit on small machines; to make them fit, you cut capabilities, split versions, and maintain multiple deployment packages. EasyAIoT resolves this with one platform—from edge ultra-light standalone to edge boxes for point intelligence, AI all-in-one cameras for on-wall analysis, AIoT full-stack all-in-ones for the complete stack in one box. Pick among the four common field hardware classes; the same software runs from “just get it running” through single-site pilots, floor coverage, and full-stack delivery—no split versions.

| Tier | Typical hardware (examples) | Recommended RAM | What you can do | Verified | | :-- | :-- | :--: | :-- | :--: | | **edge** Edge Standalone | Light edge standalone (2 GB industrial PC, old laptop, smallest cloud VM, store trial box) | ≥ 2 GB | One machine closes the loop first: WEB + VIDEO + RUNTIME; camera access, real-time analysis, smart alerts; zero DEVICE, login led by VIDEO | ~**1.02 GB**, nearly 1 GB headroom | | **mini** Edge Lite | Edge box (8 GB industrial PC, store security all-in-one, site gateway) | ≥ 8 GB | Intelligence at one point: camera access, real-time analysis, smart alerts, model inference; event plane same as standard/full (Gateway + iot-sink + EMQX) | ~4–6 GB used, ample headroom | | **standard** Standard | AI all-in-one camera (smart camera terminal, AI surveillance camera with compute, multi-sensor AI analyzer) | ≥ 16 GB | Each camera is a smart node: multiple cameras on the wall cover a floor/campus; devices, rules, and compute orchestrated together; POST custom judgment makes alerts match field standards | ~10 GB, stable with headroom | | **full** Full (default) | AIoT full-stack all-in-one (enterprise full-stack control all-in-one, industry IoT full-stack host, cloud-edge-device smart platform all-in-one) | ≥ 20 GB | IoT + video + AI in one box: device management, massive access, intelligent analysis, command and judgment unified—full capabilities long-term; includes POST custom judgment and outbound business flow | ~14 GB, full features with headroom |

Install edge: EASYAIOT_DEPLOY_PROFILE=edge sudo bash .scripts/docker/install_linux.sh install (or ... install_linux.sh edge install). First-time install can also pick the tier interactively; see Quick Start above.

Install tier selection and resource compliance (verified):

RUNTIME High-Speed Execution Layer: Pulls “watch / compute / push” out of interpreted-language paths into a native binary that owns pull → decode → infer → alert callback → boxed push. Versus Python executors, it avoids GIL and multi-process orchestration overhead—on the same hardware you get more channels per box, lower end-to-end latency, and less CPU/memory. Realtime / snap / patrol and multi-channel raw forward share one execution stack; default executor=cpp. In practice: keep dozens of NVR channels clear first, then enable AI only on critical channels; switch raw preview and boxed judgment without either path dragging the other down; VIDEO/WEB keep orchestration, archiving, and access control while RUNTIME focuses on throughput and latency—scale channels without replacing the whole appliance
High-Performance Stream Forwarding: Built for the real delivery need to “fill the video wall / split view first, without turning AI on for every channel”—batch NVR channels and building endpoints can create forwarding tasks in one click. Default path is RUNTIME high-performance (compatibility mode still available) so multi-channel raw video stays on wall at lower resource cost. Raw viewing and AI judgment can run on the same device in parallel; when algorithm tasks start/stop, forwarding policy follows automatically. Side-by-side preview shortens acceptance by comparing latency and overlay quality directly
Custom Platform Name & Logo Across All Touchpoints: After deploying EasyAIoT on site, users should see their platform—not a generic product name. The monitoring dashboard includes a visual "Platform Branding" panel where administrators can rebrand in the UI: update the admin console name and logo (synced to the sidebar and browser tab); set an independent command-center title on the big screen; and customize the login page name, logo, form title, plus light/dark background images—all three touchpoints stay visually consistent, take effect immediately, and can be saved or reset with one click.
- For system integrators and solution providers: Eliminates front-end reskinning, custom development, and release cycles; switch branding quickly between PoC demos and production delivery, reuse one codebase across multiple customers, shorten payment cycles, and improve solution reuse
- For government, campus, hospital, and other end users: Login page, command dashboard, and daily admin console all display their organization's name and identity—stronger ownership and credibility for leadership visits and internal rollout, meeting branding requirements for public-sector and large-enterprise IT projects
- For private-deployment and operations teams: Configure on site the same day for acceptance—no waiting on development schedules; one-click restore after multi-customer demos or pilot phases, lowering switching and redeployment costs
YOLO26 Next-Generation Object Detection: Built-in next-generation object detection, ready out of the box for real-time feed analysis and snapshot recognition. On the same hardware, connect more camera streams with faster response and fewer false alarms. Supports the full loop from data collection, annotation, and training to deployment and inference—helping users iteratively build custom detection models at lower cost and quickly cover common security and industrial scenarios such as hard hat compliance, unauthorized entry, and fire hazards, making "see accurately, compute fast, scale easily" the default capability
YOLO26 Human Pose Analysis: Builds on object detection with human keypoint and skeleton pose analysis, ready out of the box. Supports three input modes—images, videos, and real-time camera streams. Image mode can synchronously output skeleton annotations and person counts; video mode supports progress tracking and result download; camera mode can connect to RTSP/RTMP live streams and overlay pose recognition results on relayed output for remote monitoring and behavior analysis. The model inference page provides one-click switching between "Pose Analysis" and "Object Detection", suitable for construction site compliance, fitness form assessment, crowd gathering awareness, and other scenarios that require understanding human structure and motion—moving the platform from "boxing targets" to "understanding poses"
Multi-Protocol Camera Access Support: Comprehensive support for GB28181 and ONVIF, two mainstream video surveillance protocols, enabling standardized device access and management. GB28181, as China's national standard, perfectly adapts to mainstream domestic surveillance equipment; ONVIF, as an international universal standard, is widely compatible with global mainstream camera brands. Through dual-protocol support, the platform seamlessly integrates with existing surveillance systems, achieving plug-and-play device access, automatic discovery, and unified management, significantly reducing device access barriers, enhancing system compatibility and scalability, and providing a solid technical foundation for large-scale camera deployment. In addition, NVR batch scan, registration, and unified management across same-segment and cross-segment networks are supported, covering mainstream brands including Hikvision, Dahua, Huawei, Ezviz, and Xiaomi, with native-protocol subnet discovery, one-click registration, and batch channel import. For consumer cameras such as Mi Home that natively lack RTSP, the RTC module (go2rtc bridge) brings them into the same platform, further reducing large-scale surveillance onboarding and ops costs
DJI dock / drone aerial view access: Breaks fixed-camera “ground-only, hard to cover wide areas” limits; brings DJI FlightHub dock and drone aerial video into the platform’s unified video and AI judgment loop. Streaming module offers “Connect DJI livestream”: supports FlightHub API start livestream and manual livestream source — API mode one-click pulls vendor livestream and auto-registers device; manual mode accepts RTSP / RTMP / HTTP-FLV / HLS sources. After connect, aerial views can share the same screen as GB28181/ONVIF fixed points. Operators can view dock/aircraft live like fixed cameras, and attach real-time AI analysis, alarm linkage and evidence retention—covering wide-area patrol, emergency survey, perimeter fill-in that fixed points cannot reach; shortens “detect—locate—respond”; upgrades security from planar deployment to sky–ground collaborative sensing.
RTC Consumer-Camera P2P Bridging: One integration for Tapo (TP-Link home/store IPC), Tuya (mass white-label devices), Ring / Nest (overseas doorbell ecosystems), Xiaomi Mi Home (domestic reuse), Wyze (low-cost fill-in), DoorBird (premium entry intercom), GoPro (mobile patrol views), Roborock (vacuum mobile cameras)—all nine brands natively lack standard RTSP. The RTC module, built on go2rtc, provides P2P bridging and a unified management API. Web console "Connect RTC camera" guides per-brand form fill or OAuth binding, one-click go2rtc stream registration, VIDEO device enrollment, and SRS relay; after bridging, consumer and GB28181/ONVIF pro cameras share one screen, AI tasks, and alert linkage, bringing home/store cameras and project-grade devices into one video judgment system at lower integration and reuse cost
Real-Time Intercom & PTZ Remote Control: Breaks through traditional surveillance's "watch-only, can't act" limitation. Operators can conduct voice broadcasting and PTZ control on the same real-time preview screen—no system switching, no on-site presence required. Remotely communicate, guide evacuations, or stop violations, compressing response from "dispatch personnel" to "speak and reach instantly." PTZ control lets cameras pan, tilt, and zoom on demand—quickly aim at incident areas and magnify details during emergencies, forming an integrated on-site response loop of "see clearly, aim precisely, speak and reach." Fully compatible with GB28181 and ONVIF devices, leveraging existing surveillance assets without additional intercom hardware or third-party software, instantly upgrading deployed cameras with remote communication and flexible dispatch capabilities, significantly reducing system silos and monitoring costs
POST Custom Judgment (Orchestrable Post-Processing): Breaks through the "detect but can't judge" bottleneck with a dedicated POST service as the business judgment layer, transforming visual perception into operable, accountable, and statistically trackable business events. Inside each algorithm task, orchestrate a rule chain: default filter by detection regions before alerting, and layer business scripts plus industry plugins for people counting, line-crossing, dwell timeout, area loitering, and multi-condition composite alerts—adapt to construction safety, campus security, and traffic control without repeatedly tuning models. Trial-run rules with sample events before go-live to see what is blocked and whether alerts fire; saving rules on a running task takes effect immediately without stopping analysis. Perception and judgment run independently in parallel—feeds keep analyzing smoothly while business logic scales on demand; judgment results archive automatically and drive precise alerts, cutting false positives/negatives and manual review. Business users focus on rules, integrators plug in industry capabilities, and the platform handles distribution, execution, and scale—from "being able to see" to "judge clearly, control effectively, and put it to use"
Multi-Central-Node × Multi-Worker-Node Federated Cluster: Designed for cross-region, multi-datacenter, and cloud-edge collaborative deployments, the platform adopts an "N central nodes + N worker nodes" federated architecture—central nodes provide unified orchestration while worker nodes carry compute and media execution, scaling horizontally. Each central node manages its domain worker nodes, supporting remote distribution and one-click deployment of streaming, AV transcoding, video analytics, model inference, and training capabilities; multiple central nodes can interconnect and synchronize; the cluster swimlane view intuitively presents "central—worker" topology and resource levels. Algorithm tasks, auto-labeling pipelines, and stream relay workloads are intelligently scheduled by node role and GPU capability—enabling massive stream ingestion, high-concurrency inference, and distributed training to run together in one cluster, truly delivering "onboard easily, schedule clearly, scale openly, govern completely"
SENTINEL Cluster-Node Sentinel: Built for federated scale-out and cross-datacenter compute pools—solves the delivery pain of “the machine joined, but nobody knows if it can take work.” Continuously reveals each node’s readiness and schedulable capacity by business function, so jobs land only on truly ready machines; can request environment fill-in when gaps appear, and supports offline onboarding for air-gapped sites—so the cluster truly “onboards cleanly, recognizes clearly, dispatches accurately, and boards fewer servers”
SAM Zero-Start Auto-Labeling Orchestration Pipeline: Built for cold-start scenarios with no annotated samples and no usable detection model, the platform integrates SAM open-vocabulary segmentation to deliver a one-click, unattended labeling pipeline. Per strategy, the system automatically chains camera frame extraction, SAM text-prompt bootstrap labeling, YOLO fine-tuning once thresholds are met, production-phase YOLO high-speed inference with intelligent SAM fallback for missed detections, periodic iterative training, and automatic dataset packaging and export—closing the full "capture-annotate-train-export" loop. Supports pause/resume and elastic scheduling on local or cluster compute queues. With visual strategy configuration and run logs, users can grow a custom detection capability from zero samples and zero models, making "define categories in words, watch the model take shape" the default path for dataset building
Ten-Thousand-Node Elastic Compute Cluster & Horizontal Scaling Pool: Built for hyperscale AI and video workloads, the platform provides a cloud-edge-end distributed compute foundation that unifies algorithm tasks, stream relay, algorithm services, model training, and inference under one horizontal load-balancing and elastic scaling fabric. New servers join the fleet with one-click onboarding and immediately become schedulable compute units—the scheduling hub automatically dispatches tasks and balances load based on resource levels and business pressure, enabling linear scaling from hundreds to tens of thousands of camera streams and from a single machine to ten-thousand-node clusters without redeployment or manual tuning. Massive stream ingestion, high-concurrency inference, and distributed training run together in a shared compute pool—truly delivering "scale on demand, run reliably, govern with confidence"
Distributed Storage Driver (Compute + Storage Dual-Cluster Decoupling): Moving beyond the legacy pattern of per-node local directory mounts, hard-coded paths, and config rewrites on every scale-out, the platform replaces raw local-directory drivers with a cluster event-driven storage fabric—Export readiness, client mount state, primary/standby failover, and multi-cluster bridge links are sensed and propagated as events, so snapshots, recordings, alert evidence, and model assets flow into a distributed NFS cluster without business layers tracking mount paths. Compute and storage form two independently scalable domains: the compute side fully embraces the C++ RUNTIME high-speed execution pipeline, while the storage side builds an NFS cluster pool that scales out horizontally without bound—compute and storage grow on their own watermarks, not locked together. With cluster swimlanes, topology views, and multi-cluster bridge sync, new nodes join the storage domain with one-click onboarding, so "compute scales" and "storage scales" advance in parallel under massive stream ingestion—truly delivering "decoupled compute and storage, independent scale-out, event-driven coordination, unified governance, limitless expansion"
Tianditu Spatial Visualization & Map-Based Analysis: Integrated with China's national Tianditu map service, the platform brings cameras, alerts, and person/vehicle recognition onto a single map—upgrading surveillance from "watching feeds" to "seeing the big picture." Both the streaming media and alert modules offer a "Map Distribution" view with a device directory tree for regional focus, giving instant visibility into checkpoint layout and online status. Map click-to-pin, location search, and batch coordinate import help GB channels, NVR channels, and direct-connect cameras get mapped quickly so every feed has clear spatial context. Alerts are automatically placed on the map via linked camera coordinates; filter by time, event type, task, and business tags, then open snapshots and recordings in one click—helping operators move fast from "where did it happen" to action. Combined with face and plate libraries, hits across multiple sites can be woven into spatial trails—trace by person to reconstruct movement and presence within a monitored area; trace by vehicle to link passing records and pinpoint routes and stop zones for find-person/find-vehicle, patrol deployment, and post-incident review. Mobile devices also support track playback to replay patrol and travel paths on a timeline. Switch freely between vector and satellite basemaps with auto-fit view, so managers use the map as the anchor to spot anomalies, lock onto targets, and coordinate response faster
Qwen / DeepSeek Multi-GPU Deployment: Supports deploying Qwen, DeepSeek, and other large language models across multiple GPUs in parallel. GPU resources can be scheduled flexibly at the cluster level, enabling elastic scaling and load balancing of model instances to deliver stable inference under high concurrency and long-context workloads
Vision Large Model Intelligent Understanding: Integrated with QwenVL3 vision large model, supports deep visual reasoning and semantic understanding of real-time video frames, enabling intelligent analysis and scene comprehension of frame content, providing richer visual cognitive capabilities, achieving a leap from pixel-level perception to semantic-level understanding
Real-Time Camera Feed AI Analysis: For RTSP/RTMP real-time video streams, provides full-chain analysis from stream pull, frame extraction, model inference, structured output, and alert linkage—converting frame changes into searchable, analyzable structured detection events with millisecond response. Viewing and algorithm chains operate independently, balancing preview clarity with high-concurrency throughput. Analysis results seamlessly connect with detection regions, defense time periods, face/plate recognition, and orchestrable post-processing rules, upgrading the traditional "human staring at screens, reviewing after the fact" duty model to "machines monitor 24/7, anomalies pushed in seconds, evidence auto-archived", turning real-time video from passive viewing into infrastructure for active perception and intelligent judgment
Intelligent Camera Patrol: Designed for monitoring scenarios with many camera streams but limited staffing, the platform provides split-screen patrol and device-directory batch patrol capabilities, performing rotational AI analysis across large-scale camera fleets under limited concurrent connections. Supports three scheduling modes—rotation, connection pool, and hybrid—automatically capturing frames at set intervals, running detection models, and linking alerts with face/plate recognition. In hybrid mode, focus streams stay permanently monitored while background streams rotate on schedule, balancing priority surveillance and full-area coverage. Patrol progress is pushed in real time, captured frames are automatically archived, and patrol sessions for hundreds of cameras can be launched in one click from split-screen views or device directories—upgrading traditional manual screen-by-screen monitoring to intelligent automated patrol with "fewer connections, broader coverage, faster discovery"
Cloud-Edge-Device Integrated Algorithm Alert Monitoring Dashboard: Provides a unified cloud-edge-device integrated algorithm alert monitoring dashboard that displays key information in real-time, including device status, algorithm task operations, alarm event statistics, and video stream analysis results. Supports multi-dimensional data visualization, achieving unified monitoring and management of cloud, edge, and device layers, providing decision-makers with a global perspective intelligent monitoring command center
Face Recognition and Face Library Management: Supports flexibly enabling face recognition in camera tasks. Provides face library and facial feature management with create/query/update/delete capabilities for face samples and feature vectors, as well as high-performance vector retrieval. Supports efficient face comparison and identity retrieval on captured frames, while fully recording match results, snapshots, camera location information, and device context for personnel trajectory tracing, security forensics, and multidimensional statistical analysis.
License Plate Recognition and Plate Library Management: Enable license plate recognition in monitoring tasks with one click. Automatically reads plate information from passing vehicles and compares against your own plate libraries in real time. Flexibly maintain whitelists, blacklists, and business tags; trigger instant alerts when vehicles match rules—supporting access control at entrances and exits, targeted vehicle watchlists, and visitor vs. registered vehicle management. Automatically registers newly seen plates and keeps complete capture and match records for post-incident lookups, trace verification, and evidence retention. Recognition runs in parallel with existing video analytics without affecting monitoring and alert stability or real-time performance
Device Detection Region Drawing: Provides a visual device detection region drawing tool that supports drawing rectangular and polygonal detection regions on device snapshot images, supports flexible association configuration between regions and algorithm models, supports visual management, editing, and deletion of regions, supports keyboard shortcuts to improve drawing efficiency, enabling precise region detection configuration and providing accurate detection range definitions for algorithm tasks
Intelligent Linked Alert Mechanism: Supports a triple-link mechanism between detection regions, defense time periods, and event alerts. The system intelligently determines whether a detected event simultaneously meets the specified detection region range, falls within the defense time period, and matches the alert event type. Alerts are only triggered when all three conditions are met, achieving precise spatiotemporal condition filtering, significantly reducing false positive rates, and improving the accuracy and practicality of the alert system
Alert Work Orders (AI Alert Responsibility Closed Loop): Makes "AI raises an alert" truly land as "someone is responsible, a workflow follows up, and the outcome is traceable." Once an alert is persisted, routing rules match it automatically (combining alert object / event / task / device / edge node conditions); a hit immediately generates an alert work order and starts a handling process—no manual dispatching, responsibility goes straight to a person. Work orders run on the platform's built-in process orchestration (visual flow designer: approval, countersign, copy, conditional branches, parallel branches, timeout reminders, etc.), supporting approve / reject / return / delegate / transfer / add-signature actions with in-app and mobile notifications (deep links straight to the approval detail). Each alert's handling status, current assignee, and elapsed time stay fully recorded, forming a complete "alert → work order → handling → review" loop; existing alerts can also be manually promoted to work orders as a fallback so none are missed
Large-Scale Camera Management: Supports access to hundreds of cameras, providing end-to-end services including collection, annotation, training, inference, export, analysis, alerting, recording, storage, and deployment
Algorithm Task Management: Supports creation and management of real-time, snapshot, and patrol algorithm tasks; each task can flexibly bind frame extractors and sorters for precise video frame extraction and result sorting
- Real-Time Algorithm Tasks: Real-time video analysis with RTSP/RTMP processing; default backend executor=cpp (starts RUNTIME, default-pushes boxed AI streams and returns alerts/heartbeats), optional python compatibility path
- Snapshot Algorithm Tasks: Captured-image analysis; default can also use executor=cpp (RUNTIME SnapScheduler / Cron)
- Patrol Algorithm Tasks: Multi-stream rotation and connection-pool scheduling; default can also use executor=cpp (RUNTIME PatrolScheduler) for “fewer connections, wider coverage”
Dataset Annotation and Multi-Format Dataset Management: Provides a visual image annotation workspace supporting rectangle and polygon labeling, category management, and progress tracking; fully supports flexible import and export of mainstream dataset formats including YOLO, COCO, and ImageFolder, with cloud platform dataset integration enabling one-click import and synchronized export of cloud-hosted datasets—seamlessly connecting data collection, annotation, training, and deployment across the full pipeline
Multi-GPU Training, Checkpoint Resume, and Node-Side Deployment: Breaks through the training bottlenecks of “GPUs available but unused, tasks hard to control, and progress lost on interruption” by systematically connecting multi-GPU utilization, controllable task scheduling, and node-side deployment—so on-site GPUs are truly usable and training jobs are truly manageable. The platform automatically discovers and schedules all server GPUs; users can select single- or multi-GPU on the training page instead of being limited to “only one card visible.” It supports common dataset formats and directory layouts, large local dataset uploads, and keeps original data after failed runs for quick retry—greatly reducing data-prep and rework costs. Training progress is fully visible, and jobs can be stopped and resumed—avoiding lost results after interruption or “stop clicked but still spinning in the background.” Local and remote training schedulers also roll back promptly on failure with clear feedback. Front-end GPU selection, resume training, and stop-state display are improved in parallel, and issues such as false failure on model publish, custom preview images being overwritten, models not found by name/version, and dataset sync timeouts/conflicts are fixed—making the train–publish–use loop smoother and more reliable
Stream Forwarding: View live camera feeds without enabling AI; batch push and auto NVR channel tasks work out of the box. Default RUNTIME high-performance path keeps multi-channel raw video cheaper on wall—“fill the wall first, AI on critical channels”; special sites can switch to Python/FFmpeg compatibility mode
GPU Discovery, Load-Aware Allocation, and Multi-GPU Collaboration: The platform provides GPU resource discovery and intelligent scheduling: it detects the number of available GPUs and dynamically assigns video encode/decode and algorithm inference work across cards according to per-GPU load, running tasks in parallel where appropriate to raise multi-stream throughput and utilization while keeping the pipeline stable—coordinating frame processing and model inference in multi-GPU deployments
Smart Transport Selection and Resilient Stream Pull: On RTSP and similar pull paths, the system can automatically select appropriate transport modes based on scenario to balance latency and stability. When consecutive frames indicate gray screen, decode errors, or stream stall, automatic reconnect and link recovery run to limit prolonged artifacts or frozen video
Dual Pathways for Watching and Judgment: Split “raw video on wall / split view” from “algorithm results”—duty side prioritizes clarity and smoothness; judgment side outputs boxed results independently, so neither starves the other. The same camera can keep both live and analyzed views, making shift switches natural and channel scale-out no longer a choice between “see clearly” and “analyze enough”
Model Service Cluster Inference: Supports distributed model inference service clusters, achieving intelligent load balancing, automatic failover, and high availability guarantees, significantly improving inference throughput and system stability
Defense Time Period Management: Supports two defense strategies: full defense mode and half defense mode, allowing flexible configuration of defense rules for different time periods, achieving precise time-based intelligent monitoring and alerting
OCR and Speech Recognition: Provides high-precision text recognition and speech-to-text capabilities, supporting multi-language recognition
Multimodal Vision Large Models: Supports various vision tasks including object recognition and text recognition, providing powerful image understanding and scene analysis capabilities
LLM Large Language Models: Supports intelligent analysis and understanding of multiple input formats including RTSP streams, video, images, audio, and text, achieving multimodal content understanding
Model Deployment and Version Management: Supports rapid deployment and version management of AI models, enabling one-click model deployment, version rollback, and gray release
Multi-Instance Management: Supports concurrent operation and resource scheduling of multiple model instances, improving system utilization and resource efficiency
Camera Snapshot: Supports real-time camera snapshot functionality with configurable snapshot rules and trigger conditions, achieving intelligent snapshot capture and event recording
Snapshot Storage Space Management: Provides storage space management for snapshot images with quota and cleanup policy support, ensuring rational utilization of storage resources
Video Storage Space Management: Provides storage space management for video files with automatic cleanup and archiving, achieving intelligent storage resource management
Snapshot Image Management: Supports full lifecycle management of snapshot images including viewing, searching, downloading, and deletion, providing convenient image management functionality
Device Directory Management: Provides hierarchical device directory management with device grouping, multi-level management, and permission control, achieving organized and fine-grained device management
Alarm Recording: Supports automatic recording triggered by alarm events. When abnormal events are detected, relevant video clips are automatically recorded, providing a complete alarm evidence chain. Supports viewing, downloading, and management of alarm recordings
Alarm Events: Provides comprehensive alarm event management functionality, supporting real-time alarm event push, historical query, statistical analysis, event processing, and status tracking, achieving full lifecycle management of alarms
Video Playback: Supports fast retrieval and playback of historical recordings, providing convenient operations such as timeline positioning, variable speed playback, and keyframe jumping. Supports synchronized playback of multiple video streams, meeting event backtracking and analysis needs

#### 🌐 IoT Capabilities

Many projects reduce IoT to a "device ledger + message relay"—devices connect but cannot be governed; data reports but cannot drive action; alerts fire but the site stays invisible; you have data but cannot build screens or align with process flows. EasyAIoT positions IoT as the execution nerve in a sense—understand—decide—act closed loop: sensors and actuators provide "numbers," cameras and AI provide "pictures," visualization dashboards and SCADA configuration turn "numbers" into commandable situational awareness, and rules plus device shadows weave both into operable business actions—so the platform not only "sees clearly," but also "displays on screen, understands the process, governs effectively, controls precisely, and scales openly."

Visual Management: When device metrics, alerts, and business KPIs stay trapped in lists and message payloads, leadership cannot see the full picture, duty staff cannot read the situation, and reports still need separate PPTs—data value stalls at "collected but not displayed." The platform consolidates visualization projects, template center, asset library, data sources, and service deployment into one capability: drag IoT data into operational dashboards for campus situational awareness, production-line KPIs, equipment operations, and more—draft, refine, publish, and deploy—upgrading IoT from "data in the back office" to "screens in the front office," without bolting on a separate dashboard tool for command and display
Visualization Project Full Lifecycle: When dashboard projects live on personal PCs and temporary links, handoffs get messy, versions get lost, and go-live becomes contentious. The platform manages dashboard project creation, editing, preview, publishing, and retirement in one place—table/card views for inventory, published vs. unpublished at a glance—who is working on what, how far along, and whether it can go on the wall; project status is trackable, handoff-ready, and acceptance-ready, turning "build one screen" into a deliverable operational asset
Visualization Template Center: Starting every project from a blank canvas inevitably stretches delivery with design and integration. Mature templates for campus overview, factory situational awareness, equipment boards, and more can be reused—create a new project, apply a template, fine-tune—fewer blank-canvas starts for similar scenarios, faster PoC and multi-project replication with consistent metrics, turning "did it once" into "can deliver many times"
Visualization Assets & Data Source Governance: When icons, backgrounds, and video assets are hoarded per project and data APIs are rewritten per screen, styles clash and fields drift. The asset library centralizes reusable visual assets; data sources uniformly connect device and business APIs—the same visual style and data definitions serve multiple dashboards; change once, benefit everywhere, with less duplicate build and fewer metric disputes
Visualization Publishing & Service Deployment: A dashboard that cannot be deployed is wasted effort. After confirmation, projects link to service deployment and go live in command centers, duty rooms, or public display entry points—preview and production use the same project—from "edit mode" to "on-duty mode" with a clear path; acceptance and daily watch no longer rely on temporary links and verbal agreements
SCADA Configuration Management: Industrial and building sites fear "gauges everywhere but process unreadable"—meters, valves, and tank levels have readings, yet duty staff cannot map them to pipelines and steps, and anomalies are guessed from experience. The platform provides Web SCADA capability, binding device metrics to water-plant process overviews, production-line boards, plant network topology, electrical room monitoring, and more—edit and preview in one entry, publish for duty—so "numbers" return to "diagrams," process state is obvious at a glance, and watch shifts from flipping tables to reading process diagrams for judgment and action
SCADA Screen Real-Time Monitoring & Limited Control: Pure list monitoring "shows points but not the process"—slow anomaly localization, hard shift handoffs, and on-site training by senior staff only. SCADA runtime animates key metrics onto tanks, valve groups, motors, and switches; trends and status refresh on one screen; limited start/stop and reset actions can be done from the diagram when needed—newcomers learn from the diagram, shifts hand off on the same screen, and anomalies compress from "find the point" to "read the process," bringing industrial sites into daily operations that are watchable, accountable, and extensible
Product Model Management: The costliest part of IoT rollout is often not buying devices, but rebuilding profiles for every new device class. Products serve as templates for similar devices—create, enable/disable, search, and switch between table/card views; configure application scenarios, vendor, and model once—then scale by reusing the product template instead of filling each unit from scratch. Define once, reuse many times, and turn linear access cost into a reusable asset
Multi-Type Product Modeling: When direct terminals, edge gateways, gateway sub-devices, and video devices coexist, forcing one access path mixes topology and breaks protocols. Model four forms separately—direct-connected, gateway, gateway sub-device, and video—so edge aggregation, direct terminals, and video devices each follow their own path. Topology stays clean, protocols stay correct, and large-scale onboarding starts from the right product skeleton
Product Access Protocol & Auth Configuration: Agreeing protocol and auth per device is a classic source of integration rework. Finalize access protocol (MQTT / TCP / HTTP / Modbus-TCP / Modbus-RTU / OPC UA), data format, authentication, and encryption/decryption at the product level; child devices inherit the same rules—no more per-device auth or payload negotiations. Access norms shift from “oral tradition” to an inheritable product-level contract
Modbus-TCP industrial Ethernet access: For meters, PLCs, VFDs and other Ethernet-side industrial devices, built-in Modbus-TCP master acquisition—configure access parameters and measurement points at product/device level to go live; polled reads flow into device shadow and online status; register writes and property downlink are connected, so industrial points share the same closed loop as IoT thing models, rule engine and alarms—no separate SCADA/acquisition tool required.
Modbus-RTU serial field access: Many field instruments remain on RS-485; TCP-gateway-only paths double cost and failure points. Platform supports Modbus-RTU serial master acquisition, works with virtual and real serial ports—bus-side devices enter unified management and uplink/downlink control, filling the gap where Ethernet cannot reach and serial was unmanaged.
OPC UA industrial interconnect access: For modern industrial control and upper-system interconnect, OPC UA client access—configure node address, namespace and point mapping for subscribe/read/write; complex device models map to platform thing-model properties; uplink acquisition and downlink write points seamlessly connect to device shadow, rule chains and message push—bringing OPC UA field assets into an AIoT ops system that can “see, control, and link”.
EDGE C# edge collection runtime: An independently deployable edge collection module for industrial sites—C# pluggable collectors for Modbus RTU, Modbus TCP, OPC UA, and more; local scheduled acquisition and config-driven parsing; MQTT integration with DEVICE/iot-sink on the cloud platform. It maps to the GATEWAY role in device management (not a separate device UI): on-site aggregation, cloud-side governance; gateway/sub-device property uplink-downlink and config push are covered; topology and sub-device event/service passthrough are still evolving. Packagable for x86_64 / ARM64 Linux industrial PCs and edge gateways—"accurate on site, governed in the cloud" cloud-edge closed loop
Thing Model Property Definition: If dashboards, rules, and alerts each invent their own metric names, they will never understand each other. Define reportable/readable-writable properties first, with standard templates and custom ones; edit as draft, publish to take effect—dashboards, rules, and alerts then share one field set. “What can be observed” has unified semantics, and inconsistent metric-name rework is cut at the root
Thing Model Service Definition: Writing a one-off API for every remote start/stop or reset fragments the control plane. Define callable services with input/output parameters as a contract; edit as draft, publish to take effect—“what can be done remotely” is invoked by filling contract parameters, without stacking one-off control APIs. Control becomes reusable and auditable
Thing Model Event Definition: Without agreeing upfront on which business events devices report, alert wording will conflict over time. Define event types first; after draft publish they take effect uniformly—event logs and rule triggers share the same semantics. “What can happen” has one vocabulary, and alerts no longer speak past each other
Thing Model Publish Control: Pushing model changes straight to online devices can hit an entire fleet with one misoperation. Changes land as drafts first; only confirm-and-publish pushes them to the device side—unverified edits never strike live field devices, and misoperation risk drops sharply
Protocol Script Adaptation: The hardest part on site is rarely standard MQTT—it is private multi-vendor payloads and black-box devices that only local tools can debug. Standard messages work out of the box; for private protocols, write uplink/downlink encode-decode scripts with templates, validation, instant debug, and save-to-hot-reload—integration shifts from “change firmware and wait on the vendor” to “configure a script and hot-apply.” Legacy multi-vendor devices join a unified thing model without firmware changes
Product Access Guide: If newcomers depend entirely on on-site expert walkthroughs, delivery pace is capped by people. Product details include built-in integration parameters, auth, message samples, and acceptance notes—follow the page to accept a device. Each product ships with a standard integration playbook, less reliance on oral expertise, and faster, steadier PoC and acceptance
Product-Linked Device Overview: Ops and acceptance often argue over “how many devices does this batch cover, and what’s the online rate?” Open a product to see its device list and online status—coverage and online rate at a glance, with clear ownership boundaries between ops and acceptance
Device Profile Management: Devices scattered across spreadsheets, chat logs, and field memory make inventory and handoff chaotic. Full CRUD, search by product/identifier/online status, and table/card views turn scattered terminals into a searchable ledger—inventory, handoff, and expansion all enter through one door
Device Online & Activation Status: Problem devices buried in “all devices” force blind hunting on duty. Lists and details surface connection status, activation status, activation time, and last online time—offline and inactive units float up first, so ops energy hits truly abnormal devices
Register Devices by Product: Re-picking protocol and re-filling auth for every new unit is the biggest friction in scale-out. Bind the product on create to inherit protocol and scenario—registration attaches the right template; scale by cloning the product, with far less repeated protocol/auth work
Industrial Collection Access Config: If meters and sensors still need a separate collection tool, the site ends up running dual systems. When registering industrial collection devices, configure host, metrics, and collection interval in the same step—field points are filed once, no switch to another SCADA/collection tool; industrial collection and platform onboarding complete together
Device Basic Profile: If replacement, accountability, and reconciliation rely on verbal “who is this,” the responsibility chain breaks. Persist name, identifier, SN, product, version, IP, and other one-device-one-record fields—open the profile to confirm identity, with less verbal chasing and on-site digging
Device Access Guide: If field integration still means hunting thick docs and asking experts, go-live stretches endlessly. Per device type: recommended commands, integration parameters, auth, messages, and acceptance notes; copy commands after parameter edits—integration becomes copy-command acceptance, and go-live/PoC pace tightens
Real-Time Running Status: If operators must log into devices and parse raw payloads every time to judge metrics, duty cost stays high. Spread current property live values by thing model, with table/card views and refresh—judge key metrics at a glance without logging into devices or reading raw messages
Sensor Float Data Prediction: If key metrics can only be reviewed after the fact on historical curves, anomalies often stay invisible until they have already crossed the line. The platform forecasts trends for sensor float properties, turning past readings into forward-looking trajectories—ops upgrades from “looking at numbers after the fact” to “seeing ahead,” buying time to act
Running-Status Property Thresholds: If health boundaries live only in code or oral agreements, every new model or scenario means rework. Configure upper/lower thresholds for running-status properties by thing model—boundaries become definable, reusable, and fine-grained, turning each device’s “normal range” into a governable asset instead of scattered tribal knowledge
Threshold Alarms & Threshold Rules: Thresholds are decoration if crossings go unnoticed or cannot be linked. Out-of-bound metrics trigger alerts automatically and can drive rule-based actions—“know when crossed, manage when known,” closing health boundaries into an operable loop
Central-Device Associated Sub-Device One-Screen Control: If subordinate health must be checked device by device, inspection and incident response always lag. From the central-device view, survey associated sub-device running status on one screen—no device-by-device switching, faster field inspection and anomaly localization, so the device side truly closes the loop of “see the numbers, govern the bounds, raise the alerts, and grasp the whole picture”
Device Shadow Comparison: Classic troubleshooting pain is not knowing whether “desired” matches “actual.” View reported state, desired state, and diffs side by side, with full JSON retained—troubleshooting shifts from guessing to comparing, and consistency is obvious at a glance
Desired Property Push: Driving to site just to change one parameter is classic scale-out waste. Batch-edit desired values for writable properties and push in one click; track processing/success/failure—remote tuning has receipts, no truck roll for a parameter change, fewer wasted trips
Thing Model Service Invocation: If start/stop or reset cannot confirm execution after issue, disposal falls back to verbal accounting. Fill parameters for published services and invoke; track command receipts—actions confirm whether they executed, disposal is auditable, and “we said we controlled it” upgrades to a closed loop with receipts
Offline Command Queue: Commands dropped during weak network or brief offline must be redone later. While offline, commands still write to desired shadow and are pulled or received after reconnect per protocol—control intent survives jitter, catch-up on return, fewer repeated operations
Sub-Device Gateway Proxy Control: Requiring every edge terminal to connect directly to the platform explodes access complexity and certificate cost. Sub-devices are controlled via their parent gateway—edge terminals can be remoted without direct platform links, lowering terminal access complexity and making the gateway a truly operable aggregation plane
Linked Cameras: Sensor alerts without a live view leave operators “hearing numbers and guessing the scene.” IoT devices can bind cameras from the device catalog, mapping telemetry points to video locations—when something goes wrong, you know which stream to open, upgrading “report a number” to “find the picture”
Split-Screen Monitoring & AI Linkage: This is EasyAIoT’s key difference from pure IoT platforms—pure IoT “sees numbers but not the site,” pure video “sees the site but cannot control devices.” In function invocation, switch 1/4/9 split-screen preview of linked cameras and enable AI analysis—tune parameters and issue commands while watching the site. “Numbers” and “pictures” are verified and handled on one screen, with fewer system switches and missed judgments—true AI + IoT fusion value
Event Logs: Alert pop-ups vanish in a flash; postmortems then rely on memory and argument. Aggregate info/warning/error events from devices; filter by type, name, and time—reviews read the raw event stream, answering “what happened on site” with evidence, not just instantaneous pop-ups
Command Logs: Integration troubleshooting fears both sides claiming opposite facts: did the command reach the device, and did it accept it? Track processing/success/failure for property sets and service calls—end verbal blame games; the command path is checkable and accountable
Device Logs: If locating firmware or business faults still means logging into devices for local files, field network and permission walls kill efficiency. Aggregate multi-level device-side logs to the cloud with keyword and time search—locate anomalies in the cloud without logging into devices for local logs
Gateway Sub-Device Binding: Industrial and building sites often hang dozens or hundreds of sub-devices under one gateway; if topology lives only in oral memory, expansion and fault isolation fail. Gateways can batch bind/unbind sub-devices—who hangs under whom is clear, and ownership stays sharp when expanding, replacing gateways, or isolating faults
Topic Capability Inventory: If R&D and integration each hold a different channel contract, integration rework is guaranteed. Per device, list uplink/downlink channel docs for config, shadow, properties, services, events, OTA, clock sync, and more—integrate against one shared catalog, with fewer reworks from mismatched channel agreements
OTA Package Management: If patches and firmware rely on USB-stick copying device by device, scale-out upgrades are nearly impossible. Centrally upload and archive software/firmware packages with version, download, edit, delete, and dual views—patches and firmware live in one reusable place, no per-device media copying; firmware becomes a manageable delivery asset
OTA Upgrade Strategy: Missed upgrades leave security holes; chaotic upgrades create compatibility risk—the classic scale-out dilemma. Mark critical versions and choose forced/non-forced modes—urgent fixes can be pushed through, routine versions stay orderly, and both miss-upgrade and chaos risks stay controlled
Rule Chain Management: Business linkage rules scattered everywhere and impossible to toggle centrally breed false triggers and idle chains. Create, enable/disable, and batch-delete rules with list/card management—linkage chains switch centrally, idle rules turn off anytime, and false triggers drop
Visual Rule Chain Orchestration: Field business changes daily—thresholds to tune, linkages to add—if every change waits on custom code, response is always half a beat late. On a chain canvas, link data flow, conditions, and downstream actions by intent—scenario changes land by drag-and-drop, no waiting on a sprint. “What happens after device data arrives” is configured by business users
Rule Import/Export: If mature rules cannot travel, every project rewrites from scratch. Import/export rules across environments and projects—mature rules become copyable delivery assets
Message Configuration: If swapping notification channels or accounts still requires business-code changes, ops stays blocked by developers. Centrally maintain notification channels and base message settings—swap channels or accounts by config only, without touching business code
Message Templates: Ad-hoc alert wording is error-prone and hard to unify. Maintain templates for email, SMS, Enterprise WeChat, DingTalk, Feishu, Webhook, and more—copy once, reuse everywhere; unified alert wording, fewer temporary composition mistakes
Message Push: Even perfect detection and complete device events are worthless if stuck inside the system waiting for someone to open it. Create push tasks by channel; test first, then start—alerts and business events land in owners’ daily work tools, not trapped in the system
Push History: Without records of whether notices were sent or delivered, audit and optimization are guesswork. Review push records by channel—sent or not, delivered or not, with evidence for audit and reach-strategy improvement
Notification Users & Groups: All-hands critical alerts cause fatigue; missing the right people causes misses. Maintain notification users and groups for precise reach by role/shift—the right people get them, all-hands spam fatigue drops, and sense—judge—notify—act finally closes to the person
TRANSFORM Multidirectional Business Flow: If platform-side alerts, device events, and business results stay trapped inside EasyAIoT, integrating MES / ERP / CRM / WMS still means per-project custom APIs—delivery cycles and rework costs explode. TRANSFORM turns “who to send to, by which rules, how fields map, and whether it arrived” into configurable capability: destinations, forwarding rules, and mapping templates are set once and reused; delivery is monitorable and reviewable—multi-system integration shifts from “custom API per partner” to “wire by contract, accept by trail,” so platform data truly enters the customer’s existing business loop

#### 📱 Mobile APP

Multi-Channel Access: Available on phones, mini programs, and apps—ops and management are no longer tied to a desk; handle issues on-site in real time
Capability Parity: Mobile matches the PC admin console feature-for-feature; switch devices without losing control
Device Management: Unified management across access methods; browse channels at a glance and tap for live view—stay informed during field inspections
Stream Forwarding: Create and stop forwarding anytime; see node and channel status; multi-channel raw video can go on screen efficiently—even while away from the desk
Algorithm Tasks: Start and stop real-time and snapshot tasks on the go; track detection results without waiting to get back to the office
Alert Center: Search alerts instantly; tap to view snapshots and recordings—verify and follow up while on mobile duty
Model Management: Deployment status at a glance; always know what's live
Model Inference: Upload an image on-site and get results immediately—spot checks without returning to PC
Model Training: Monitor training progress anytime; stop remotely when needed to avoid wasted compute
Personal Center: Account, tenant, and app preferences in one place—convenient across devices
Smooth Viewing: Live feeds and alarm recordings play smoothly on mobile—low latency, no stutter, uncompromised duty experience
Stay Connected: Sessions stay active with less re-login—bringing cloud-edge-device intelligent control to phones and mini programs

#### 💻 IDEA Cloud IDE

Develop in the browser: VS Code–style online IDE on code-server; clones the full EasyAIoT repo by default—contributors can edit, run module-level checks, and open PRs without setting up a local toolchain first
Standalone portal and multi-user: Ops console on :9300, decoupled from the WEB admin; one Docker workspace per person; port pool 13338–13437 for concurrent users; console floating ball jumps to the portal
Six-language toolchain aligned with the host: Preinstalled JDK 21, Node 22, Python, Go, CMake/C++, and .NET 8—covers reading, light edits, and module-level checks for WEB / DEVICE / AI / RUNTIME / EDGE
AI co-creation: GitHub Copilot preinstalled (sign in with your own GitHub account; the platform never holds keys); without a Copilot subscription, bring your own OpenAI-compatible API key via Continue; toolbar opens HARNESS AI Assistant in a split pane—drag files to auto @-mention while you edit
Local publish: Suggests modules from workspace diffs, one-click build and replace running containers on the host—refresh to verify, shortening the edit-to-see loop
OAuth and idle reclaim: Gitee / GitHub login (can be required), one account per workspace; idle auto-stop after 8 hours by default; heartbeat and opening the IDE refresh activity so compute is not left spinning
Contribution loop: Bind your fork → branch → edit → push to the fork → open a PR to upstream

### 🔌 LLM Unified Gateway — One Protocol, Every Major LLM Vendor

The platform converges every major LLM vendor onto a single OpenAI-compatible protocol (/v1/chat/completions). Only one model is active at a time — all in-page AI capabilities (image/video understanding, auto labeling, chat) switch to it instantly. Adding a vendor is zero-code: just one entry in the template registry. Preset template data is seeded automatically on first deployment (placeholder keys sk-placeholder-*, inactive); fill in a real API key in the editor and enable it — the UI guides you through the whole flow.

Preset template data: 6 templates (DeepSeek / Bailian / GLM / OpenAI / Kimi / Claude) are seeded on fresh deployment; activation and connectivity tests are blocked until a real API key replaces the placeholder — no dead-end 401s
For other services: the platform exposes the active model as an OpenAI-compatible endpoint (POST /v1/chat/completions, GET /v1/models) — any OpenAI SDK can call it with a Bearer token
Resilience: ordered parameter fallback (temperature → max_completion_tokens), streaming SSE, per-vendor timeouts

### 🤖 RAG Knowledge Base & AI Agents

Built on the unified LLM gateway, the platform turns business documents into answerable knowledge assets packaged as conversational AI agents — one pipeline from knowledge curation to retrieval-backed answers to in-page and in-IDE assistants.

Documents → segments → knowledge sets: Upload TXT / Markdown / CSV / JSON / LOG files (UTF-8, up to 10 MB); each document is auto-split into Milvus vector-indexed segments — editable, individually toggleable in retrieval, and composable across documents into reusable knowledge sets
RAG experts (agents): Combine multiple knowledge sets, set a role prompt and welcome message, and start chatting — answers cite 【Source N】, refuse to fabricate when the material is insufficient, and degrade gracefully to retrieval-only mode when the model is unreachable
Hybrid retrieval: Milvus vector search fused with keyword/BM25-style scoring; an offline local-hash embedding fallback keeps the whole chain demo-able without external keys
AI assistant: A floating assistant answers right on business pages; the HARNESS conversational assistant lives inside the IDEA cloud IDE — drag files to auto @, co-create in split pane — and the same easyaiot_* capabilities are exposed via MCP + Cursor Skill to Cursor and other IDEs

### 🧠 LLM Post-Processing for Alerts (LLM Judgment) — From “Detected” to “Trusted”

Traditional vision algorithms solve “seeing” but leave “believing” to people — bounding boxes for helmets, line-crossing, flames and sleep-on-duty flood the screen every day, forcing watch officers to open each alert image and re-check it manually; false alarms drown out real incidents, and real incidents are feared to be missed. EasyAIoT connects LLM semantic understanding to the alert pipeline: algorithm tasks can attach LLM post-processing rules, alerts that match a rule automatically enter a dedicated judgment queue, where a multimodal LLM inspects each scene image (or short clip) one by one and writes back a “Confirmed / False Positive” verdict with confidence and reasoning — watch officers go from “staring at every frame” to “reading conclusions”, and high-frequency false alarms are kept out of notifications.

Dedicated async judgment queue: rule-matched alerts are delivered via Kafka and judged asynchronously — slow or flaky models never block alert persistence or the notification pipeline; a failed judgment only logs, never disrupts the main flow
Sampling & throttling control cost: matched alerts enter the LLM queue by a sampling rate (e.g. 10% = 1 in 10), combined with a per-task minimum judgment interval to avoid repeated calls on high-frequency events; alerts not sampled or throttled are automatically marked “Not Sampled / Rate-Limited Skipped”, decoupling LLM spend from alert volume
Image / video dual judgment: image judgment by default, switchable to short-clip judgment with configurable pre/post event windows and max slice duration; automatically falls back to image judgment when footage is missing
Gated notifications (secondary judgment): for false-alarm-sensitive tasks, notifications are sent only after the LLM confirms the event; false positives are suppressed — turning an alert storm into precise reminders, so duty phones are not bombarded
Failure policy chosen per site: on model-call failure choose skip (leave original result) / confirm (let notification pass) / reject (suppress notification) — trade false-negative vs false-positive risk the way the site prefers
Bindable agents & models: judgment can mount a RAG expert (answering with knowledge-base context), or pin a specific LLM, override the judgment prompt, and force JSON structured output — vendor switching is one click away via the unified LLM gateway
Full verdict write-back & display: judgment status (Confirmed / False Positive / Judging / Failed / Not Sampled…), confidence, reasoning and structured attributes are all written back to the alert; WEB and APP alert lists carry status tags, filter by “Sampled / Not Sampled / per verdict”, and the judgment detail modal shows the image, verdict, reasoning and execution info in one screen

### 📦 Built-in AI Models

The platform is ready to use out of the box, with multiple pre-trained models built in for security monitoring, industrial sites, smart transportation, and similar scenarios. Select them directly in algorithm tasks for rapid deployment and inference—no training from scratch required to cover common vision detection needs.

We believe no single programming language excels at everything. EasyAIoT uses six programming languages mixed by scenario: Java for platform architecture, Python for AI algorithms, C++ for video execution, Go for protocol gateway, TypeScript for management UI, C# for edge industrial acquisition—cloud management, algorithms, execution, protocols, UI, and on-site acquisition each in its place, forming a complete cloud-edge-device technical closed loop.

Java excels at building stable and reliable platform architectures, but is ill-suited to network programming and AI development; Python excels at network programming and AI algorithms, but hits GIL and process-overhead bottlenecks on high-channel, low-latency frame execution; C++ excels at high-performance task execution, but is ill-suited to platform architecture and algorithm orchestration; Go excels at high-concurrency networking and protocol implementation, but is ill-suited to platform control planes and AI algorithms; TypeScript excels at complex front-end interactions and type-safe engineered UIs, but is ill-suited to high-performance backend computing and AI inference; C# excels at industrial protocol acquisition and edge runtime orchestration, with strong typing ensuring reliable point mapping and protocol parsing, async/await supporting concurrent multi-device polling, .NET cross-platform publishing adapting to x86/ARM industrial sites, mature industrial/SCADA ecosystem with fast integrator onboarding, but is ill-suited to cloud platform core business and AI algorithms. Six languages each play to their strengths and avoid weaknesses—challenging to implement, yet extremely easy to use.

![EasyAIoT Platform Architecture.jpg](.image/iframe2.jpg) ### 🔄 Module Data Flow

### 🤖 Zero-Shot Labeling Technology

Innovatively leveraging large models to construct a zero-shot labeling technical system (ideally completely eliminating manual labeling, achieving full automation of the labeling process), this technology generates initial data through large models and completes automatic labeling via prompt engineering. It then ensures data quality through optional human-machine collaborative verification, thereby training an initial small model. This small model, through continuous iteration and self-optimization, achieves co-evolution of labeling efficiency and model accuracy, ultimately driving continuous improvement in system performance.

### 🏗️ Project Architecture Features

EasyAIoT is not actually one project; it comprises multiple independently deployable sub-projects (WEB, DEVICE, EDGE, VIDEO, RTC, AI, and more).

What's the benefit? Suppose you are on a resource-constrained device (like an RK3588). You can extract and independently deploy just one of those projects. Therefore, while this project appears to be a cloud platform, it simultaneously functions as an edge platform.

🌟 Genuine open source is rare. If you find this project useful, please star it before leaving - your support means everything to us!
(In an era where fake open-source projects are rampant, this project stands out as an exception.)

### 🌍 Localization Support

EasyAIoT actively responds to localization strategies, providing comprehensive support for localized hardware and operating systems, delivering secure and controllable AIoT solutions for users. Deployment and PANEL packaging already cover domestic OS targets such as Kylin (麒麟) / openEuler (欧拉).

🖥️ Server-Side Support

Full compatibility with Hygon x86 architecture processors
Support for localized server hardware platforms
Targeted performance optimization solutions
Ensures stable operation of enterprise applications

📱 Edge-Side Support

Ordinary development boards can perform on-site intelligent watch duty
EDGE C# edge collection deployable independently on industrial PCs and RS485 sites
Lightweight deployment on site—no need to stack heavy storage at every site
Intelligence out of the box, shortening edge go-live cycles
Compute scales with deployment points; alerts and evidence automatically aggregate to the cloud

🖱️ Operating System Support

Compatible with Kylin (麒麟) / openEuler (欧拉)
Support for localized Linux distributions like Founder
Adaptation to mainstream localized operating systems like UOS
Provides complete localized deployment solutions

## 🎯 Application Scenarios ![Application Scenarios.png](.image/适用场景.png) ## 🧩 Project Structure

EasyAIoT comprises core modules including WEB, APP, DEVICE, EDGE, SENTINEL, VIDEO, RTC, AI, RUNTIME, POST, VISUALIZE, TRANSFORM, PANEL, IDEA, HARNESS, and SITE, plus COMPILE multi-platform packaging and delivery:

Module	Description
SITE Module	Official value entry: Standalone official website for visitors, integrators, and end customers—explain cloud-edge-device integration clearly, then guide people to download and deploy Shorter learning path: Features, four hardware tiers, installer entry, and docs on one site—less time hunting the repo or asking around for packages Supports tier selection: Present edge / mini / standard / full for light standalone, edge boxes, AI cameras, and full-stack appliances so sites pick the right tier once From interest to install: Website, demo, open-source repos, and Releases form one loop—understand → try → download → install
WEB Module	Unified Admin UI: Frontend management interface with a consistent user experience Multi-Protocol Onboarding Wizard: Tabbed guides for IPC / NVR / GB28181 / RTC platforms; ONVIF scan, cross-subnet scan, manual RTSP, DJI livestream, and consumer-camera P2P access RTC Platform Access: "Connect RTC camera" shortcut with dynamic forms for Tapo / Tuya / Ring / Nest / Xiaomi / Wyze / DoorBird / GoPro / Roborock; OAuth platforms guided to go2rtc WebUI for binding
APP Module	Multi-Channel Access: One build, multiple touchpoints—phones, mini programs, and apps Capability Parity: Matches PC admin console capabilities with multi-tenant switching Device Management: Unified management for direct cameras, GB28181, NVR, and RTC consumer cameras; online status and channel browsing with one-tap live preview in device details Stream Forwarding: Task create/start/stop, node status, and multi-channel viewing; switch high-performance / compatibility mode by site Algorithm Tasks: Real-time/snapshot algorithm task list, start/stop control, and detection/frame stats Alert Center: Alert search, snapshot preview, and alarm recording VOD playback Models & AI: Model list and deployment status, mobile image inference workbench, training task progress monitoring and stop Profile: Personal info, account security, FAQ, feedback, and app settings
ANDROID / IOS / HARMONYOS Module	One frontend, three native shells: APP uni-app pages packaged into installable apps on Android (DCloud offline runtime + Gradle → APK), iOS (WKWebView shell + xcodebuild → .app / .ipa), and HarmonyOS (ArkWeb shell + hvigor → HAP)—same business logic on every mainstream phone OS One-command packaging: `make-apk.sh` / `make-ipa.sh` / `make-hap.sh` with version-consistency checks; prod / test / dev environments build independent artifacts Unified management: `.scripts/docker/mobile.sh` for status / build / bump / artifacts / clean; `bump` updates all five version fields at once and packaging refuses mismatched versions
DEVICE Module	Device Management: Device registration, authentication, status monitoring, lifecycle management Product Management: Product definition, thing model management, product configuration Protocol Support: Multiple IoT and industrial protocols including MQTT, TCP, HTTP, Modbus-TCP, Modbus-RTU, OPC UA Device Authentication: Device dynamic registration, identity authentication, secure access Rule Engine: Data flow rules, message routing, data transformation Data Collection: Device data collection, storage, query, and analysis Node Orchestration: Compute/media node onboarding, connectivity testing, workload scheduling, and media node pool allocation Visualization Backend: Unified management of dashboard/SCADA projects, templates, assets, data sources, and service deployment, providing project management and publishing for the visualization editor and Web SCADA
EDGE Module	Why C#: Strong-typed point mapping, async multi-device concurrent polling, 7×24 long-running stability, Linux x86/ARM cross-platform self-contained publishing—mature industrial ecosystem, fast integrator onboarding C# edge collection runtime: Independently deployable edge-side collection service—pluggable collectors + local scheduling + config-driven parsing Multi-protocol collectors: Built-in Modbus RTU (RS485/serial), Modbus TCP, OPC UA collectors; extend via `ICollector` plugins per job MQTT cloud-edge integration: Joins as device-management GATEWAY—property reporting, sub-device property proxy reporting, cloud config push (`config/downstream/push`) and property write downlink—integrated with DEVICE/iot-sink; data shown in the same device management UI, complementary to cloud-side industrial polling (platform reaches field devices directly)—EDGE suits OT isolation and RS-485 field sites Dual config channels: Local `device-jobs.json` and cloud MQTT config push both drive collection jobs Linux packaging: `pack_linux.sh` produces x86_64 / ARM64 standalone deployment packages for industrial PCs and edge gateways Out-of-box integration: Built-in E2E demo validates collection → MQTT uplink → cloud persistence; cloud platform integration included
SENTINEL Module	Business-readiness sentinel: Travels with every schedulable node; continuously checks whether the box can truly take the selected workloads Monitor on onboard: Inspection starts automatically after join—accept readiness the same day of scale-out Schedulable capacity aggregation: Surfaces “can this node run this business?” in the console so dispatch follows real capability Self-serve gap fill-in: Requests platform fill-in when expected environment is missing—fewer on-site installs Air-gap friendly scale-out: Offline onboarding and environment sync for sites without public internet One delivery language: Component health and schedulable functions on one screen—less guessing during acceptance and troubleshooting
VIDEO Module	Stream Processing: Supports RTSP/RTMP stream real-time processing and transmission Multi-Protocol Camera Access: Unified management for GB28181, ONVIF, NVR batch scan, DJI FlightHub livestream, and RTC consumer cameras RTC Integration API: `/register/device/rtc-live` one-click go2rtc stream registration and device enrollment; auto-cleanup of RTC streams on device delete Algorithm Task Management: Supports realtime / snapshot / patrol; high-performance execution is the default with boxed judgment views, and compatibility mode remains available Stream Forwarding Orchestration: Multi-channel raw wall display defaults to high performance; special sites can use compatibility mode; start/stop and policy changes follow automatically to cut manual rework Frame Extractor and Sorter: Supports flexible frame extraction strategies and result sorting mechanisms, each algorithm task can bind independent frame extractors and sorters Defense Time Period: Supports time-based configuration for full defense mode and half defense mode Orchestration vs Execution: VIDEO owns device orchestration, raw preview, alert archiving, and start/stop; heavy lifting goes to RUNTIME (inference and high-performance forward)—“governed” and “fast” stay separate so channel count and latency are not dragged by Python orchestration Handoff to POST judgment: Algorithm tasks can configure post-processing rules so detections enter standard alerting only after custom judgment—change rules without stopping analysis Acceptance Preview: Side-by-side raw vs judgment views for faster on-site checks of latency and overlay quality
RTC Module	go2rtc: Built on go2rtc source; vendor pulled by install script Nine-Brand P2P Bridging: Tapo (TP-Link) — home/store IPC, cloud-password connect + two-way audio Tuya — mass white-label/OEM camera onboarding Ring (Amazon) — doorbells/outdoor cams for overseas sites Nest (Google) — Nest Cam / Doorbell for premium projects Xiaomi (Mi Home) — domestic fleet reuse without Micam Wyze — ultra-low-cost IPC for pilots and wide fill-in DoorBird — smart doorbell entry intercom + video GoPro — HERO9–12 mobile views / emergency patrol Roborock — vacuum cameras for moving under-furniture views Unified Management API: Platform registry, stream URL builder, go2rtc REST proxy; default ports 6100 (mgmt) / 1984 (WebUI) / 8554 (RTSP) Full VIDEO Pipeline: P2P ingest → standard RTSP → SRS relay → Web playback and AI analysis—consumer and pro cameras under one ops model Docker All-in-One: Single container runs go2rtc core + Python management service; host network for P2P LAN access
AI Module	Intelligent Analysis: Responsible for video analysis and AI algorithm execution Model Service Cluster: Supports distributed model inference services, achieving load balancing and high availability Real-Time Inference: Provides millisecond-level response real-time intelligent analysis capabilities Model Management: Supports model deployment, version management, and multi-instance scheduling
RUNTIME Module	High-Performance Native Execution: One binary owns pull, decode, ONNX inference, alert/heartbeat callbacks, and boxed push; default `executor=cpp`—more channels per box, lower latency, leaner resources than Python paths Four Field Shapes: Realtime watch, scheduled snapshot, rotating patrol, and raw-only forwarding—pick by business need so “just want video” does not pay full AI cost Raw + Judgment Dual Views: Realtime tasks default-output boxed detection streams, presented separately from VIDEO raw preview—paths do not steal from each other Resource-Efficient Multi-Channel Raw Wall: Stream forward defaults to the high-performance path so “many channels watch raw, few channels run AI” can coexist on NVR sites Alerts & Status Back to Center: Alerts and run status aggregate to VIDEO for persistence and notification; nodes do not stack business data locally Keep Realtime Under Load: When compute is tight, prioritize current picture and alert freshness—avoid “busier means more lag, more lag means more misses” Prefer Acceleration, Keep Running on Fallback: Use accelerators when available; automatically continue when not—tasks do not stop One-Click Distribute: WEB “workload distribute” or install scripts batch-deploy; center VIDEO install auto-mounts the local executor Event plane MQTT: Alerts/snapshots/post-process via EMQX algo bus; iot-sink persists, archives, and enriches notifications Management plane HTTP heartbeat: Task liveness reports to VIDEO; start/stop and task table managed by VIDEO NFS media root: Alert images and SRS DVR unified to NFS shared media root (`EASYAIOT_MEDIA_ROOT`, default `/mnt/easyaiot-media`; falls back to `$HOME/easyaiot/media` without sudo); MQTT carries paths only; iot-sink reads disk and archives to MinIO
POST Module	Custom judgment: Independent business judgment on top of object detection—turn “boxed targets” into “whether to alert and under which standard” Rules per task: Region filtering, pass-through, business scripts, and industry plugins compose into rule chains for sites, campuses, traffic, and more Fewer false alarms, ready to accept: Outside regions do not flood screens; trial-run rules before go-live to see what is blocked and whether alerts fire Change standards without stopping analysis: Saving rules on a running task takes effect immediately—no need to stop tasks to adjust forbidden zones or add a judgment step Perception and judgment decoupled: Video analysis keeps running while business logic scales on demand; industry capabilities are pluggable so one detection stack serves many projects Built-in plugins: `line_cross` line crossing, `region_enter_exit` zone enter/exit, `dwell_timer` dwell timeout, `headcount_gate` headcount threshold—select in algorithm task post-processing rules without plugin registration; line crossing, enter/exit, and dwell require target tracking (`track_id`)
VISUALIZE Module	Drag-and-Drop Dashboard Editor: A high-performance low-code visualization editor focused on canvas editing and preview Integrated with WEB: Project creation, templates, assets, data sources, publishing, and deployment are done in the admin console "Visualization" menu; click "Open Editor" to enter the canvas Dashboard Delivery: Drag-and-drop charts, metrics, and layouts; components can connect to platform data sources and IoT metrics, supporting rapid command dashboards for campus situational awareness, production-line KPIs, equipment ops, energy consumption, and more Clear Division with SCADA: Dashboards use this module; process SCADA uses Web SCADA capability; project metadata is unified under the DEVICE visualization backend Deployment Profile: Same as APP as a full-edition capability; mini / standard can skip per field hardware, reducing edge lite deployment size
TRANSFORM Module	Multidirectional Business Flow: Delivers platform-side alerts, device events, and business results to external systems such as MES / ERP / CRM / WMS by contract, closing the last mile from “the platform has data” to “business systems can use it” Configurable Integration: Configure destinations, forwarding rules, and field mappings once and reuse them—cutting the cost of “custom APIs for every customer system” Delivery You Can Accept: Runtime clusters and delivery trails are monitorable and reviewable, so integration and acceptance can answer “did it arrive, and where did it stall”—less verbal reconciliation Horizontal Scale-Out: As traffic grows, expand consume and delivery capacity by business contract—supporting parallel integration across lines, plants, and systems
PANEL Module	Delivery & Watch Entry: Independent of the business console: install, accept, and watch on arrival—shorten acceptance cycles and cut on-site / remote support cost Same-Day Closed Loop: UI-driven install by tier with progress and results on the spot; bring up and hand over the appliance even before the business console is ready Self-Serve Troubleshooting: Container health, resource levels, task logs, and image readiness at a glance—common start/stop, pull, and cache cleanup without waiting for developer commands Reuse Across Sites: One entry across appliances and machine rooms—PoC and production delivery share the same playbook
IDEA Module	Community cloud IDE: Open a VS Code–style workspace in the browser, clones the full repo by default; one Docker workspace per person, with local publish and idle reclaim—turning open-source contribution from “set up an environment first” into “open and edit” Split-pane AI Assistant: Toolbar opens HARNESS on the right; drag files to auto `@`; deep-link with `?file=&harness=1`
HARNESS Module	Conversational assistant: Ask about health, architecture, and issues—shorter troubleshooting and PoC, less vendor dependency In-page floating drawer: Chat without leaving business pages; included by default in `mini / standard / full` IDEA split-pane link: Assistant beside the editor; drag-to-`@`, deep links, and two-way jump MCP / Skill: Console and IDE share platform semantics; Skills reusable across projects
COMPILE Packaging	Multi-Platform Artifacts: Package PANEL and related capabilities into installers or binaries for Ubuntu / Debian, CentOS / RHEL 7–9 (x86 + CentOS ARM, packages per el7/el8/el9), Windows, macOS, and ARM / Kylin (麒麟) / openEuler (欧拉) targets—so customers can install without compiling from source on site Shorter Delivery Chain: Integrators pick the matching package for the target environment to deploy and upgrade—unified install, start/stop, and uninstall paths reduce cross-OS delivery variance Paired with PANEL: Build outputs land the on-site ops entry directly, connecting “package it out” with “install and watch on arrival” on one delivery chain

## 🖥️ Cross-Platform Deployment Advantages

EasyAIoT supports deployment on Linux, Mac, and Windows, providing flexible and convenient deployment solutions for users in different environments; with COMPILE producing installers and binaries per target OS, and PANEL completing on-site install and day-to-day watch:

🐧 Linux Deployment Advantages

Ideal for production environments, stable and reliable with low resource consumption
Supports Docker containerized deployment with one-click service startup
Perfect compatibility with servers and edge computing devices (such as RK3588 and other ARM architecture devices)
Provides complete automated installation scripts to simplify deployment
Covers mainstream server distros including Ubuntu, CentOS/RHEL 7–9 (incl. CentOS ARM), Kylin (麒麟) / openEuler (欧拉)

🍎 Mac Deployment Advantages

Suitable for development and testing environments with deep macOS integration
Supports local development and debugging for rapid feature validation
Provides convenient installation scripts compatible with package managers like Homebrew

🪟 Windows Deployment Advantages

Suitable for Windows server environments, reducing learning curve
Supports PowerShell automation scripts to simplify deployment operations
Compatible with both Windows Server and desktop Windows systems
Provides graphical installation wizards for user-friendly experience

Unified Experience: Regardless of the operating system chosen, EasyAIoT provides consistent installation scripts and deployment documentation, ensuring a uniform cross-platform deployment experience.

## ☁️ EasyAIoT = AI + IoT = Cloud-Edge-Device Integrated Solution

Supports thousands of vertical scenarios, with customizable AI models and algorithm development, deeply integrated.

Empowering Intelligent Vision for Everything: EasyAIoT

EasyAIoT constructs an efficient access and management network for IoT devices (especially massive cameras). We deeply integrate real-time streaming technology with cutting-edge AI to create a unified service core. This solution not only enables interoperability across heterogeneous devices but also deeply integrates HD video streams with powerful AI analytics engines, giving surveillance systems "intelligent eyes" – accurately enabling facial recognition, abnormal behavior analysis, risk personnel monitoring, and perimeter intrusion detection.

The platform supports real-time, snapshot, and patrol algorithm tasks: all three can default to the RUNTIME high-speed execution layer (executor=cpp)—a native binary for long-lived pull, decode, YOLO inference, and result callbacks; realtime default-pushes boxed AI detection streams; snap uses Cron capture; patrol rotates multi-channel coverage; stream forward can use the same high-performance path for resource-efficient raw walls. Versus the Python compatibility backend, RUNTIME holds up better under high channel counts and low latency. Alerts and heartbeats return to VIDEO. Algorithm task management keeps frame extraction and sorting flexible; model-service cluster inference ensures millisecond response and high availability. Full and half defense modes support precise time-based monitoring and alerting.

In terms of IoT device management, EasyAIoT provides comprehensive device lifecycle management capabilities, supporting multiple IoT and industrial protocols (MQTT, TCP, HTTP, Modbus-TCP, Modbus-RTU, OPC UA). Gateways in device management are cloud-side GATEWAY / sub-device topology; the EDGE C# edge collection runtime acts as that gateway on site, handling industrial protocol acquisition and MQTT cloud-edge integration, with data flowing back into the same device management UI—achieving rapid device access, secure authentication, real-time monitoring, and intelligent control. Through the rule engine, intelligent data flow and processing of device data are realized, combined with AI capabilities for in-depth analysis of device data, achieving full-process automation from device access, data collection, intelligent analysis to decision execution, truly realizing interconnected everything and intelligent control of everything.

## ⚠️ Disclaimer EasyAIoT is an open-source learning project unrelated to commercial activities. Users must comply with laws and regulations and refrain from illegal activities. If EasyAIoT discovers user violations, it will cooperate with authorities and report to government agencies. Users bear full legal responsibility for illegal actions and shall compensate third parties for damages caused by usage. All EasyAIoT-related resources are used at the user's own risk. ## 📚 Deployment Documentation - [Platform Deployment Documentation](.doc/部署文档/平台部署文档.md) — Step-by-step guide for Linux (Ubuntu / CentOS·RHEL **7–9** / **CentOS ARM** / ARM / **Kylin (麒麟) / openEuler (欧拉)**) / Mac / Windows - [macOS Image Deploy](.doc/部署文档/平台macOS部署文档.md) — One-click pull of pre-built images with Docker Desktop - [Windows Image Deploy](.doc/部署文档/平台Windows部署文档.md) — `install_windows.ps1` recommended entry - [Deployment Best Practices](.doc/部署文档/部署最佳实践_en.md) — Profiles, environment requirements, one-click deploy (incl. CentOS **7–9** / **CentOS ARM** / **Kylin (麒麟) / openEuler (欧拉)**), troubleshooting, and production recommendations ## 📘 Operations Manual For delivery, watchkeeping, and business operations: organized by **operation chains** (goal → prerequisites → steps → acceptance). Assumes the platform is already deployed and available. (Content is currently in Simplified Chinese.) - [Platform Operations Manual (Index)](.doc/操作手册/README.md) — How to read, shortest closed loop, and doc index - [Operation Chain Overview](.doc/操作手册/00-操作链总览.md) — Global map, menu quick reference, same-day PoC checklist - [Login & Basic Setup](.doc/操作手册/01-登录与基础准备.md) — Accounts, org, permissions, notification channels - [Video Device Onboarding](.doc/操作手册/02-视频设备接入.md) — ONVIF / NVR / GB28181 / RTC / DJI → preview & stream forward - [AI Algorithm Task Loop](.doc/操作手册/03-AI算法任务闭环.md) — Labeling/models → tasks → alerts - [IoT Device Onboarding](.doc/操作手册/04-物联网设备接入.md) — Product thing model → devices → EDGE / industrial acquisition - [Alerts, Notifications & External Integration](.doc/操作手册/05-告警通知与对外联动.md) — Alert handling, notifications, TRANSFORM - [Visualization Dashboards](.doc/操作手册/06-可视化大屏.md) — Dashboard/SCADA edit, publish, and display - [APP Mobile Watchkeeping](.doc/操作手册/07-APP移动值守.md) — Mobile vs WEB capability map ## 🎮 Demo Environment - Demo URL: http://36.111.47.113:8888/ - Username: admin - Password: admin123 ## 🎬 Demo Video - Bilibili: https://www.bilibili.com/video/BV1d3846yEQz/?vd_source=5d3350c0182a2cf35c2739f3d16c1161 ## ⚙️ Project Repositories - Gitee: https://gitee.com/soaring-xiongkulu/easyaiot - Github: https://github.com/soaring-xiongkulu/easyaiot ## 📸 Screenshots

Please follow our official account below first, then reach us via the technical exchange group or WeChat.

## 👥 Official Account

## 💬 Technical Exchange Group

After following the official account, scan the QR code below with WeChat to join the EasyAIoT technical exchange group.

## 💬 WeChat Contact

After following the official account, scan the QR code below to add us as a WeChat friend for one-on-one communication.

## 🪐 Knowledge Planet:

Knowledge Planet

## 💰 Sponsorship

## 🤝 Contributing Guide

We welcome all forms of contributions! Whether you are a code developer, documentation writer, or issue reporter, your contribution will help make EasyAIoT better. Here are the main ways to contribute:

💻 Code Contribution

Fork the project to your GitHub/Gitee account
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

📚 Documentation Contribution

Improve existing documentation content
Add usage examples and best practices
Provide multilingual translations
Fix documentation errors

🌟 Other Contribution Methods

Report and fix bugs
Suggest feature improvements
Participate in community discussions and help other developers
Share usage experiences and case studies

## 🌟 Major Contributors

The following are outstanding contributors who have made major contributions to the EasyAIoT project. Their contributions have played a key role in promoting the project's development. We express our most sincere gratitude!

Contributor	Contribution
℡夏别	Contributed Windows deployment documentation for the EasyAIoT project, providing a complete deployment guide for Windows platform users, greatly reducing the deployment difficulty in Windows environments, and enabling more users to easily use the EasyAIoT platform.
YiYaYiYaho	Contributed Mac container one-click deployment script for the EasyAIoT project, providing an automated deployment solution for Mac platform users, significantly simplifying the deployment process in Mac environments, and improving the deployment experience for developers and users.
山寒	Contributed Linux container deployment script for the EasyAIoT project, providing a containerized deployment solution for Linux platform users, achieving fast and reliable container deployment, and providing important guarantees for stable operation in production environments.
玖零。	Contributed Linux container deployment script for the EasyAIoT project, further improving the containerized deployment solution for Linux platforms, providing more options for users of different Linux distributions, and promoting the project's cross-platform deployment capabilities.
爱吃小柚子	To advance EasyAIoT toward training that actually runs, stays stable, and stays easy to operate, systematically delivered multi-GPU training, checkpoint resume, and node-side deployment so on-site compute can be fully used and training jobs stay under control: servers can auto-detect and use all GPUs, and users can pick one or more cards on the training page instead of being stuck with a single visible GPU; common dataset formats and directory layouts are supported, large local datasets can be uploaded, and original data is kept after failed runs for quick retries—greatly cutting the cost of data prep and rework; training progress is visible, jobs can be stopped and resumed, avoiding lost results after interruptions or “stop” clicks that leave processes spinning in the background, with clear fallback and feedback when local or remote scheduling fails; also improved frontend GPU selection, resume, and stop-state display, and fixed false “publish failed” results, custom preview images being overwritten, model lookup by name/version not working, and dataset sync timeouts or conflicts—making the train–publish–use loop smoother and more reliable. Previously also led end-to-end GB28181 and AI workflow integration testing and dedicated image-clarity evaluation, providing a strong basis for reliable national-standard access and better viewing experience.
Dark	Contributed end-to-end integration of GB28181 for EasyAIoT in national-standard video surveillance, delivering video playback and PTZ (pan-tilt) control so that device access supports practical live preview and remote camera steering.
machh	Contributed to the EasyAIoT-Edge project by validating camera onboarding and AI capabilities end to end, and wiring these features into a coherent edge-side workflow.
遗忘的星空	Contributed to EasyAIoT's direct device onboarding by delivering a multi-vendor IP camera asset inventory and subnet scanner, supporting batch discovery and identification of Hikvision IPCs, NVRs, and related devices; improved batch search and one-click registration for directly connected devices across same-subnet and cross-subnet scenarios. Device access is implemented via native protocols, bypassing the Hikvision SDK and reducing reliance on the Hikvision platform—laying the groundwork for open, controllable large-scale camera onboarding.
阿龙	To advance EasyAIoT in map visualization and spatial intelligence, independently contributed the complete implementation of Tianditu spatial visualization capabilities, covering national Tianditu basemap integration, camera and alarm device placement, map distribution views, location search and batch coordinate import, automatic alarm event mapping, person/vehicle trajectory tracking, and mobile device track playback—bringing the platform's "Tianditu spatial visualization and map-based analysis" capability from design to production-ready, usable form. Building on that, he further contributed forward-looking reference code for "drawing tracking trajectories along actual roads"—addressing the common pain point that raw capture-point connections cut straight across buildings and water and deviate from real movement paths. He proposed a technical approach that treats consecutive capture points as origin–destination pairs, queries the map route-planning service segment by segment to match passable roads (driving strategy for vehicles, walking strategy for persons) and overlays the road-snapped paths, together with key implementation references for parsing route-planning results and gracefully degrading unmatched segments. This upgrades person/vehicle trajectories from "two-point straight lines" to "street-level reconstruction," making spatial-temporal analysis conclusions far closer to real movement routes and markedly improving their readability, credibility, and practical value. His selfless sharing of a reusable reference implementation also cleared technical barriers for the community and greatly lowered the reproduction threshold for similar capabilities.
雨落流殇	To advance EasyAIoT in ultra-large-scale streaming media delivery, contributed deployment and scheduling approaches for heterogeneous streaming media server clusters, proposing scalable solutions including multi-node pool coordination, decoupling of streaming from the business layer, and node registration scheduling—laying an important architectural foundation for the platform to support concurrent access of tens of thousands of camera streams with stable distribution and elastic scaling.
常康	To advance EasyAIoT in intelligent transportation and vehicle management, independently contributed the license plate recognition algorithm and complete code implementation, covering plate detection, plate number and color recognition, double-layer plate merging and tilt/perspective correction, plate library management and multi-library sequential matching, one-click integration with algorithm tasks, and asynchronous matching—supporting mainstream plate types including blue, yellow, green, white, and new energy vehicle plates—bringing the platform's "license plate recognition and plate library management" capability from planning to production-ready, closed-loop application.
Li	To advance EasyAIoT in youth developer community building and collaborative ecosystem development, demonstrated outstanding organizational leadership and rallying power by leading fellow students across campus to actively co-build the project, bringing together young talent and collective momentum to inject a continuous, enduring stream of growth energy into EasyAIoT; also made pivotal, irreplaceable contributions in project outreach, hands-on implementation, and cultivating the next generation of contributors.
陈家林	To advance EasyAIoT in IoT device interoperability, industrial protocol access, and air–ground video fusion, delivered a closed loop for device commands and status so the platform can truly “send commands down, see status, and stay in control”; systematically contributed Modbus-TCP, Modbus-RTU, and OPC UA industrial protocol access—unified acquisition of Ethernet- and serial-side industrial devices and OPC UA nodes, with measurement read/write and thing-model mapping—so meters, sensors, PLCs, controllers and other industrial equipment data can be aggregated, monitored and linked on the platform, completing the key puzzle of “seeing the scene and hearing the devices”; also contributed DJI FlightHub dock and drone video integration, bringing aerial inspection into the unified video and alarm system, significantly expanding value in industrial data acquisition, production-line intelligence, wide-area patrol, emergency survey, and sky–ground collaborative sensing.
空空	To advance EasyAIoT in camera direct-connect from “discoverable” to “production-ready,” closed critical gaps in authentication, channel sync, config changes, and multi-vendor stream URLs so the platform is deliverable on real NVR / multi-vendor sites: made device login work reliably so direct-connect devices can truly “log in and stay managed”; improved the post-NVR-sync streaming model so batch-synced channels play and scale; ensured access parameters remain maintainable; built stream URL rule libraries for common domestic camera brands and opened custom brand rules so heterogeneous devices can go live in one click without manual address trials—moving direct-connect from “devices can be scanned” to “login works, sync is accurate, configs can be changed, and multi-brand streams play,” laying a solid foundation for later PTZ and zoom controls.
狗娃	To advance EasyAIoT toward "IoT data displayed on screen," proactively proposed the product vision of a visualization Board (drag-and-drop dashboard) module: traditional dashboards often require hand-written SQL for every screen and component, slowing delivery, making every change ripple across the stack, and leaving business users unable to self-serve. The Board approach puts charts, metrics, and layout on a drag-and-drop canvas and binds component variables directly to platform IoT thing-model metrics—real-time and historical values pulled from devices in one step, without bespoke queries per dashboard; campus situational awareness, production-line KPIs, equipment operations, and similar screens upgrade from "developers write SQL to get a screen" to "pick metrics, drag components, screen done," significantly shortening visualization delivery and turning IoT "data in the back office" into an operational "screens in the front office" capability. Previously also contributed sensor float data prediction, running-status property threshold configuration, threshold alarms with rule linkage, and one-screen running-status views for central-device associated sub-devices—closing the device operations loop of "predict—bound—alert—rule—one-screen control" so the device side can "see the numbers, govern the bounds, raise the alerts, and grasp the whole picture."
大老刘	To advance EasyAIoT in external communication and solution storytelling, contributed the illustrated introduction material AI Video Surveillance Analytics Platform, systematically presenting the platform's capability landscape and deployment value in AI video surveillance scenarios so that users, integrators, and partners can quickly grasp the positioning and key highlights—significantly improving outreach and business communication efficiency.
刘兆中ᯤ⁵ᴳ	To advance EasyAIoT toward one-click macOS deployment, pioneered part of the Mac one-click deployment scripts—largely opening the main path of image pull, container orchestration, and environment precondition checks so that follow-on work only needed to close the “last mile.” His exploration clarified key nodes and risk points on the Mac deployment chain, substantially shortening the path to engineering completion, and remains an indispensable foundational contribution in taking macOS deployment from zero to usable.
添旺	To advance EasyAIoT in cloud-edge collaborative video ingestion and AI analytics, independently delivered several pivotal capabilities that confront the core pain points of real-world edge delivery—“can't get cameras in, can't schedule right, doesn't truly run, can't look back”: pioneered edge camera ingress with algorithm-node affinity—IPC/NVR devices can designate an online edge node as their “ingress node,” so discovery, subnet scanning, ONVIF probing, and NVR channel enumeration all run locally on that node while source streams are pushed back to the control-plane media service for unified distribution and playback; cameras in branch sites or cross-segment/private networks no longer need direct reachability to the central platform to be onboarded and streamed, and algorithm tasks are automatically pinned to their cameras' ingress node so workloads never land on nodes that cannot reach the source stream. Diagnosed and fixed the critical defect where multiple algorithm tasks or multi-model pipelines on one camera left only a single channel effective—isolating inference chains with task-scoped stream identities, reusing one shared decode across concurrent tasks via a dedicated camera-source service, and propagating task identity through alerts and runtime status end to end—one camera can now stably run multiple algorithm tasks and multi-model detection (face + vehicle in the same frame) in parallel, guarded by regression tests over the long term. Also contributed tiered storage for edge recordings with unified event replay—recordings retained in tiers at the edge while alert events and video evidence stay searchable and replayable through one cloud-edge unified entry, closing the evidence loop from “event happened” to “proof in hand.” Together these markedly strengthen the platform's delivery certainty in complex real-world network environments and the trustworthiness of its AI analytics results.

Special Thanks: The above contributors have advanced EasyAIoT in cross-platform deployment documentation and scripts, foundational macOS one-click deployment scripting and path exploration, national-standard video capability delivery and AI integration verification, multi-GPU training and checkpoint resume, multi-vendor camera direct discovery and batch onboarding, Tianditu spatial visualization, road-snapped trajectory reconstruction reference implementation, heterogeneous streaming media cluster deployment and scheduling, license plate recognition algorithm and complete implementation, EasyAIoT-Edge end-to-end edge-side integration, campus developer community organization and youth collaborative ecosystem building, IoT device uplink/downlink closed loop and DJI FlightHub aerial view integration, Modbus-TCP / Modbus-RTU / OPC UA industrial protocol access, the production-ready closed loop of camera direct-connect from discovery through login/sync/config/multi-brand streaming, the drag-and-drop Board vision with IoT metric real-time/historical value integration, sensor float data prediction with threshold alarm rules plus one-screen running-status views for central-device associated sub-devices, and illustrated introduction materials for the AI video surveillance analytics platform, edge camera ingress with algorithm-node affinity, isolation of multi-task/multi-model inference on the same camera, and tiered edge recording storage with unified event replay. Their professionalism and selfless dedication are worthy of our learning and respect. Once again, we express our most sincere gratitude to these outstanding contributors! 🙏

## 💝 Open Source Guardians Sustaining an open-source project takes more than code and documentation. During the days when EasyAIoT's compute resources were most strained and the project was on the brink of stalling, the following individuals stepped forward with tangible financial support that gave the project the momentum it needed to keep going. You may never have submitted a single line of code, yet every act of trust and support helped EasyAIoT cross its hardest hurdles and continue to evolve. As long as people use it and stand behind it, the open-source ecosystem deserves to go further; what EasyAIoT has achieved today would not have been possible without these companions who reached out at critical moments. We extend our deepest respect and gratitude to every friend who lent a hand. The following rankings are in no particular order:

_lysss	_Sean-宋阳	_XYZ	_{大虚子民🎼}	_哈兰葱	_曲超	_李雪汉	_{梦影·清之韵}	_dasic
_战刀	_禾一虫	_{钟意月月🍹}	_山人	_林大侠	_core	_王亚鹏	_{今早好大雾}	_头像飞鱼
_simon	_万博览	_董永乐	_℡夏别	_周金旺	_无忧	_许多	_王军	_子非鱼
_苏州小朱		_HuaZy	_{越南打印机网络监控电脑门禁何工}	_熊勇辉	_旭	_心远	_Mr.Peng	_{舒韩春💭成都云速广告💭}
_前进!	_永恒	_Catwings	_刘振达	_雷沛奇	_CSL	_自胜	_朱江山	_安
_简单	_郝艳军	_Star&Li	_工体东路	_Sunder.	_程亮🌟	_should	_黄国洪	_Holmesian
_Issac	_习惯	_黄杰	_唐智灵	_{巴波儿奔🇨🇳}	_冯振华	_风清扬	_{take your time or}	_Rising徐
_Mr.G	_吴翕然	_蓝天白云	_Charlie	_胖哥	_王宪芳	_lk	_阿旺*	_{🍃一笑奈何🍃}
_刘召	_🍻Jamie	_薛磊	_Jack	_啊这	_{在希望德田野上}	_莫建民	_马景祥	_谭远彪
_{一杯陈豆浆🥲🥲}	_chen	_{xingzhedu2030}	_machh	_{开炫🍊🍊🍊}	_Dark	_A-Tree	_陈	_月半
_吴军	_青衫	_梓淇東來	_潇潇	_依依	_{金·郁金香}	_David	_{榕德天锐-邱国城}	_Wzs
_张军伟	_{菜rainbow狗}	_闻达	_银之匙	_命中注定	_...	_{爱吃小柚子}	_草原雄鹰	_顺流致远
_香草口味	_雨落流殇	_弱电安防	_山里人	_诗如画	_星空🌃	_楠哥	_蜗牛	_大周
_{歌德de花烛}	_noname	_兔子	_ThinkInStack	_Louis	_{胡首凡梯控门禁五方对讲}	_袁建华	_空空	_阿涛
_NULL	_一片天	_小满藏舟	_M	_舍得	_默者	_{火车叨位去、}	_payne	_滕虎
_天天	_王超	_南北	_{最后的轻语}	_{西乡一粒沙}	_yang	_何行者	_在路上	_ANDY
_冯	_忘记时间	_A许庆	_{刘兆中📶⁵ᴳ}	_莫斯克	_赵欢

## 🏆 Best Practitioners They are the pioneers who push EasyAIoT from "usable" to "easy to use and use well" — the following individuals have completed EasyAIoT project deployment or business scenario implementation. Their exploration and achievements set replicable and referable benchmarks for the community. We extend our highest respect and heartfelt congratulations to these outstanding practitioners! The following rankings are in no particular order:

_℡夏别

_YiYaYiYaho

_冯

_{在希望德田野上}

_漠然

_{爱吃小柚子}

_Wzs

_Dark

_刘延波

## 🙏 Acknowledgements Thanks to the following contributors for code, feedback, donations, and support (in no particular order):

_默者	_小满藏舟	_空空	_陈家林	_NULL	_陈勇至	_Dark	_machh	_{三块两毛四}
_{物语晨水²⁰²⁶}	_玖零。	_金鸿伟	_李江峰	_{Best Yao}	_无为而治	_shup	_也许	_{⁰ʚᦔrꫀꪖꪑ⁰ɞ .}
_逆	_廖东旺	_黄振	_春生	_{贵阳王老板}	_{hao_chen}	_尽千	_yuer629	_kong
_岁月静好	_Kunkka	_灬	_Mr.LuCkY	_泓	_i	_依依	_{小菜鸟先飞}	_追溯未来	_青衫	_Fae
_憨憨	_{文艺小青年}	_lion	_{汪汪队立大功}	_wcj	_{怒放de生命}	_蓝速传媒	_{Achieve_Xu}	_NicholasLD
_ADVISORYZ	_{take your time or}	_碎碎念.	_北街	_{Dorky TAT}	_右耳向西	_派大星	_棒槌	_{信微输传助手}
_一往无前	_Charon	_赵WIFI.	_Chao.	_{城市稻草人}	_{Bug写手墨白}	_kevin	_童年	_sherry金
_℡夏别	_翠翠草原	_慕容曦	_Tyrion	_大漠孤烟	_Return	_一杯拿铁	_Thuri	_Liu
_三金	_ZPort	_Li	_嘉树	_俊采星驰	_oi	_{ZhangY_000}	_℡夏别	_张瑞麟
_{Lion King}	_Frank	_徐梦阳	_九月	_tangl伟	_冯瑞伦	_杨林	_{梧桐有语。}	_{歌德de花烛}
_泥嚎	_翠翠草原	_胡泽龙	_苏叶	_裴先生	_谭远彪	_陈祺	_零点就睡	_风之羽
_王守仁	_狼图腾	_马到成功	_{做生活的高手}	_清欢之恋	_绝域时空	_风雨	_Nicola	_云住
_Mr.Zhang	_剑	_shen	_嗯	_周华	_太阳鸟	_了了	_{第七次日落}	_npc
_{承担不一样的天空}	_铁木	_Orion	_{森源-金福洪}	_薛继超	_虎虎虎	_Everyman	_NXL	_孙涛
_大饼	_hrsjw1	_linguanghuan	_YiYaYiYaho	_慢慢慢	_lilOne	_icon	_山寒	_{放学丶别走}
_春和	_{章鱼小丸子}	_Catwings	_小工头	_{西乡一粒沙}	_{爱吃小柚子}	_阿龙	_雨落流殇	_{遗忘的星空}
_常康	_嘎嗝	_曹	_滔滔	_狗娃

## 💡 Expectations

We welcome suggestions for improvement to help refine EasyAIoT.

## 📄 Copyright

Soaring Xiongkulu / easyaiot is licensed under the MIT LICENSE. We are committed to promoting the popularization and development of AI technology, enabling more people to freely use and benefit from this technology.

Usage License: Individuals and enterprises can use it 100% free of charge, without the need to retain author or Copyright information. We believe the value of technology lies in its widespread use and continuous innovation, rather than being bound by copyright. We hope you can freely use, modify, and distribute this project, making AI technology truly benefit everyone.