Communitygithub.com

VideoDB Skill – Video, Live-Streams und Desktop-Erfassung

Videoinhalte erfassen, verstehen und bearbeiten: Dateien, URLs, RTSP/Live-Feeds oder Desktopaufnahmen einlesen; Echtzeit-Kontext und abspielbare Stream-Links liefern; visuelle/semantische/zeitliche Indizes erstellen und Momente mit Zeitstempeln suchen; transkodieren, mit Timeline-Operationen bearbeiten und Medien-Assets generieren.

Was ist VideoDB Skill – Video, Live-Streams und Desktop-Erfassung?

Dieses Skill für KI-Agenten (wie Claude Code, Cursor oder Codex) bietet eine umfassende Schnittstelle zur VideoDB-Plattform. Es ermöglicht Agenten, Videodaten aus unterschiedlichsten Quellen – lokale Dateien, URLs, YouTube-Links, RTSP-Live-Streams oder Desktop-Bildschirmaufnahmen – zu importieren und sofort in durchsuchbare und bearbeitbare Medien umzuwandeln. Die Kernfunktionen umfassen das Transkodieren und Normalisieren von Videoeigenschaften (Codec, Bitrate, FPS, Auflösung, Seitenverhältnis), das Erstellen von Indexen für gesprochene Wörter, Szenen und Schlagwörter sowie die präzise Suche nach bestimmten Szenen mit Zeitstempeln und automatisch generierten Clips. Für die Nachbearbeitung stehen umfangreiche Timeline-Operationen zur Verfügung, darunter das Hinzufügen von Untertiteln, Text- und Bildeinblendungen, Audio-Overlays, Sprachvertonung und Übersetzungen. Live-Überwachungsworkflows werden durch Echtzeit-Events und Alarme unterstützt. Das Skill enthält vollständige Python-Codebeispiele, detaillierte Fehlerbehandlung und Best Practices zur Verwendung der VideoDB SDK, sodass Agenten komplexe Video-Workflows selbstständig ausführen können, ohne auf lokale Tools wie ffmpeg zurückgreifen zu müssen.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/affaan-m/everything-claude-code/videodb

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

VideoDB Skill

Wahrnehmung + Gedächtnis + Aktionen für Video, Live-Streams und Desktop-Sitzungen.

Wann verwenden

Desktop-Wahrnehmung

  • Desktop-Sitzung starten/stoppen, die Bildschirm, Mikrofon und Systemaudio aufnimmt
  • Live-Kontext streamen und episodisches Sitzungsgedächtnis speichern
  • Echtzeit-Alarme/Trigger auf Gesprochenes und Bildschirminhalt ausführen
  • Sitzungszusammenfassungen, eine durchsuchbare Zeitleiste und abspielbare Beweislinks erstellen

Video-Import + Stream

  • Eine Datei oder URL importieren und einen abspielbaren Web-Stream-Link zurückgeben
  • Transkodieren/normalisieren: Codec, Bitrate, FPS, Auflösung, Seitenverhältnis

Index + Suche (Zeitstempel + Beweise)

  • Visuelle, gesprochene und Schlüsselwort-Indizes erstellen
  • Suchen und exakte Momente mit Zeitstempeln und abspielbaren Beweisen zurückgeben
  • Automatisch Clips aus Suchergebnissen erstellen

Zeitleisten-Bearbeitung + Generierung

  • Untertitel: generieren, übersetzen, einbrennen
  • Overlays: Text/Bild/Marken, animierte Untertitel
  • Audio: Hintergrundmusik, Sprachkommentar, Synchronisation
  • Programmgesteuerte Komposition und Exporte über Zeitleisten-Operationen

Live-Streams (RTSP) + Überwachung

  • RTSP/Live-Feeds verbinden
  • Echtzeit-visuelles und gesprochenes Verständnis ausführen und Events/Alarme für Überwachungs-Workflows ausgeben

Funktionsweise

Übliche Eingaben

  • Lokaler Dateipfad, öffentliche URL oder RTSP-URL
  • Desktop-Erfassungsanfrage: Sitzung starten / stoppen / zusammenfassen
  • Gewünschte Operationen: Kontext zum Verständnis abrufen, Transkodierspezifikation, Indexspezifikation, Suchabfrage, Clip-Bereiche, Zeitleisten-Bearbeitungen, Alarmregeln

