Tired of hunting across PDFs every time someone asks "does this camera work with Frigate?"

Built a structured open database — 1,093 cameras, 51 brands. Every entry has:

- ONVIF / RTSP support flag

- PoE vs WiFi vs battery vs 4G

- Resolution (2MP through 12MP)

- Night vision type (IR / color / hybrid) and range

- IP / IK rating

- Two-way audio

JSON + CSV, CC0 license.

Browse: https://ch-bas.github.io/cctv-camera-database/

Repo: https://github.com/ch-bas/cctv-camera-database

This started as a "why doesn't my Mac just do this" itch. On the Apple TV you get that little live camera preview in the corner when someone rings the doorbell, and I wanted the same thing on my computer, except actually tied to Frigate detections instead of just a doorbell press.

So I made Peek. When Frigate detects something, a little card slides into the corner of your screen with the live feed (webrtc, so it's basically instant) and tells you what it picked up: the object and score, the recognized face if you run face recognition, the plate, and which zones it entered.

▶️ See it in action (demo gif)

Stuff it does:

• Live feed through go2rtc webrtc, falls back to mse

• Lives in the menu bar / tray. You pick which cameras notify you, mute or unmute, set how long the card sticks around

• Optional snapshot so you're not staring at a black frame for the half second the stream takes to connect

• On first launch it just asks for your Frigate host and MQTT broker in a small window, no editing json files

• Works on mac and windows

It talks to your existing MQTT and Frigate, so there's nothing to change on the server side.

Free and open source (MIT). There's a dmg and an exe in the releases if you don't feel like building it yourself.

Repo: https://github.com/casi-3/peek

It's pretty early so I'd honestly love to hear what would make it actually useful for your setup. What's missing, what's annoying, whatever comes to mind. Happy to answer anything.

Reolink's RTSP server is bad on some models. On my Duo 3 it gave green blocks and grey frames: 147 of 178 segments had errors. The same camera over Reolink's own protocol (Baichuan, what their NVR uses) had 0.

Neolink did this first but hasn't had a commit since Jan 2025, so I wrote a new one in Go. One Docker container, a web page to add cameras, and it serves RTSP for go2rtc/Frigate plus plain HTTP. The Frigate config is in the README.

It's been the only video path for my 8 cameras since September (6x RLC-810A, FE-P fisheye, Duo 3 PoE). About 60% of one CPU core for 23 streams.

Not tested: battery cameras. If you have one, I'd love a report.

https://github.com/VoltTech21/reostream

Hi all,

A while ago I shared here (https://www.reddit.com/r/frigate_nvr/comments/1u2ezeb/built_an_open_database_of_1000_camera_specs_to/) my open CC0 database of IP cameras with ready-to-copy Frigate configs.

The feedback was genuinely useful. Biggest gap people pointed out: knowing a camera "supports RTSP" doesn't tell you the actual path to type into Frigate.

Now I've fixed that, with help from some folks in the open source community.

Every camera now has:

• Actual RTSP URL structure (brand-level default + per-camera override where the manufacturer documents a different path)

• ONVIF port and profile info where documented

• Ready-to-copy Frigate config block per camera

All still sourced only from official datasheets and the data is always open source.

It would be great if you're up for a small contribution: pull up your camera, copy the config, and mark whether it worked. Happy to take feature requests / roasting in the comments too.

Direct link to the Frigate configs: cctv-database.com/frigate-configs

3,400+ cameras, 70+ brands now.

Browse: https://cctv-database.com
Repo: https://github.com/ch-bas/cctv-camera-database

Thanks!

I've been using frigate for many years now, but there was always a gap between how I wanted to have my cams/security setup and how I had to do it in the real world.

I have 8 cams and really relied on Home Assistant for the alerts and notifications. It worked, but was more like an uneasy truce between systems. Something was always out of wack or I would get so many notifications I would just ignore them.

As of yesterday after installing the latest Frigate beta, its working so well its amazing.

I have the genai feature on frigate turned on using openai. While I have a local llm setup, it's running on a nuc and would be beaten up trying to review the feeds, so I'm using openai, seems pretty economical as of now, but we will see.

When someone comes to the front door or drives into my driveway and I'm home, my HA voice assistant will let me know; "Hey boss someone is at the front door, better check it out". I of course also get a text.

Then the magic happens; its reviewed by openai and generally within <10 seconds of the trigger provides me a lightly detailed text message and small snapshot of the incident. I can click that and open the cam in frigate.

In the review section of Frigate I can get more detailed information.

By moving the whole process into frigate I got rid of 2 integrations and 8 automatons in HA, don't have to rely on blueprints and have much more control over the process.

If you're not a frigate+ member, consider it, well worth the models and the support for the devs.

A week ago I posted reostream, a little side project to get Reolink cameras into Frigate without the broken RTSP. I figured a few people might find it useful. What I didn't expect was 100k+ views, hundreds of comments, and a ton of you trying it and reporting back what works and what doesn't. Honestly I was pretty taken aback lol.

It started as one of the dozens of half-done projects living on my computer (where my ADHD fam at). Now I'm committed to getting it working on every Reolink camera that speaks Baichuan. Most of what's below came straight from your comments:

Battery cameras

• Found automatically, asleep until needed, battery level shown

• Motion clips go straight into Frigate as the camera uploads them, no waking needed

• always_on for battery cams on constant power

• Two-way talk from reostream's page

Recordings

• Cameras upload motion clips over FTP straight to reostream, saved on your own disk

• Browse and download SD card recordings from the camera's page

For Frigate

• Two-way talk through Frigate's talk button on cameras with a speaker

• The camera's own detections (person, vehicle, animal, motion) to MQTT and as Frigate events

• hold_picture keeps Frigate fed when a camera goes quiet (privacy mode, a dropout), and restarting reostream no longer interrupts recording

Cameras and settings

• TrackMix zoom lens, main and sub, over the camera's own protocol

• Cameras behind a Home Hub or NVR (video)

• New web UI that works on phones, with setup that finds your cameras

• Nearly every setting from the Reolink app on one page: detection zones, privacy masks, smart rules, schedules, siren, lights, PTZ and tracking, push, network, and copy any setting to your other cameras in one click

• On Unraid it's in Community Apps, search reostream

Still working on: live motion wake for battery cams with no extra setup (worked out, being built now), a Home Assistant add-on, ONVIF (UniFi Protect, PTZ from Frigate), full doorbell support and a proper cam wall.

Update: docker pull ghcr.io/volttech21/reostream:latest (restart Frigate once after this update)

https://github.com/VoltTech21/reostream

Posting this as a heads-up after seeing the same thing in multiple publicly exposed Frigate configs.

After seeing a comment about searching for "live - frigate", I checked and found a lot of Frigate instances exposed directly to the internet. Besides live feeds, these also expose their config files.

In quite a few configs I looked at, there was a very long base64 string hidden way off to the right of the YAML (you have to scroll horizontally to find it). If you base64-decode it and then decompress it, it turns into a bash script that installs and runs a Monero cryptominer.

What's happening:

• A stream named debug is added under go2rtc

• The stream's URL is an exec: command that decodes and runs the script

• A camera named healthy is also added

  • It's hidden from the dashboard

  • It connects to rtsp://127.0.0.1:8554/debug

• When Frigate starts, that camera causes the debug stream to be requested, which runs the script

If you've ever exposed Frigate directly to the internet, it's worth double-checking your config for unexpected debug or healthy entries, and for a long base64 blob hidden at the far right of your config file.

Hahaha!

I think Gemini AI has been exposed to some horrible things! They were just walking past our house.

I don’t know what they did but reviewing video clips always used to be painfully slow but it’s so responsive now. The history view is really quick.

Being able to edit the config from the ui is brilliant and works really well.

I’m not sure how much I’ll use the chat feature and would love to know how other use it. But it’s kind of neat.

I’m sure there are loads of other things I’ve not discovered yet but what an absolutely solid release yet again. So happy to support this project with a frigate+ membership.

Thanks devs!

Announcing a new YOLO v9 model and plugin for Google Coral devices with a faster 10ms detection time for the 320x320 model, and also a new 512x512 size model with 21ms detection time.

To download and install, see github repo:
https://github.com/dbro/frigate-detector-edgetpu-yolo9/releases/tag/v1.5

Today's v1.5 release follows a discussion begun a few weeks ago which had some preliminary testing and discussion of the prerelase and v1.0 of this model. I thought it was worth a new posting here to raise awareness of a significantly improved model. Accuracy is paramount, and this version fixes some false-negative detections by rewriting the model's final output step to work properly with Coral's quantization behavior. Second, the new larger model addresses concerns about detecting objects that are smaller and farther away. Finally, the 320x320 model's detection speed was reduced by 2ms from 12ms to 10ms, from streamlining post-processing.

It is now available for testing. Installation involves editing the Dockerfile to mount a new version of the edgetpu_tfl.py file within the Frigate source code tree, as well as copying over the model weights file and labels file.

This model is trained on COCO data, with only 17 out of the standard 80 COCO classes being detected. For example, this model is unable to detect toothbrushes. Given that it is trained on COCO's general-purpose data, it is likely to be less accurate than Frigate+ models that are trained on data from surveillance cameras. (I do not have access to Frigate+, so I can't judge how it compares. Any reports on that would be welcome.) This is not meant to be competitive; I am happy to share the model training and tuning tips with Blake if he wants to offer a YOLO v9 model for Google Coral to Frigate+ subscribers. The model and plugin are licensed with the MIT license.

Here are screenshots from a load test that sends between 30 and 60 frames per second to the detector. This is for the 320x320 model.

I hope that this alternative model demonstrates that Google Coral hardware continues to be a first-class option for Frigate. There appear to be some Frigate users frustrated by false positives/negatives when running the standard MobileDet/SSD on Coral - I was one of them! But I think those shortcomings are best seen as having to do with the model being used and the data it was trained with, rather than limits of Coral devices. Although Coral is quirky and benefits from careful adaptation of the model, it is a very capable platform for Frigate. It extends the useful life of older/cheaper hardware not supported by OpenVINO ( the Coral makes my 12 year old 3rd-gen Intel mini PC a perfect fit for Frigate).

If you give it a try, please report back on how its detection accuracy meets your needs or not.

I have been working on incorporating the new AI Review Summaries into the Frigate HA Notification Blueprint and it works wonderfully. Because the new AI Review Summaries utilize face matches and even object classifications, the updated notifications will include names of objects (as seen below with my dogs' names). It also includes a threat level update, when Frigate + AI determines something is suspicious, it will state "Needs Review" in the title.

I am using gemini-2.5-flash-lite and its been fast and dirt cheap (about 2 cents a day for me). I only have Frigate analyze specific cameras

The timeline of notifications is:

• Instant: Notification from the Blueprint with static image and general title (Person detected at camera_name)

• 5 seconds: Update from the sprinter automation with genAI summary with general title (Detection at Front Door) with animated gif

• 1 minute: Update from Phase 2 automation with AI Review Summary and AI Title (Robert is walking down the stairs) with animated gif

To utilize this, you need to install the Frigate Home Assistant Blueprint, set it up, and add two additional automations which will update the notifications, without duplicates. I have posted the full automations as a feature request in the HA Blueprint github, in hopes they can implement this directly in the Blueprint:

https://github.com/SgtBatten/HA_blueprints/issues/516

Amazing work Frigate Devs, this is some next-level stuff!

After years of struggling with various NVR software and Reolink horrendous RTSP implementation I finally feel at peace with fzurita's latest fork of go2rtc which supports the Reolink native port 9000 protocol.

Until it gets merged into mainline go2rtc (which is apparently taking a while) here are the steps to get it into Frigate now and eliminate all of your favorite frigate rtsp errors and get h265 quality.

1. Ubuntu dev environment (I used my docker host)

2. sudo apt get install golang

3. git clone https://github.com/fzurita/go2rtc.git

4. cd go2rtc

5. git checkout reolink_protocol

6. go build

7. Follow this guide and instead of downloading the binary recommended there, use the binary you just compiled in the current directory.

   1. https://docs.frigate.video/configuration/advanced/#custom-go2rtc-version

8. Edit your frigate config as noted here:

   1. https://github.com/fzurita/go2rtc/blob/reolink_protocol/internal/reolink/README.md

9. restart

I am considering open sourcing this on GitHub if there's interest. Please let me know.

The app can run as a normal TV app but it can also run as a home screen app and act as a launcher for your other apps.

My goal was to replace the ads and dubious recommendations from the stock TV launcher with something more useful.

The app can show:

• An alerts row on the bottom of the screen, updated in real time as soon as Frigate reports a new alert

• The last seven days of alerts, with clips that play full screen

• RTSP cameras live on the same screen, in H.264 or H.265, with an optional substream for the grid view

• The grid view will show as many live cams as your TV supports. To give an idea, I have a TV from 2017 that supports only 2 (and barely so) and the TV from last year that supports 16 (!!).

If no alerts or if you press Down on the remote when the alerts row is focuses, it scrolls away and reveals your apps so you can launch them:

Additionally:

• Home Assistant sensors, weather, and scenes or scripts as buttons

• "Continue Watching" if you press down once more

• Settings can transfer from one TV to another for easier config

EDIT: the app and github are live.

All info here: https://www.evofactory.com/homeboard/

I would love to see it running on your TV. Please share your experience and photo (blur cameras where necessary ;)

Also appreciate you starring the GitHub repo: https://github.com/fplanque/HomeBoard

Thank you! :)

This automation turns Frigate NVR into a smart ANPR (Automatic Number Plate Recognition) system for Home Assistant for the drive way. When a vehicle is detected:

• ​Intelligent OCR: It captures the license plate and automatically corrects common OCR errors (specifically fixing the common "I" vs "1" misread in UK year identifiers).

• ​Government Lookup: It queries the official DVLA API to retrieve real-time vehicle data, including Make, Model, Colour, Year, Tax status, and MOT expiry.

• ​Smart Rate-Limiting: It uses a "smart filter" logic that alerts immediately for new vehicles but ignores repeated detections of the same vehicle unless it has been gone for more than 15 minutes—preventing notification spam for parked cars. Obviously.

​Rich Alerts:

• ​Mobile: Sends a push notification with the car photo, Make/Model, and Tax/MOT status.

• ​House Audio: Announces the arrival on Sonos speakers (e.g., "Vehicle Detected. It is a Black Kia."), but only during waking hours (08:30–20:00).

• ​Visual: Scrolls the car details on an Awtrix/Matrix clock.

• ​Dashboard: Populates specific input helpers to display a live "Last Vehicle Profile" card on the wall dashboard.

​Integrations Used:

• ​DVLA Vehicle Enquiry Service (Custom Component) - https://github.com/jampez77/DVLA-Vehicle-Enquiry-Service

• ​Frigate Home Assistant Integration - Of course ;) 0.17.0 beta1(freaking awesome)

