Communitygithub.com

BEKO2210/Firstbrain

Video- und Audio-Wahrnehmung, Indexierung und Bearbeitung. Erfasse Dateien/URLs/Livestreams, erstelle visuelle und gesprochene Indizes, durchsuche mit Zeitstempeln, bearbeite Timelines, füge Overlays/Untertitel hinzu, generiere Medien und erstelle Echtzeit-Benachrichtigungen.

Was ist Firstbrain?

Dieses Skill ermöglicht es KI-Agenten, Video- und Audioinhalte aus verschiedenen Quellen (Dateien, URLs, Desktop-Sessions, Livestreams) zu erfassen, zu verstehen, zu indizieren, zu durchsuchen und zu bearbeiten. Es ist besonders nützlich für Aufgaben wie das Erstellen von Desktop-Aufzeichnungen durchsuchbaren Gedächtnisses, das Indizieren von Videoinhalten (visuell & gesprochen), das Suchen mit exakten Zeitstempeln, das automatische Erstellen von Clips, das Hinzufügen von Untertiteln und Overlays sowie das Generieren von Medien (Bilder, Ton). Das Skill unterstützt Echtzeit-Überwachung von Livestreams mit benutzerdefinierten Auslösern und Alarmschwellen. Plattformübergreifend einsetzbar, erfordert es einen gültigen VideoDB-API-Schlüssel und nutzt das VideoDB-Python-SDK für serverseitige Operationen. Der Agent sollte immer die VideoDB-Lösung bevorzugen gegenüber lokalen Tools wie ffmpeg, außer bei ausdrücklich dokumentierten Einschränkungen.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/BEKO2210/Firstbrain/tree/HEAD/03%20-%20Resources/Skills/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, Livestreams und Desktop-Sessions.

Verwende dieses Skill, wenn du Folgendes benötigst:

Wann verwenden

  • Du benötigst Video- oder Audio-Wahrnehmung, Indexierung, Suche oder Timeline-Bearbeitung von Dateien, URLs, Desktop-Sessions oder Livestreams.
  • Die Aufgabe beinhaltet Zeitstempel, durchsuchbare Beweise, Untertitel, Clips, Overlays oder Echtzeit-Überwachungsalarme.
  • Du möchtest einen Workflow, der Erfassung, Verständnis, Abruf und Medienaktionen kombiniert.

1) Desktop-Wahrnehmung

  • Starte/Stoppe eine Desktop-Session, die Bildschirm, Mikrofon und Systemaudio erfasst
  • Streame Live-Kontext und speichere episodisches Session-Gedächtnis
  • Führe Echtzeit-Alarme/Trigger auf dem Gesprochenen und dem, was auf dem Bildschirm passiert, aus
  • Erstelle Session-Zusammenfassungen, eine durchsuchbare Timeline und abspielbare Beweislinks

2) Videoerfassung + Stream

  • Erfasse eine Datei oder URL und gib einen abspielbaren Web-Stream-Link zurück
  • Transkodiere/normalisiere: Codec, Bitrate, fps, Auflösung, Seitenverhältnis

3) Indexieren + Suchen (Zeitstempel + Beweise)

  • Erstelle visuelle, gesprochene und Schlüsselwort-Indizes
  • Suche und gib genaue Momente mit Zeitstempeln und abspielbaren Beweisen zurück
  • Erstelle automatisch Clips aus Suchergebnissen

4) Timeline-Bearbeitung + Generierung

  • Untertitel: generieren, übersetzen, einbrennen
  • Overlays: Text/Bild/Branding, Bewegungsuntertitel
  • Audio: Hintergrundmusik, Voiceover, Synchronisation
  • Programmatische Komposition und Exporte via Timeline-Operationen

5) Livestreams (RTSP) + Überwachung

  • Verbinde RTSP/Live-Feeds
  • Führe Echtzeit-visuelles und gesprochenes Verständnis durch und sende Events/Alarme für Überwachungs-Workflows