Übliche Ausgaben

  • Stream-URL
  • Suchergebnisse mit Zeitstempeln und Beweislinks
  • Generierte Assets: Untertitel, Audio, Bilder, Clips
  • Event/Alarm-Payloads für Live-Streams
  • Desktop-Sitzungszusammenfassungen und Gedächtniseinträge

Python-Code ausführen

Bevor Sie einen VideoDB-Code ausführen, wechseln Sie in das Projektverzeichnis und laden Sie die Umgebungsvariablen:

from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()

Dies liest VIDEO_DB_API_KEY aus:

  1. Umgebung (falls bereits exportiert)
  2. .env-Datei des Projekts im aktuellen Verzeichnis

Fehlt der Schlüssel, löst videodb.connect() automatisch einen AuthenticationError aus.

Schreiben Sie KEINE Skriptdatei, wenn ein kurzer Inline-Befehl ausreicht.

Wenn Sie Inline-Python (python -c "...") verwenden, nutzen Sie immer korrekt formatierte Trennstriche (Semikolons) und halten Sie es lesbar. Für Code länger als etwa 3 Anweisungen verwenden Sie stattdessen einen Heredoc:

python << 'EOF'
from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()
coll = conn.get_collection()
print(f"Videos: {len(coll.get_videos())}")
EOF

Einrichtung

Wenn der Benutzer nach "videodb einrichten" oder ähnlichem fragt:

1. SDK installieren

pip install "videodb[capture]" python-dotenv

Wenn videodb[capture] unter Linux fehlschlägt, installieren Sie ohne das capture-Extra:

pip install videodb python-dotenv

2. API-Schlüssel konfigurieren

Der Benutzer muss VIDEO_DB_API_KEY mit einer der folgenden Methoden setzen:

  • Im Terminal exportieren (vor dem Starten von Claude): export VIDEO_DB_API_KEY=ihr-schluessel
  • Projekt-.env-Datei: Speichern Sie VIDEO_DB_API_KEY=ihr-schluessel in der .env-Datei des Projekts

Holen Sie sich einen kostenlosen API-Schlüssel unter console.videodb.io (50 kostenlose Uploads, keine Kreditkarte erforderlich).

Lesen, schreiben oder handhaben Sie den API-Schlüssel NICHT selbst. Überlassen Sie dem Benutzer die Einstellung.

Kurzreferenz

Medien hochladen

# URL
video = coll.upload(url="https://example.com/video.mp4")

# YouTube
video = coll.upload(url="https://www.youtube.com/watch?v=VIDEO_ID")

# Lokale Datei
video = coll.upload(file_path="/pfad/zu/video.mp4")

Transkript + Untertitel

# force=True überspringt den Fehler, falls das Video bereits indiziert ist
video.index_spoken_words(force=True)
text = video.get_transcript_text()
stream_url = video.add_subtitle()

In Videos suchen

from videodb.exceptions import InvalidRequestError

video.index_spoken_words(force=True)

# search() löst InvalidRequestError aus, wenn keine Ergebnisse gefunden werden.
# Immer in try/except einpacken und "Keine Ergebnisse gefunden" als leeres Ergebnis behandeln.
try:
    results = video.search("Produktdemo")
    shots = results.get_shots()
    stream_url = results.compile()
except InvalidRequestError as e:
    if "Keine Ergebnisse gefunden" in str(e):
        shots = []
    else:
        raise

Szenen-Suche

import re
from videodb import SearchType, IndexType, SceneExtractionType
from videodb.exceptions import InvalidRequestError

# index_scenes() hat keinen force-Parameter – es löst einen Fehler aus, wenn ein Szenen-
# Index bereits existiert. Extrahieren Sie die vorhandene Index-ID aus dem Fehler.
try:
    scene_index_id = video.index_scenes(
        extraction_type=SceneExtractionType.shot_based,
        prompt="Beschreiben Sie den visuellen Inhalt dieser Szene.",
    )
except Exception as e:
    match = re.search(r"id\s+([a-f0-9]+)", str(e))
    if match:
        scene_index_id = match.group(1)
    else:
        raise

# score_threshold verwenden, um Rauschen mit geringer Relevanz zu filtern (empfohlen: 0.3 oder höher)
try:
    results = video.search(
        query="Person schreibt auf einem Whiteboard",
        search_type=SearchType.semantic,
        index_type=IndexType.scene,
        scene_index_id=scene_index_id,
        score_threshold=0.3,
    )
    shots = results.get_shots()
    stream_url = results.compile()