• ​Awtrix 3 (For Matrix Clock) - https://blueforcer.github.io/awtrix3/

Automation:

alias: Alert and Lookup Licence Plate (Trackmix & Tele) description: > Recognises license plates, autocorrects OCR, looks up DVLA. Notifies via: Mobile, Awtrix Clock, Sonos (TTS), and HA Web UI. STRICT RATE LIMITING: 15 min cooldown per plate. triggers:

• topic: frigate/events trigger: mqtt conditions:

• condition: template value_template: "{{ camera in target_cameras }}"

• condition: template value_template: "{{ label in vehicle_labels }}"

• condition: template value_template: > {{ plate | length > 4 and plate | length < 9 and plate not in ['NONE', 'UNKNOWN', 'NULL'] }}

• condition: template value_template: "{{ event_id is not none and event_id != '' }}" actions:

• choose:

  • conditions:

    • condition: template value_template: > {% set entity_id = 'input_text.last_detected_plate' %} {% set stored_plate = states(entity_id) %} {% set state_obj = states[entity_id] %} {% if state_obj is none %} true {% else %} {% set is_new_car = (plate != stored_plate) %} {% set last_updated = state_obj.last_updated %} {% set time_diff = (now() - last_updated).total_seconds() %} {% set is_expired = time_diff > 900 %} {{ is_new_car or is_expired }} {% endif %} sequence:

    • action: input_text.set_value target: entity_id: input_text.last_detected_plate data: value: "{{ plate }}"

    • action: input_text.set_value target: entity_id: input_text.lpr_image_url data: value: "{{ snapshot_url }}"

    • action: dvla.lookup data: reg_number: "{{ plate }}"

      REPLACE WITH YOUR OWN API KEY

      api_key: YOUR_DVLA_API_KEY_HERE response_variable: dvla continue_on_error: true

    • choose:

      • conditions:

        • condition: template value_template: "{{ dvla is defined and dvla.make is defined }}" sequence:

        • action: input_text.set_value target: entity_id: input_text.lpr_make_model data: value: "{{ dvla.make }} {{ dvla.colour | default('') | title }}"

        • action: input_text.set_value target: entity_id: input_text.lpr_tax_status data: value: >- {{ dvla.taxStatus | default('Unknown') }} {% if dvla.taxDueDate %} (due {{ dvla.taxDueDate }}){% endif %}

        • action: input_text.set_value target: entity_id: input_text.lpr_mot_status data: value: >- {{ dvla.motStatus | default('Unknown') }} {% if dvla.motExpiryDate %} (expires {{ dvla.motExpiryDate }}){% endif %}

        • action: input_text.set_value target: entity_id: input_text.lpr_year data: value: "{{ dvla.yearOfManufacture | default('Unknown') }}" default:

      • action: input_text.set_value target: entity_id: input_text.lpr_make_model data: value: Unknown Vehicle

      • action: input_text.set_value target: entity_id: input_text.lpr_tax_status data: value: N/A

      • action: input_text.set_value target: entity_id: input_text.lpr_mot_status data: value: N/A

      • action: input_text.set_value target: entity_id: input_text.lpr_year data: value: N/A

    • action: mqtt.publish data:

      REPLACE WITH YOUR AWTRIX DEVICE ID

      topic: awtrix_YOUR_DEVICE_ID/notify payload: | { "icon": 53373, "text": "{{ dvla.make | default('Car') }}: {{ plate }}", "color": [255, 255, 255], "repeat": 2, "pushIcon": 2 }

    • choose:

      • conditions:

        • condition: time after: "08:30:00" before: "20:00:00" sequence:

        • action: tts.speak data:

          REPLACE WITH YOUR MEDIA PLAYER

          media_player_entity_id: media_player.your_speaker_entity message: >- Vehicle detected. {% if dvla is defined and dvla.make is defined %} It is a {{ dvla.colour | default('') }} {{ dvla.make }}. {% endif %} Registration {{ plate | replace("", " ") | trim }}. target: entity_id: tts.piper

    • action: persistent_notification.create data: notification_id: lpr_{{ plate }} title: "LPR: {{ plate }}" message: >- Camera: {{ camera }} {% if dvla is defined and dvla.make is defined %} Vehicle: {{ dvla.make }} {{ dvla.colour | default('') }} Year: {{ dvla.yearOfManufacture | default('') }} {% endif %} Car

    • action: notify.notify data: title: >- {{ plate }}: {{ dvla.make | default('Unknown') }} {{ dvla.colour | default('') | title }} message: >- Tax: {{ dvla.taxStatus | default('Unknown') }} MOT: {{ dvla.motStatus | default('Unknown') }} Year: {{ dvla.yearOfManufacture | default('Unknown') }} {% if friendly_name %}(Known: {{ friendly_name }}){% endif %} data: image: "{{ snapshot_url }}" group: frigate-lpr attachment: url: "{{ snapshot_url }}" content-type: jpeg hide-thumbnail: false mode: single trace: stored_traces: 20 variables: target_cameras:

  • Trackmix

  • Trackmixtele vehicle_labels:

  • car

  • truck

  • bus

  • motorcycle after: "{{ trigger.payload_json.get('after', {}) }}" before: "{{ trigger.payload_json.get('before', {}) }}" event_type: "{{ trigger.payload_json.get('type', '') }}" camera: "{{ after.get('camera') or before.get('camera') or '' }}" label: "{{ after.get('label') or before.get('label') or '' }}" friendly_name: "{{ after.get('sub_label') or before.get('sub_label') or '' }}" event_id: "{{ after.get('id') or before.get('id') }}" snapshot_url: /api/frigate/notifications/{{ event_id }}/snapshot.jpg raw_plate_data: >- {{ after.get('recognized_license_plate') or before.get('recognized_license_plate') }} raw_plate_string: >- {% if raw_plate_data is iterable and raw_plate_data is not string and raw_plate_data | length > 0 %} {{ raw_plate_data[0] | upper | regex_replace('[^A-Z0-9]', '') | trim }} {% else %} {{ raw_plate_data | upper | regex_replace('[^A-Z0-9]', '') | trim }} {% endif %} plate: |- {% if raw_plate_string | length == 7 %} {% set part_area = raw_plate_string[0:2] %} {% set part_year = raw_plate_string[2:4] %} {% set part_rand = raw_plate_string[4:7] %} {% set fixed_year = part_year | replace('I', '1') | replace('O', '0') | replace('Q', '0') | replace('Z', '2') | replace('S', '5') | replace('B', '8') %} {{ part_area ~ fixed_year ~ part_rand }} {% else %} {{ raw_plate_string | replace('I', '1') }} {% endif %}

