How to connect neural network vision to home cameras with Unblink

A familiar story: you have two or three RTSP cameras at home or in the office, recording gigabytes of video to disk, but to find the moment when a courier left a package at the door, you have to manually scrub through the timeline at 8x speed. A traditional motion detector doesn't help much here. It triggers on flying insects, tree shadows, and passing headlights, creating hundreds of false markers in the archive.

Recently I came across the Unblink repository (version V2). The developers at zapdos-labs tried to solve this pain point using multimodal vision-language models (VLM). The idea is simple: the video stream is fed to a neural network, and the user communicates with their cameras through a regular chat or searches for specific clips using text.

What Unblink can do

The project is built on a combination of a local agent, a management server, and the Qwen3-VL model. Here's what the system does in practice:

• Text-based archive search. You can type a query like "a person in a red jacket entered the building" or "courier with a package," and the system will return timestamps of matching frames instead of manually watching five hours of footage.
• Chat with cameras. Works as a question-and-answer interface to the video stream. You ask "were there any guests after 6 PM?", the model analyzes the saved frames and responds with coherent text.
• Frame analysis and summarization. The neural network compresses video footage into text descriptions of what's happening, saving time on initial incident review.
• Operation via relay without port forwarding. A compact node runs on the local network and maintains its own connection to the management server.

How the architecture works

Architecturally, Unblink is split into two parts: a management server and a lightweight node that sits next to the cameras.

+-------------------------------------------------------+
|                     Public Server                     |
|  (Auth, DB PostgreSQL, Web UI SolidJS, VLM Analysis)  |
+-------------------------------------------------------+
                           ▲
                           │ Безопасный туннель
                           ▼
+-------------------------------------------------------+
|                   Local Network Node                  |
|                   (unblink-node CLI)                  |
+-------------------------------------------------------+
        │                                    │
        ▼ RTSP                               ▼ MJPEG
   [ Камера 1 ]                         [ Камера 2 ]

The server side handles authorization, data storage, and the web interface. The frontend is written in SolidJS using TypeScript, Vite, and Ark UI components. PostgreSQL via pgx is used as the database. For working with video streams, the developers chose the proven go2rtc engine, which handles RTSP and WebRTC conversion for the browser excellently.

The unblink-node node is written in Go. It runs inside your local network, connects to RTSP or MJPEG streams from cameras, and proxies them to the server. This means you don't need to open ports on your router or expose cameras directly to the internet.

Quick node startup

If you already have a server running (or are using the cloud deployment), you can connect local cameras in a couple of minutes.

Pre-built binaries

GitHub releases contain compiled files for Linux and Windows (both x86_64 and ARM64). Download the archive, extract it, and run:

# Для Linux
tar -xzf unblink-node_linux_amd64.tar.gz
./unblink-node

On Windows, startup looks similar via PowerShell:

.\unblink-node.exe

On first startup, the utility will output a URL to the terminal. Open it in your browser to authorize the node in the control panel.

Building from source

If you have Go installed on your machine, the easiest way to install the utility is with the go install command:

go install github.com/zapdos-labs/unblink/cmd/unblink-node@main
unblink-node

Local development of the full stack

For those who want to dig deeper or deploy the server side locally, the repository includes a convenient Makefile. You'll need tmux, as it brings up the server, node, and web interface in one window:

# Ставим зависимости
make install

# Копируем конфиг окружения
cp .env.example .env

# Запускаем все компоненты в dev-режиме
make dev

The repository also has make typecheck commands for type-checking the frontend and make proto for regenerating Protobuf files when network contracts change.

Where this comes in handy

The project clearly targets the niche of advanced home video surveillance and small office setups where standard NVRs like Frigate or Shinobi fall short specifically in semantic search capabilities.

A good example: monitoring a parking lot in front of your house. Instead of configuring detection zones, you can simply ask the chat "when did the blue car leave?". Another scenario is controlling a warehouse area where it's important to quickly find loading moments without watching terabytes of empty footage.

The fly in the ointment and conclusions

The README documentation is still minimal. There's no detailed description of system requirements for running Qwen3-VL inference on your own hardware, so heavy models will likely need to be moved to a server with a good GPU or connected via external APIs.

Nevertheless, the codebase in Go and SolidJS looks clean, and the choice of go2rtc as the media engine speaks to a solid understanding of video processing specifics. If you've been looking for a way to attach VLM to your home cameras and don't want to write the wrapper from scratch, Unblink is definitely worth a look. The source code is open under the AGPL-3.0 license.