;toc

Most modern cameras can already tell you something happened—motion, a person, a car, maybe even an animal.

Frigate is different because it adds context and flexibility while keeping everything local. You can detect more specific objects (bicycle vs car, bus vs truck), optionally add things like facial recognition and package detection, and then use those events inside Home Assistant for smarter alerts.

This post is the companion guide to the video and includes example configs you can copy, plus notes on how the pieces fit together.

Table of Contents

What You’ll Build

By the end, you’ll have:

Frigate installed either as a Home Assistant Add-on or in Docker
One or more cameras added (Reolink + a generic RTSP camera like Aqara/TP-Link)
Home Assistant integrated with Frigate using the Frigate Integration
Smarter notifications using the Frigate Mobile App Notification Blueprint
A clear understanding of detections vs alerts so you don’t get spammed

My Real-World Setup (So You Can Map It to Yours)

Recording / long-term storage: Still handled by my Reolink NVR / Home Hub
Frigate’s job: Object detection + smart alerts
Clip retention in Frigate: ~1 day (just enough for notifications and quick review)

You can use Frigate as a full NVR. I’m using it as the “intelligence layer” on top of my existing system.

Prerequisites

Hardware (Flexible)

Frigate can run on:

A higher-spec Raspberry Pi (Pi 5+)
Your Home Assistant machine (mini PC, etc.)
A separate PC or NAS (Docker)

In my case, I started with a Coral TPU on Home Assistant for testing, but I moved Frigate to my NAS later for long-term stability and to use hardware video decoding.

I’m not covering TPU selection or installation here because recommendations change. Always check the Frigate docs for current guidance.

Cameras (RTSP Required)

Frigate works with basically any camera that can output an RTSP stream:

Reolink cameras (including via NVR/Home Hub streams)
Aqara G5 Pro (RTSP enabled via app)
TP-Link (model dependent, RTSP varies)

Installing Frigate

Installation Option 1: Home Assistant Add-on (Easiest)

If you run Home Assistant OS or Supervised, this is the simplest path.

Steps (High Level)

Add the Frigate add-on repository
Install the Frigate add-on
Configure hardware acceleration (optional)
Start the add-on
Open the Frigate Web UI from Home Assistant

Add-on Repository

https://github.com/blakeblackshear/frigate-hass-addons

Installation Option 2: Docker (Most Flexible)

If you want to keep Frigate off your Home Assistant box, Docker is the common route. This is what I use now on my NAS.

You can find all of the details of running Frigate on Docker in the official Frigate docs: https://docs.frigate.video/frigate/installation/

Installation Option 2b: Docker on UGREEN NAS (What I am using)

This is the exact path I used to install Frigate on my UGREEN DXP4800 using UGREEN’s built-in Docker interface. The UI may look slightly different depending on your UGREEN OS version, but the overall workflow is the same.

Why I Used the NAS

It already supports Docker
It has hardware video decoding available via the Intel iGPU
It keeps Frigate’s workload off my Home Assistant box

Step 1: Install / Open Docker on the UGREEN NAS

Log into your UGREEN NAS web interface.
Open the App Center (or equivalent).
Install Docker (if it isn’t installed already).
Open the Docker app.

Step 2: Create Storage Folders First

Before creating the container, I recommend creating two SHARED folders on your NAS so you can map them cleanly:

frigate/config
frigate/media (or frigate/storage)

Example paths (yours will vary):

/volume1/docker/frigate/config
/volume1/docker/frigate/media

Step 3: Download the Frigate Image

In the Docker UI:

Go to Images
Search for the Frigate image:
- cluangar/frigate:0.16.4-npu
Download / Pull the image.

Step 4: Create a “Project” (Docker Compose)

UGREEN’s Docker UI uses the term Project (which is basically Docker Compose).

Go to Projects (or Compose / Stacks)
Click Create Project
Give it a name (example: frigate)
Select a storage location (where the project data will live)
Paste in your compose config

In the video, I describe this as: create the project → set storage → paste compose → click start.

PLACEHOLDER: Screenshot: Create Project screen

Step 5: Paste the Docker Compose Configuration

Here’s a solid template that matches what you described. Adjust paths for your NAS.

version: "3.9"

services:
  frigate:
    container_name: frigate
    image: cluangar/frigate:0.16.4-npu
    restart: unless-stopped

    # Matches your UGREEN config (host mode)
    network_mode: host

    # You have this enabled in the UI
    privileged: true

    # ✅ SHM FIX (Adjust as your logging suggests)
    shm_size: "256mb"

    # Volumes (match your UI)
    volumes:
      - ./config:/config
      - ./media:/media/frigate
      # Good practice for correct time inside container
      - /etc/localtime:/etc/localtime:ro

    # Devices (helps VAAPI + OpenVINO GPU on Intel iGPU)
    devices:
      - /dev/dri:/dev/dri

    environment:
      TZ: America/Chicago

      # Keep if you're using Frigate+
      #PLUS_API_KEY: ""

      # These showed in your UI; harmless to keep if you actually have NVIDIA runtime
      NVIDIA_VISIBLE_DEVICES: "all"
      NVIDIA_DRIVER_CAPABILITIES: "compute,video,utility"

      TOKENIZERS_PARALLELISM: "true"
      TRANSFORMERS_NO_ADVISORY_WARNINGS: "1"
      OPENCV_FFMPEG_LOGLEVEL: "8"
      DEFAULT_FFMPEG_VERSION: "7.0"
      INCLUDED_FFMPEG_VERSIONS: "7.0:5.0"
      HAILORT_LOGGER_PATH: "NONE"

Notes:

privileged: true is commonly used for Frigate deployments to avoid permission issues.
/dev/dri is the typical device mapping needed for Intel iGPU video acceleration.
You can run without go2rtc at first, but it’s worth using once you scale up.

Step 6: Start the Project and Verify It’s Running

Click Start (or Deploy)
Watch the container status (it should show “running”)
Open logs and confirm Frigate starts without errors

What I look for in logs:

config loaded successfully
ffmpeg starts correctly
detector initializes (even if CPU at first)
no continuous restart loop

PLACEHOLDER: Screenshot: container running + logs view

Step 7: Open the Frigate UI

Once the container is running, open:

http://<UGREEN_NAS_IP>:5000

At this point the UI may be empty (no cameras yet), but the app should load.

Access the UI

Once running, open:

http://<FRIGATE_IP>:5000

Frigate Set-up

Step 1: Add Cameras (This Is Where Most People Get Stuck)

Once Frigate is installed, the first “real” step is adding cameras. You’ll do most of this in the Frigate config YAML.

In the Frigate UI:

Click the gear icon
Go to Configuration Editor

Key Config Sections (High-Level)

Most configs break down into:

MQTT (for Home Assistant integration)
Detectors (depends on your hardware)
ffmpeg (stream decoding)
go2rtc (optional but recommended for restreaming)
cameras (your actual camera definitions)
recording / snapshots (optional)

Step 2: MQTT (Required for Home Assistant Integration)

This is required if you want Home Assistant to receive events properly.

mqtt:
  host: <HOME_ASSISTANT_IP_OR_MQTT_BROKER_IP>  # PLACEHOLDER
  user: <MQTT_USERNAME>                        # PLACEHOLDER
  password: <MQTT_PASSWORD>                    # PLACEHOLDER

Tip: Use a dedicated RTSP user for cameras (read-only) when possible, so your admin creds aren’t sitting in config files.

Step 3: go2rtc Streams (Recommended)

go2rtc lets Frigate ingest a camera stream once and restream it locally in a clean way.

Reolink Example (Standalone Camera)

go2rtc:
  streams:
    reolink_driveway_main: rtsp://<USER>:<PASS>@<CAMERA_IP>:554/preview_01_main   # PLACEHOLDER
    reolink_driveway_sub:  rtsp://<USER>:<PASS>@<CAMERA_IP>:554/preview_01_sub    # PLACEHOLDER

Reolink NVR Example (Channels + Codec)

This is highly dependent on your NVR model and channel numbering.

go2rtc:
  streams:
    nvr_ch01_main: rtsp://<USER>:<PASS>@<NVR_IP>:554/h265Preview_01_main  # PLACEHOLDER
    nvr_ch01_sub:  rtsp://<USER>:<PASS>@<NVR_IP>:554/h264Preview_01_sub   # PLACEHOLDER

Aqara Example (Multiple Channels/Resolutions)

Aqara RTSP is usually shown in-app and may have multiple channels for resolution.

go2rtc:
  streams:
    aqara_deck_ch1: rtsp://<USER>:<PASS>@<AQARA_IP>:554/<AQARA_PATH_CH1>  # PLACEHOLDER

Step 4: Camera Definitions (The Part You Repeat)

Once streams are defined, you create camera blocks under cameras:.

Reolink Camera with Main (record) + Sub (detect)

cameras:
  driveway:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/reolink_driveway_main   # from go2rtc
          input_args: preset-rtsp-restream                    # PLACEHOLDER
          roles:
            - record
        - path: rtsp://127.0.0.1:8554/reolink_driveway_sub
          input_args: preset-rtsp-restream                    # PLACEHOLDER
          roles:
            - detect
    detect:
      enabled: true

Why two streams? Detection can run on the lower-res substream to reduce load, while recording uses the high-quality main stream.

Step 5: Detectors (Hardware Dependent)

This changes based on your setup (Coral, OpenVINO, etc.). Here’s a placeholder:

detectors:
  detector1:
    type: <openvino_or_edgetpu_or_cpu>    # PLACEHOLDER
    device: <DEVICE>                      # PLACEHOLDER

Step 6: Recording Retention (Optional)

In my setup, Frigate clip retention is short (about a day) because my NVR handles long-term.

record:
  enabled: true
  retain:
    days: 1
    mode: all   # PLACEHOLDER (all/motion/active_objects/etc)

Step 7: Choose What Objects You Want to Track

By default many people start with person, then add more.

objects:
  track:
    - person
    - car
    - bicycle
    - bus
    - package
    # PLACEHOLDER: add/remove based on your model support

If you’re using Frigate+, you may see additional object categories available.

Detections vs Alerts (Important)

This is one of the biggest “aha” moments.

Detections

Frigate’s understanding of what is in the scene:

person, car, bicycle, etc.

Alerts

What you actually want to notify on (less noise):

only alert when a person is in a specific zone
only alert when package OR person is detected
only alert when you’re away

Bottom line:
Frigate can detect a lot — Home Assistant decides what becomes a notification.

Integrating Frigate with Home Assistant

Install the Frigate Integration (HACS)

In your video, you install this via HACS.

Install via HACS
Reboot Home Assistant
Go to Settings → Devices & Services → Add Integration
Search Frigate
Enter Frigate host (if Frigate is not running as an add-on)

PLACEHOLDER:

Frigate host: http://<FRIGATE_IP>:5000
SSL: on/off (you disabled it)

What You Get in Home Assistant

Home Assistant will create:

A device for Frigate itself
Devices for each camera
Entities for object counts and occupancy
Entities for zones (if you’ve defined zones)

Tip: Use a consistent naming scheme for zones so you can identify them easily later.

Notifications the Easy Way: Blueprint

You use the Frigate Mobile App Notification Blueprint (from the forums).

Install the Blueprint

Settings → Automations & Scenes → Blueprints
Import blueprint
Search: “Frigate Mobile App Notification”
Import into your HA instance

PLACEHOLDER: Add the blueprint link here.

Blueprint Settings Worth Calling Out

Trigger Type: Alert vs Detection

Your transcript specifically calls out the blueprint can trigger from alert or detection.

Use alerts when you want less noise
Use detections when you’re still tuning the system

Zones

If your camera sees a road/sidewalk, you can create a “walkway” zone and only notify on that area.

PLACEHOLDER example:

Zone name: doorbell_walk (your post should match your exact naming)

Object Filters

You used:

person
package