except InvalidRequestError as e:
    if "Keine Ergebnisse gefunden" in str(e):
        shots = []
    else:
        raise

Zeitleisten-Bearbeitung

Wichtig: Validiere immer die Zeitstempel, bevor du eine Zeitleiste erstellst:

  • start muss >= 0 sein (negative Werte werden stillschweigend akzeptiert, erzeugen aber fehlerhafte Ausgaben)
  • start muss < end sein
  • end muss <= video.length sein
from videodb.timeline import Timeline
from videodb.asset import VideoAsset, TextAsset, TextStyle

timeline = Timeline(conn)
timeline.add_inline(VideoAsset(asset_id=video.id, start=10, end=30))
timeline.add_overlay(0, TextAsset(text="Das Ende", duration=3, style=TextStyle(fontsize=36)))
stream_url = timeline.generate_stream()

Video transkodieren (Auflösung/Qualität ändern)

from videodb import TranscodeMode, VideoConfig, AudioConfig

# Auflösung, Qualität oder Seitenverhältnis serverseitig ändern
job_id = conn.transcode(
    source="https://example.com/video.mp4",
    callback_url="https://example.com/webhook",
    mode=TranscodeMode.economy,
    video_config=VideoConfig(resolution=720, quality=23, aspect_ratio="16:9"),
    audio_config=AudioConfig(mute=False),
)

Seitenverhältnis anpassen (für soziale Plattformen)

Warnung: reframe() ist eine langsame serverseitige Operation. Bei langen Videos kann es mehrere Minuten dauern und zu Zeitüberschreitungen führen. Best Practices:

  • Beschränken Sie es wenn möglich immer auf ein kurzes Segment mit start/end
  • Bei vollständigen Videos verwenden Sie callback_url für die asynchrone Verarbeitung
  • Schneiden Sie das Video zuerst auf einer Timeline zu, dann passen Sie das kürzere Ergebnis an
from videodb import ReframeMode

# Immer ein kurzes Segment anpassen:
reframed = video.reframe(start=0, end=60, target="vertical", mode=ReframeMode.smart)

# Asynchrones Reframing für vollständige Videos (gibt None zurück, Ergebnis via Webhook):
video.reframe(target="vertical", callback_url="https://example.com/webhook")

# Voreinstellungen: "vertical" (9:16), "square" (1:1), "landscape" (16:9)
reframed = video.reframe(start=0, end=60, target="square")

# Benutzerdefinierte Abmessungen
reframed = video.reframe(start=0, end=60, target={"width": 1280, "height": 720})

Generative Medien

image = coll.generate_image(
    prompt="Ein Sonnenuntergang über Bergen",
    aspect_ratio="16:9",
)

Fehlerbehandlung

from videodb.exceptions import AuthenticationError, InvalidRequestError

try:
    conn = videodb.connect()
except AuthenticationError:
    print("Überprüfen Sie Ihren VIDEO_DB_API_KEY")

try:
    video = coll.upload(url="https://example.com/video.mp4")
except InvalidRequestError as e:
    print(f"Upload fehlgeschlagen: {e}")

Häufige Fallstricke

SzenarioFehlermeldungLösung
Indizieren eines bereits indizierten VideosSpoken word index for video already existsVerwenden Sie video.index_spoken_words(force=True), um zu überspringen, falls bereits indiziert
Szenen-Index existiert bereitsScene index with id XXXX already existsExtrahieren Sie die vorhandene scene_index_id aus dem Fehler mit re.search(r"id\s+([a-f0-9]+)", str(e))
Suche findet keine ÜbereinstimmungenInvalidRequestError: No results foundFangen Sie die Ausnahme ab und behandeln Sie sie als leere Ergebnisse (shots = [])
Reframe-ZeitüberschreitungBlockiert bei langen Videos unbegrenztVerwenden Sie start/end zur Begrenzung des Segments oder übergeben Sie callback_url für asynchrone Verarbeitung
Negative Zeitstempel in TimelineErzeugt stillschweigend fehlerhaften StreamValidieren Sie immer start >= 0, bevor Sie VideoAsset erstellen
generate_video() / create_collection() schlägt fehlOperation not allowed oder maximum limitPlanabhängige Funktionen – informieren Sie den Benutzer über die Planlimits

Beispiele

