Build a Retail Shelf Monitoring System with Edge AI

This tutorial walks through a working retail shelf monitoring prototype for out-of-stock detection. You will use an edge AI camera to capture shelf images, train a lightweight detection model, deploy it locally, and publish structured MQTT alerts when shelf gaps appear.

The goal is not to create a finished retail operations platform in one article. The goal is to build a reliable prototype-to-pilot workflow that system integrators, developers, and retail technology teams can validate on real shelf images before designing a larger deployment.

What You Will Build

The prototype detects visible shelf gaps and publishes a structured event when fill level falls below a configured threshold.

What You Need for the Prototype

Start with the minimum stack that lets you validate image quality, model performance, MQTT event delivery, and alert workflow. Add production hardware only after the pilot target is clear.

Step 1: Place the Camera for Consistent Shelf Images

Camera placement is the most important part of the build. Consistent images reduce false positives, improve model training, and make validation easier.

Choose the Right Lens

Use the lens that gives enough product detail for the task. Wider coverage is not always better because object detail decreases as coverage increases.

Mounting Guidelines

• Height: start near the middle shelf rail or the area that gives a stable front-facing view of the target products.
• Distance: choose a distance that keeps the target products large enough for detection while covering the shelf section you care about.
• Angle: keep the camera as straight-on as practical. Severe angles can distort product geometry and reduce detection reliability.
• Lighting: avoid glare, hard shadows, reflective packaging, and changing light patterns across the shelf face.

Step 2: Boot NE301 and Connect It to the Network

Use USB-C power for fast prototyping or NE301 PoE when you want stable wired power and network in a fixed setup.

# 1. Power up the NE301 with USB-C or PoE
  # 2. Hold the button for 2–3 seconds until the device AP appears
  # 3. Connect to the AP and open the default Web UI
  
  $ open http://192.168.10.10
  
  # 4. In Web UI → Settings → Network, add the store Wi-Fi SSID
  # 5. Reboot the device and find the assigned LAN IP
  # 6. Reopen Web UI at the assigned IP address

Step 3: Collect Shelf Images with AI Tool Stack

CamThink AI Tool Stack supports the prototype workflow from data collection to model deployment. For a shelf monitoring build, your dataset should capture real product appearance, lighting variation, partial stock, empty gaps, and common edge cases.

Install AI Tool Stack

# Prerequisites: Docker + Docker Compose v2.0+
  
  $ git clone https://github.com/camthink-ai/AIToolStack.git
  $ cd AIToolStack
  
  # Pull the NE301 model export environment
  $ docker pull camthink/ne301-dev:latest
  
  # Start local services
  $ docker compose up -d
  
  # Open the AI Tool Stack Web UI
  $ open http://localhost:8000

Capture a Useful Prototype Dataset

For a prototype, start with enough images to test feasibility. Before evaluating a pilot model, collect more images from the real deployment environment.

• Fully stocked shelf images for the baseline state
• Partial fill levels such as 75%, 50%, and 25%
• Empty shelf gaps and near-empty states
• Morning, midday, evening, and shadow conditions
• Common occlusions, rotated labels, misplaced items, and reflective packaging

Step 4: Train and Export a Shelf Gap Model

The simplest OOS prototype uses two classes: product_present and shelf_gap. The model detects visible product facings and empty areas, then threshold logic decides whether to publish an alert.

# Example training command. Adjust epochs and dataset paths for your project.
  $ yolo detect train \
      data=shelf_gap.yaml \
      model=yolov8n.pt \
      epochs=100 \
      imgsz=256 \
      device=0          # use device=cpu if no GPU is available

$ docker run --rm \
      -v "$(pwd)/runs/detect/train/weights:/workspace/weights" \
      -v "$(pwd)/export:/workspace/export" \
      camthink/ne301-dev:latest \
      yolo export \
          model=/workspace/weights/best.pt \
          format=tflite \
          imgsz=256 \
          int8=True \
          data=shelf_gap.yaml
  
  # AI Tool Stack wraps the model and configuration into a deployable package.

Step 5: Deploy the Model to NE301

Model deployment is handled through the NE301 Web UI. This makes it possible to update the detection model without reflashing firmware.

{
    "model": "shelf_gap_v1_ne301",
    "confidence_min": 0.55,
    "nms_iou": 0.45,
    "alert_classes": ["shelf_gap"],
    "alert_threshold": {
      "shelf_gap": {
        "min_area_pct": 5,
        "fill_pct_alert": 30
      }
    },
    "inference_fps": 5
  }

Step 6: Publish MQTT Alerts

MQTT turns detection output into a usable system event. The camera publishes a structured payload when a shelf gap crosses the configured threshold.

Start a Local MQTT Broker

$ docker run -d \
      --name mosquitto \
      -p 1883:1883 \
      -p 9001:9001 \
      eclipse-mosquitto:latest
  
  # Subscribe to all topics to verify messages
  $ mosquitto_sub -h localhost -t "#" -v

Configure NE301 MQTT Output

• Broker: local broker IP address on the same LAN
• Port: 1883
• Topic: shelf/aisle3-bay2/events
• Publish mode: detection event, not continuous video

{
    "device_id": "NE301_A3F2C1",
    "shelf_id": "aisle3-bay2-left",
    "timestamp": "2026-05-12T09:47:12Z",
    "event": "shelf_gap_detected",
    "detections": [
      {
        "class": "shelf_gap",
        "confidence": 0.91,
        "bbox": [320, 140, 580, 390],
        "fill_pct": 14
      }
    ],
    "image_url": "http://192.168.1.45/snap/20260512_094712.jpg"
  }

Step 7: Route Alerts with Home Assistant

Home Assistant is useful for a prototype because it can subscribe to MQTT topics and create mobile notifications without building a custom application. For enterprise integration, the same MQTT event can later be routed through Node-RED or middleware to ERP, WMS, or task systems.

alias: "Shelf OOS Alert — Aisle 3"
  trigger:
    - platform: mqtt
      topic: "shelf/aisle3-bay2-left/events"
  condition:
    - condition: template
      value_template: "{{ trigger.payload_json.detections[0].fill_pct | int < 30 }}"
  action:
    - service: notify.mobile_app_store_phone
      data:
        title: "Low Stock Alert"
        message: >
          Aisle 3, Bay 2 Left is at
          {{ trigger.payload_json.detections[0].fill_pct }}% fill.
          Please check the shelf.
        data:
          image: "{{ trigger.payload_json.image_url }}"

Step 8: Validate Before You Scale

The first model is a baseline, not the final production model. Live shelf conditions expose edge cases that a training dataset may miss.

Going Further: From Prototype to Pilot Architecture

Once the single-shelf prototype is validated, you can expand the same workflow into a larger pilot. Scaling is mainly an architecture question: how many cameras, where inference runs, how events are routed, and who owns the downstream workflow.

What CamThink Provides — and What You Still Need to Build

CamThink provides the edge AI hardware and development building blocks. A complete retail deployment also needs application logic, integration design, and operational workflow.

FAQ

Conclusion

A retail shelf monitoring prototype should prove three things: the camera can capture consistent shelf images, the model can detect meaningful shelf gaps, and the alert event can reach the right downstream workflow.

NE301, AI Tool Stack, MQTT, and Home Assistant provide a practical starting point for that validation. Once the single-shelf build works, system integrators and developers can extend the same foundation into multi-camera pilots with NG4500, NeoMind, and ERP/WMS integration.