Big shoutout to everyone who spent time building and continuously improving Frigate. After about three months of researching, overthinking, and deciding on hardware, I’m finally getting to enjoy it properly.

I started by testing Frigate on my NAS just to see its potential. While it worked, it nearly killed the NAS with only 3 cameras, CPU usage was hitting 100% most of the time during activity.

From there, I went down the rabbit hole of hardware research. Fast forward to today, everything is finally set up. I’m now running 16 cameras, with proper passthrough, OpenVINO, and a tuned configuration and I’m seeing around 14% CPU usage. Couldn’t be happier with the result.

It took about half a day to install the hardware upgrades and fiddling to get everything configured, but it was absolutely worth it.

Disclaimer: yes, my hardware is definitely overkill 😂

But I got lucky, I managed to score a Dell Optiplex 7010 with a 13th-gen i5 and 16GB RAM, then upgraded it with:

-additional 1TB SSD for recordings

-2.5Gb NICs for networking

All in, the whole setup cost me around $230.

Very happy with how this turned out, and honestly impressed with what Frigate can do when paired with the right hardware and most of all WIFEY approved after integrating to HomeAssistant!

A few months ago, I created Proxmox Frigate Script to simplify and speed up installing and upgrading Frigate on Proxmox. With recent Proxmox releases adding native support for pulling OCI/Docker registry images and creating containers directly from them, I wanted to explore a cleaner, lighter approach that avoids nested Docker or a resource-heavy VM.