Kanonische Aufforderungen

  • "Desktop-Erfassung starten und alarmieren, wenn ein Passwortfeld erscheint."
  • "Meine Sitzung aufzeichnen und eine umsetzbare Zusammenfassung erstellen, wenn sie endet."
  • "Diese Datei importieren und einen abspielbaren Stream-Link zurückgeben."
  • "Diesen Ordner indizieren und jede Szene mit Personen finden, Zeitstempel zurückgeben."
  • "Untertitel generieren, einbrennen und leichte Hintergrundmusik hinzufügen."
  • "Diese RTSP-URL verbinden und alarmieren, wenn eine Person die Zone betritt."

Bildschirmaufnahme (Desktop-Erfassung)

Verwenden Sie ws_listener.py, um WebSocket-Ereignisse während Aufnahmesitzungen zu erfassen. Desktop-Erfassung unterstützt nur macOS.

Schnellstart

  1. State-Verzeichnis wählen: STATE_DIR="${VIDEODB_EVENTS_DIR:-$HOME/.local/state/videodb}"
  2. Listener starten: VIDEODB_EVENTS_DIR="$STATE_DIR" python scripts/ws_listener.py --clear "$STATE_DIR" &
  3. WebSocket-ID abrufen: cat "$STATE_DIR/videodb_ws_id"
  4. Aufnahmecode ausführen (siehe reference/capture.md für den vollständigen Workflow)
  5. Ereignisse geschrieben nach: $STATE_DIR/videodb_events.jsonl

Verwenden Sie --clear immer beim Start einer neuen Aufnahme, damit veraltete Transkript- und visuelle Ereignisse nicht in die neue Sitzung gelangen.

Ereignisse abfragen

import json
import os
import time
from pathlib import Path

events_dir = Path(os.environ.get("VIDEODB_EVENTS_DIR", Path.home() / ".local" / "state" / "videodb"))
events_file = events_dir / "videodb_events.jsonl"
events = []

if events_file.exists():
    with events_file.open(encoding="utf-8") as handle:
        for line in handle:
            try:
                events.append(json.loads(line))
            except json.JSONDecodeError:
                continue

transcripts = [e["data"]["text"] for e in events if e.get("channel") == "transcript"]
cutoff = time.time() - 300
recent_visual = [
    e for e in events
    if e.get("channel") == "visual_index" and e["unix_ts"] > cutoff
]

Zusätzliche Dokumentation

Die Referenzdokumentation befindet sich im Verzeichnis reference/ neben dieser SKILL.md-Datei. Verwenden Sie das Glob-Tool, um sie bei Bedarf zu finden.

Verwenden Sie ffmpeg, moviepy oder lokale Codierungswerkzeuge NICHT, wenn VideoDB die Operation unterstützt. Folgende Operationen werden alle serverseitig von VideoDB erledigt: Trimmen, Kombinieren von Clips, Überlagern von Audio oder Musik, Hinzufügen von Untertiteln, Text-/Bildeinblendungen, Transkodieren, Auflösungsänderungen, Seitenverhältnis-Konvertierung, Größenänderung für Plattformanforderungen, Transkription und Mediengenerierung. Verwenden Sie lokale Werkzeuge nur für Operationen, die unter "Einschränkungen" in reference/editor.md aufgeführt sind (Übergänge, Geschwindigkeitsänderungen, Zuschneiden/Zoomen, Farbkorrektur, Lautstärkemischung).

Wann was verwenden

ProblemVideoDB-Lösung
Plattform lehnt Video-Seitenverhältnis oder Auflösung abvideo.reframe() oder conn.transcode() mit VideoConfig
Video für Twitter/Instagram/TikTok zuschneidenvideo.reframe(target="vertical") oder target="square"
Auflösung ändern (z.B. 1080p → 720p)conn.transcode() mit VideoConfig(resolution=720)
Audio/Musik auf Video legenAudioAsset auf einer Timeline
Untertitel hinzufügenvideo.add_subtitle() oder CaptionAsset
Clips kombinieren/trimmenVideoAsset auf einer Timeline
Sprachkommentar, Musik oder Soundeffekte generierencoll.generate_voice(), generate_music(), generate_sound_effect()

Herkunft

Referenzmaterial für dieses Skill wird lokal unter skills/videodb/reference/ abgelegt. Verwenden Sie die lokalen Kopien oben anstatt bei der Ausführung auf externe Repository-Links zuzugreifen.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Next.js 16+ uses App Router with Server Components by default. Client Components are only used when interactivity is needed (hooks, event handlers, browser APIs).

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills