Hoe neurale netwerkvisie verbinden met thuiscamera's met Unblink

Een bekend verhaal: je hebt twee of drie RTSP-camera's thuis of op kantoor, die gigabytes aan video naar schijf opnemen, maar om het moment te vinden waarop een koerier een pakket bij de deur achterliet, moet je handmatig door de tijdlijn scrubben met 8x snelheid. Een traditionele bewegingsdetector helpt hier niet veel. Hij triggert op vliegende insecten, schaduwen van bomen en passerende koplampen, waardoor honderden valse markeringen in het archief ontstaan.

Onlangs kwam ik de Unblink repository tegen (versie V2). De ontwikkelaars bij zapdos-labs hebben geprobeerd dit pijnpunt op te lossen met multimodale vision-language modellen (VLM). Het idee is eenvoudig: de videostream wordt gevoed aan een neuraal netwerk, en de gebruiker communiceert met zijn camera's via een gewone chat of zoekt naar specifieke clips met behulp van tekst.

Wat Unblink kan doen

Het project is gebouwd op een combinatie van een lokale agent, een beheerserver en het Qwen3-VL model. Hier is wat het systeem in de praktijk doet:

• Tekstgebaseerd archief zoeken. Je kunt een query typen zoals "een persoon in een rood jasje betrad het gebouw" of "koerier met een pakket", en het systeem retourneert tijdstempeln van overeenkomende frames in plaats van handmatig vijf uur beeldmateriaal te bekijken.
• Chatten met camera's. Werkt als een vraag-en-antwoord interface voor de videostream. Je vraagt "waren er gasten na 18:00 uur?", het model analyseert de opgeslagen frames en antwoordt met samenhangende tekst.
• Frame-analyse en samenvatting. Het neurale netwerk comprimeert videobeelden tot tekstbeschrijvingen van wat er gebeurt, wat tijd bespaart bij de eerste incidentbeoordeling.
• Werking via relay zonder poortforwarding. Een compacte node draait op het lokale netwerk en onderhoudt zijn eigen verbinding met de beheerserver.

Hoe de architectuur werkt

Architecturally, Unblink is opgedeeld in twee delen: een beheerserver en een lichtgewicht node die naast de camera's staat.

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

De serverkant verzorgt autorisatie, gegevensopslag en de webinterface. De frontend is geschreven in SolidJS met TypeScript, Vite en Ark UI componenten. PostgreSQL via pgx wordt gebruikt als database. Voor het werken met videostreams kozen de ontwikkelaars voor de bewezen go2rtc engine, die RTSP en WebRTC conversie voor de browser uitstekend afhandelt.

De unblink-node node is geschreven in Go. Hij draait binnen je lokale netwerk, maakt verbinding met RTSP of MJPEG streams van camera's en proxiet ze naar de server. Dit betekent dat je geen poorten op je router hoeft te openen of camera's direct aan het internet hoeft bloot te stellen.

Snelle node-opstart

Als je al een server draait (of de cloud deployment gebruikt), kun je lokale camera's in een paar minuten aansluiten.

Pre-built binaries

GitHub releases bevatten gecompileerde bestanden voor Linux en Windows (zowel x86_64 als ARM64). Download het archief, pak het uit en voer uit:

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

Op Windows ziet de opstart er vergelijkbaar uit via PowerShell:

.\unblink-node.exe

Bij de eerste opstart geeft het hulpprogramma een URL uit naar de terminal. Open deze in je browser om de node te autoriseren in het controlepaneel.

Bouwen vanuit broncode

Als je Go op je machine hebt geïnstalleerd, is de gemakkelijkste manier om het hulpprogramma te installeren met het go install commando:

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

Lokale ontwikkeling van de volledige stack

Voor degenen die dieper willen graven of de server-side lokaal willen deployen, bevat de repository een handige Makefile. Je hebt tmux nodig, want het brengt de server, node en webinterface in één venster omhoog:

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

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

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

De repository heeft ook make typecheck commando's voor type-checking van de frontend en make proto voor het regenereren van Protobuf bestanden wanneer netwerkcontracten veranderen.

Waar dit van pas komt

Het project richt zich duidelijk op de niche van geavanceerde thuisvideobewaking en kleine kantooropstellingen waar standaard NVR's zoals Frigate of Shinobi tekortschieten specifiek in semantische zoekmogelijkheden.

Een goed voorbeeld: het monitoren van een parkeerplaats voor je huis. In plaats van detectiezones te configureren, kun je simpelweg aan de chat vragen "wanneer is de blauwe auto vertrokken?". Een ander scenario is het controleren van een magazijngebied waar het belangrijk is om laadmomenten snel te vinden zonder terabytes aan leeg beeldmateriaal te bekijken.

De smet in het oog en conclusies

De README documentatie is nog minimaal. Er is geen gedetailleerde beschrijving van systeemvereisten voor het draaien van Qwen3-VL inferentie op je eigen hardware, dus zware modellen moeten waarschijnlijk worden verplaatst naar een server met een goede GPU of worden aangesloten via externe API's.

Desondanks ziet de codebase in Go en SolidJS er clean uit, en de keuze voor go2rtc als media-engine getuigt van een goed begrip van de specificaties van videoverwerking. Als je op zoek bent naar een manier om VLM aan je thuiscamera's te koppelen en je niet de wrapper vanaf nul wilt schrijven, is Unblink zeker het bekijken waard. De broncode is open onder de AGPL-3.0 licentie.