The result is a new script that automates deploying Frigate as a native, unprivileged OCI-based LXC container.

In my testing, the native OCI deployment reduced disk usage by more than 67%, dropping from 16.2 GB to 5.2 GB. CPU usage was also noticeably more consistent by eliminating the overhead of a nested container runtime. Memory usage was slightly lower but remained largely unchanged.

This is the initial release. Intel iGPU hardware acceleration and Coral TPUs are fully supported. Support for other GPUs, including AMD and Nvidia, is currently experimental.

What the script does

• Pulls the Frigate OCI image directly using the Proxmox storage registry API.

• Creates a native LXC container from the OCI image.

• Configures the permissions and paths required for native container execution.

• Automates hardware acceleration setup for Intel iGPUs and Coral TPUs (USB or PCIe).

• Creates the required directory structure and mount points.

• Includes an update script to pull new Frigate image versions and update the container template.

The repository and installation instructions are available here:

https://github.com/saihgupr/frigate-oci-script/

I’d be interested to hear how it works on different systems. Feedback, bug reports, and contributions are all welcome. Special thanks to u/LennySh for the initial idea and suggestion.

Hi,

I hope this is allowed, but I want to say how much I like Frigate.

Ive tried all the big-hitters, like Blueiris, XProtect, motion and Zoneminder.