Häufige Eingaben

  • Lokaler Dateipfad, öffentliche URL oder RTSP-URL
  • Desktop-Erfassungsanfrage: Session starten / stoppen / zusammenfassen
  • Gewünschte Operationen: Kontext für Verständnis abrufen, Transcode-Spezifikation, Index-Spezifikation, Suchanfrage, Clip-Bereiche, Timeline-Bearbeitungen, Alarmregeln

Häufige Ausgaben

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

Kanonische Eingabeaufforderungen (Beispiele)

  • "Starte Desktop-Erfassung und alarmiere, wenn ein Passwortfeld erscheint."
  • "Zeichne meine Session auf und erstelle eine umsetzbare Zusammenfassung, wenn sie endet."
  • "Erfasse diese Datei und gib einen abspielbaren Stream-Link zurück."
  • "Indiziere diesen Ordner und finde jede Szene mit Personen, gib Zeitstempel zurück."
  • "Generiere Untertitel, brenne sie ein und füge leichte Hintergrundmusik hinzu."
  • "Verbinde diese RTSP-URL und alarmiere, wenn eine Person den Bereich betritt."

Python-Code ausführen

Bevor du VideoDB-Code ausführst, wechsle in das Projektverzeichnis und lade 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

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

Schreibe KEINE Skriptdatei, wenn ein kurzer Inline-Befehl ausreicht.

Wenn du Inline-Python schreibst (python -c "..."), verwende immer korrekt formatierten Code — verwende Semikolons, um Anweisungen zu trennen, und halte es lesbar. Für alles länger als ~3 Anweisungen verwende 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, installiere 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 Start von Claude): export VIDEO_DB_API_KEY=dein-schlüssel
  • Projekt .env-Datei: Speichere VIDEO_DB_API_KEY=dein-schlüssel in der .env-Datei des Projekts

Hole einen kostenlosen API-Schlüssel unter https://console.videodb.io (50 kostenlose Uploads, keine Kreditkarte erforderlich).

Lese, schreibe oder verwalte den API-Schlüssel NICHT selbst. Überlasse es immer dem Benutzer, ihn zu setzen.

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="/path/to/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 einwickeln 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 "No results found" in str(e):
        shots = []
    else:
        raise

Szenensuche

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 Szenenindex
# bereits existiert. Extrahiere die vorhandene Index-ID aus dem Fehler.
try:
    scene_index_id = video.index_scenes(
        extraction_type=SceneExtractionType.shot_based,
        prompt="Beschreibe 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

# Verwende score_threshold, um irrelevantes Rauschen zu filtern (empfohlen: 0,3+)
try:
    results = video.search(
        query="Person, die auf ein Whiteboard schreibt",
        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 "No results found" in str(e):
        shots = []
    else:
        raise

Timeline-Bearbeitung

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

  • start muss >= 0 sein (negative Werte werden stillschweigend akzeptiert, erzeugen aber defekte 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

# Ändere Auflösung, Qualität oder Seitenverhältnis serverseitig
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 möglicherweise eine Zeitüberschreitung verursachen. Best Practices:

  • Beschränke es nach Möglichkeit immer auf ein kurzes Segment mit start/end
  • Verwende für vollständige Videos callback_url für asynchrone Verarbeitung
  • Schneide das Video zuerst auf einer Timeline zu, dann passe das kürzere Ergebnis an
from videodb import ReframeMode

# Bevorzuge immer die Anpassung eines kurzen Segments:
reframed = video.reframe(start=0, end=60, target="vertical", mode=ReframeMode.smart)

# Asynchrone Anpassung 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 den Bergen",
    aspect_ratio="16:9",
)

Fehlerbehandlung

from videodb.exceptions import AuthenticationError, InvalidRequestError

try:
    conn = videodb.connect()
except AuthenticationError:
    print("Überprüfe deinen 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
Indexierung eines bereits indizierten VideosSpoken word index for video already existsVerwende video.index_spoken_words(force=True), um zu überspringen, falls bereits indiziert
Szenenindex existiert bereitsScene index with id XXXX already existsExtrahiere 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 foundFange die Ausnahme ab und behandle sie als leere Ergebnisse (shots = [])
Anpassung läuft zeitlich ausBlockiert bei langen Videos auf unbestimmte ZeitVerwende start/end, um das Segment zu begrenzen, oder übergib callback_url für asynchrone Verarbeitung
Negative Zeitstempel in der TimelineErzeugt stillschweigend einen defekten StreamValidiere immer start >= 0, bevor du VideoAsset erstellst
generate_video() / create_collection() schlägt fehlOperation not allowed oder maximum limitPlanabhängige Funktionen — informiere den Benutzer über Planlimits

Zusätzliche Dokumentation

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

Bildschirmaufnahme (Desktop-Erfassung)

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

Schnellstart

  1. Listener starten: python scripts/ws_listener.py &
  2. WebSocket-ID abrufen: cat /tmp/videodb_ws_id
  3. Erfassungscode ausführen (siehe reference/capture.md für den vollständigen Workflow)
  4. Ereignisse geschrieben nach: /tmp/videodb_events.jsonl

Ereignisse abfragen

import json
events = [json.loads(l) for l in open("/tmp/videodb_events.jsonl")]

# Alle Transkripte abrufen
transcripts = [e["data"]["text"] for e in events if e.get("channel") == "transcript"]

# Visuelle Beschreibungen der letzten 5 Minuten abrufen
import time
cutoff = time.time() - 300
recent_visual = [e for e in events 
                 if e.get("channel") == "visual_index" and e["unix_ts"] > cutoff]

Dienstprogramm-Skripte

Den vollständigen Erfassungs-Workflow findest du unter reference/capture.md.

Verwende keine ffmpeg-, moviepy- oder lokalen Codierungswerkzeuge, wenn VideoDB die Operation unterstützt. Folgendes wird alles serverseitig von VideoDB verarbeitet — Trimmen, Kombinieren von Clips, Überlagern von Audio oder Musik, Hinzufügen von Untertiteln, Text-/Bildoverlays, Transcodierung, Auflösungsänderungen, Seitenverhältnis-Konvertierung, Größenänderung für Plattformanforderungen, Transkription und Mediengenerierung. Verwende 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 verwende ich was

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

Repository

https://github.com/video-db/skills

Verwaltet von: VideoDB

Verbindungen

  • Domäne: [[Design & Kreativitaet]]
  • Kategorie: [[Video & Audio Produktion]]
  • Dateien:
    • scripts/ws_listener.py
  • Navigation: [[Skills Uebersicht]], [[Home]]

Individual skills in this repo

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

BEKO2210/Firstbrain

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

BEKO2210/Firstbrain

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

BEKO2210/Firstbrain

One sentence - what this skill does and when to invoke it

BEKO2210/Firstbrain

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

BEKO2210/Firstbrain

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

BEKO2210/Firstbrain

Expert in building portfolios that actually land jobs and clients -

BEKO2210/Firstbrain

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

BEKO2210/Firstbrain

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

BEKO2210/Firstbrain

Best practices for Remotion - Video creation in React

BEKO2210/Firstbrain

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

BEKO2210/Firstbrain

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

BEKO2210/Firstbrain

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

BEKO2210/Firstbrain

Three.js animation - keyframe animation, skeletal animation, morph targets, animation mixing. Use when animating objects, playing GLTF animations, creating procedural motion, or blending animations.

BEKO2210/Firstbrain

Automate TikTok tasks via Rube MCP (Composio): upload/publish videos, post photos, manage content, and view user profiles/stats. Always search tools first for current schemas.

BEKO2210/Firstbrain

Upload, stream, search, edit, transcribe, and generate AI video and audio using the VideoDB SDK.

BEKO2210/Firstbrain

One sentence - what this skill does and when to invoke it

BEKO2210/Firstbrain

Automate YouTube tasks via Rube MCP (Composio): upload videos, manage playlists, search content, get analytics, and handle comments. Always search tools first for current schemas.

BEKO2210/Firstbrain

Extract transcripts from YouTube videos and generate comprehensive, detailed summaries using intelligent analysis frameworks

Verwandte Skills