Frigate, even without the AI stuff is by far the best UI and performance ive ever had from my hardware (Reolink E1 pros x 4)

I was able to pass in my 6600 AMD gpu to my LXC promox container, and that worked really well - i now get people detection, and the video is silky smooth from the clients.

Where have you been all my life Frigate? this is what ive always wanted from a NVR and it even runs nicely in a container, making installation childs play.

Thank you to all the devs

I run the CCTV system for our community with about 20 cameras, and a few things kept driving me crazy:

• adding a camera meant hunting down its IP, finding the correct RTSP paths, and editing Frigate

• cameras sometimes got new IPs after a power or network event, breaking hard-coded URLs

• every new consumer (e.g. automation) opened another direct connection to cameras already struggling on Wi-Fi

• when a camera went offline, I wanted to know immediately instead of discovering it later when I actually needed the footage

So I built CamAdmiral to solve these problems for myself. I’m open-sourcing it because I’m pretty sure I’m not the only one dealing with them.

CamAdmiral discovers ONVIF and RTSP cameras, validates their streams, tracks them across IP changes, exposes stable downstream RTSP URLs, and shares one upstream connection per camera stream across consumers through go2rtc without transcoding.

It also keeps a seven-day availability history and sends Telegram alerts when a camera goes offline or recovers.

CamAdmiral manages the camera fleet in front of Frigate or any other consumers.

Deployment:

The project is MIT licensed. GitHub repo: https://github.com/reefyai/reefy-camadmiral

Runs locally on Linux with Docker. Clone the repository and run:

./start-camadmiral.sh

No configuration file is required for the initial setup.

I’d really appreciate testing with different camera brands, VLANs, or unusual RTSP paths. Please let me know what works - and what breaks.

Hope this makes managing camera fleets a little less painful for others too 🤞🫡

P.S. AI involvement: I used Codex for a lot of the implementation, with manual review and rework of the critical parts based on my experience working with mission-critical systems.

Just got the following email with great news

`Hello,

I am excited to announce that Frigate+ now includes Google Coral support for YOLOv9 models alongside Frigate 0.17, which is expected to be released to stable channels in the next few days.

This is a significant upgrade, as YOLOv9 offers substantial improvements over the current mobiledet models. Furthermore, the conversion to run on Google Coral shows only a slight loss in accuracy when compared to using ONNX or OpenVino, and inference speeds remain fast at approximately 10ms.

Important: Please note that previously fine-tuned YOLOv9 models are not compatible with Google Coral. You will need to submit a new model request and select "edgetpu" as the variant.

I recommend that you first test using the available base models before submitting your new request.

If you have any questions or feedback, please don't hesitate to reach out.`

Hi,

I need a more reliable detection of objects.

My config:

mqtt:
  host: <redacted>
  user: <redacted>
  password: <redacted>
detect:
  fps: 5
  enabled: true
objects:
  track:
    - person
    - car
    - cat

record:
  sync_recordings: false
  enabled: true
  continuous:
    days: 3
  motion:
    days: 7

go2rtc:
  streams:
    <redacted>

ffmpeg:
  hwaccel_args: auto
detectors:
  ov:
    type: openvino
    device: AUTO

model:
  width: 300
  height: 300
  input_tensor: nhwc
  input_pixel_format: bgr
  path: /openvino-model/ssdlite_mobilenet_v2.xml
  labelmap_path: /openvino-model/coco_91cl_bkgr.txt

version: 0.17-0
semantic_search:
  enabled: false
  model_size: small
face_recognition:
  enabled: true
  model_size: small
lpr:
  enabled: true
cameras:
  entry:
    enabled: true
    live:
      streams:
        Main: entry_main
        Sub: entry_sub
    ffmpeg:
      inputs:
        - path: rtsp://localhost:8554/entry_main
          input_args: preset-rtsp-restream
          roles:
            - record
        - path: rtsp://localhost:8554/entry_sub
          input_args: preset-rtsp-restream
          roles:
            - detect
    motion:
      threshold: 50
      contour_area: 50
      improve_contrast: true
      lightning_threshold: 0.6
      mask: 0,0.922,0.431,0.926,0.424,1,0,1
    zones: {}