Communitygithub.com

ComeOnOliver/skillshub

Voir, comprendre et agir sur la vidéo et l’audio. Ingestion depuis des fichiers locaux, URLs, flux RTSP/ directs ou capture d’écran en direct ; retour de contexte en temps réel et de liens de flux lisibles. Compréhension : extraire des images, construire des index visuels, sémantiques et temporels, et rechercher des moments avec horodatages et extraits automatiques. Action : transcoder et normaliser (codec, fps, résolution, rapport hauteur/largeur), effectuer des montages temporels (sous-titres, incrustations de texte/images, branding, incrustations audio, doublage, traduction), générer des contenus multimédia (image, audio, vidéo) et créer des alertes en temps réel pour des événements issus de flux en direct ou de capture d’écran.

Qu'est-ce que skillshub ?

Cette compétence VideoDB offre une suite complète de perception, mémoire et actions pour la vidéo, les flux en direct et les sessions de bureau. Elle permet d'ingérer des vidéos depuis des fichiers locaux, des URLs ou des flux RTSP, de retourner des liens de flux lisibles et de construire des index visuels, sémantiques et temporels pour rechercher des moments précis avec horodatages et extraits. Elle prend également en charge le transcodage, le montage temporel (sous-titres, incrustations, doublage) et la génération de nouveaux contenus (images, audio, vidéo). Pour les sessions de bureau, elle peut capturer l'écran, le micro et l'audio système, diffuser le contexte en direct, stocker la mémoire épisodique et déclencher des alertes en temps réel. La compétence s'appuie sur le SDK Python VideoDB, qui gère la plupart des opérations côté serveur, évitant ainsi l'utilisation d'outils locaux comme ffmpeg sauf en cas de limitations documentées. Elle est conçue pour les développeurs et les utilisateurs d'agents IA qui ont besoin de traiter, analyser et agir sur des contenus vidéo et audio de manière automatisée.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence VideoDB

Perception + mémoire + actions pour la vidéo, les flux en direct et les sessions de bureau.

Quand utiliser

Perception de bureau

  • Démarrer/arrêter une session de bureau capturant l'écran, le micro et l'audio système
  • Diffuser le contexte en direct et stocker la mémoire de session épisodique
  • Exécuter des alertes/déclencheurs en temps réel sur ce qui est dit et ce qui se passe à l'écran
  • Produire des résumés de session, une chronologie consultable et des liens de preuve lisibles

Ingestion vidéo + diffusion

  • Ingérer un fichier ou une URL et retourner un lien de flux web lisible
  • Transcoder/normaliser : codec, débit, fps, résolution, rapport hauteur/largeur

Indexation + recherche (horodatages + preuves)

  • Construire des index visuels, vocaux et par mots-clés
  • Rechercher et retourner des moments précis avec horodatages et preuves lisibles
  • Créer automatiquement des extraits à partir des résultats de recherche

Montage temporel + génération

  • Sous-titres : générer, traduire, incruster
  • Incrustations : texte/image/branding, légendes animées
  • Audio : musique de fond, voix off, doublage
  • Composition programmatique et exportations via opérations de chronologie

Flux en direct (RTSP) + surveillance

  • Connecter des flux RTSP/en direct
  • Exécuter une compréhension visuelle et vocale en temps réel et émettre des événements/alertes pour les workflows de surveillance

Comment ça fonctionne

Entrées courantes

  • Chemin de fichier local, URL publique ou URL RTSP
  • Demande de capture de bureau : démarrer / arrêter / résumer une session
  • Opérations souhaitées : obtenir le contexte pour la compréhension, spécification de transcodage, spécification d'index, requête de recherche, plages d'extraits, montages temporels, règles d'alerte

Sorties courantes

  • URL de flux
  • Résultats de recherche avec horodatages et liens de preuve
  • Contenus générés : sous-titres, audio, images, extraits
  • Charges utiles d'événements/alertes pour les flux en direct
  • Résumés de session de bureau et entrées de mémoire

Exécution de code Python

Avant d'exécuter du code VideoDB, placez-vous dans le répertoire du projet et chargez les variables d'environnement :

from dotenv import load_dotenv
load_dotenv(".env")

import videodb
conn = videodb.connect()

Ceci lit VIDEO_DB_API_KEY depuis :

  1. L'environnement (si déjà exporté)
  2. Le fichier .env du projet dans le répertoire courant

Si la clé est manquante, videodb.connect() lève automatiquement AuthenticationError.

N'écrivez PAS un fichier de script lorsqu'une courte commande en ligne suffit.

Lorsque vous écrivez du Python en ligne (python -c "..."), utilisez toujours un code correctement formaté — utilisez des points-virgules pour séparer les instructions et restez lisible. Pour tout ce qui dépasse environ 3 instructions, utilisez plutôt un 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

Configuration

Lorsque l'utilisateur demande de "configurer videodb" ou similaire :

1. Installer le SDK

pip install "videodb[capture]" python-dotenv

Si videodb[capture] échoue sur Linux, installez sans l'extension capture :

pip install videodb python-dotenv

2. Configurer la clé API

L'utilisateur doit définir VIDEO_DB_API_KEY en utilisant l'une ou l'autre des méthodes :

  • Exporter dans le terminal (avant de démarrer Claude) : export VIDEO_DB_API_KEY=ma-clé
  • Fichier .env du projet : Enregistrez VIDEO_DB_API_KEY=ma-clé dans le fichier .env du projet

Obtenez une clé API gratuite sur console.videodb.io (50 téléversements gratuits, pas de carte de crédit).

Ne lisez PAS, n'écrivez PAS et ne gérez PAS vous-même la clé API. Laissez toujours l'utilisateur la définir.

Référence rapide

Téléverser un média

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

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

# Fichier local
video = coll.upload(file_path="/chemin/vers/video.mp4")

Transcription + sous-titres

# force=True ignore l'erreur si la vidéo est déjà indexée
video.index_spoken_words(force=True)
texte = video.get_transcript_text()
url_flux = video.add_subtitle()

Rechercher dans des vidéos

from videodb.exceptions import InvalidRequestError

video.index_spoken_words(force=True)

# search() lève InvalidRequestError quand aucun résultat n'est trouvé.
# Toujours envelopper dans try/except et traiter "No results found" comme vide.
try:
    resultats = video.search("démo produit")
    plans = resultats.get_shots()
    url_flux = resultats.compile()
except InvalidRequestError as e:
    if "No results found" in str(e):
        plans = []
    else:
        raise

Recherche par scène

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

# index_scenes() n'a pas de paramètre force — il lève une erreur si un index
# de scène existe déjà. Extrayez l'ID d'index existant de l'erreur.
try:
    id_index_scene = video.index_scenes(
        extraction_type=SceneExtractionType.shot_based,
        prompt="Décrivez le contenu visuel de cette scène.",
    )
except Exception as e:
    correspondance = re.search(r"id\s+([a-f0-9]+)", str(e))
    if correspondance:
        id_index_scene = correspondance.group(1)
    else:
        raise

# Utilisez score_threshold pour filtrer le bruit de faible pertinence (recommandé : 0.3+)
try:
    resultats = video.search(
        query="personne écrivant sur un tableau blanc",
        search_type=SearchType.semantic,
        index_type=IndexType.scene,
        scene_index_id=id_index_scene,
        score_threshold=0.3,
    )
    plans = resultats.get_shots()
    url_flux = resultats.compile()
except InvalidRequestError as e:
    if "No results found" in str(e):
        plans = []
    else:
        raise

Montage temporel

Important : validez toujours les horodatages avant de construire une chronologie :

  • start doit être >= 0 (les valeurs négatives sont acceptées silencieusement mais produisent un résultat cassé)
  • start doit être < end
  • end doit être <= video.length
from videodb.timeline import Timeline
from videodb.asset import VideoAsset, TextAsset, TextStyle

chronologie = Timeline(conn)
chronologie.add_inline(VideoAsset(asset_id=video.id, start=10, end=30))
chronologie.add_overlay(0, TextAsset(text="La Fin", duration=3, style=TextStyle(fontsize=36)))
url_flux = chronologie.generate_stream()

Transcodage vidéo (changement de résolution/qualité)

from videodb import TranscodeMode, VideoConfig, AudioConfig

# Modifier la résolution, la qualité ou le rapport hauteur/largeur côté serveur
id_tache = 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),
)

Recadrer le rapport hauteur/largeur (pour les réseaux sociaux)

Attention : reframe() est une opération lente côté serveur. Pour les vidéos longues, elle peut prendre plusieurs minutes et expirer. Bonnes pratiques :

  • Limitez toujours à un court segment avec start/end lorsque c'est possible
  • Pour les vidéos de pleine durée, utilisez callback_url pour un traitement asynchrone
  • Rognez d'abord la vidéo sur une Timeline, puis recadrez le résultat plus court
from videodb import ReframeMode

# Préférez toujours recadrer un court segment :
recadree = video.reframe(start=0, end=60, target="vertical", mode=ReframeMode.smart)

# Recadrage asynchrone pour les vidéos de pleine durée (retourne None, résultat via webhook) :
video.reframe(target="vertical", callback_url="https://example.com/webhook")

# Préréglages : "vertical" (9:16), "square" (1:1), "landscape" (16:9)
recadree = video.reframe(start=0, end=60, target="square")

# Dimensions personnalisées
recadree = video.reframe(start=0, end=60, target={"width": 1280, "height": 720})

Média génératif

image = coll.generate_image(
    prompt="un coucher de soleil sur des montagnes",
    aspect_ratio="16:9",
)

Gestion des erreurs

from videodb.exceptions import AuthenticationError, InvalidRequestError

try:
    conn = videodb.connect()
except AuthenticationError:
    print("Vérifiez votre VIDEO_DB_API_KEY")

try:
    video = coll.upload(url="https://example.com/video.mp4")
except InvalidRequestError as e:
    print(f"Échec du téléversement : {e}")

Pièges courants

ScénarioMessage d'erreurSolution
Indexation d'une vidéo déjà indexéeSpoken word index for video already existsUtilisez video.index_spoken_words(force=True) pour ignorer si déjà indexé
Index de scène déjà existantScene index with id XXXX already existsExtrayez l'scene_index_id existant de l'erreur avec re.search(r"id\s+([a-f0-9]+)", str(e))
La recherche ne trouve aucune correspondanceInvalidRequestError: No results foundAttrapez l'exception et traitez comme des résultats vides (plans = [])
Recadrage expiréBloque indéfiniment sur les vidéos longuesUtilisez start/end pour limiter le segment, ou passez callback_url pour l'asynchrone
Horodatages négatifs sur la chronologieProduit silencieusement un flux casséValidez toujours start >= 0 avant de créer VideoAsset
generate_video() / create_collection() échoueOperation not allowed ou maximum limitFonctionnalités limitées par le plan — informez l'utilisateur des limites du plan

Exemples

Invites canoniques

  • "Démarrer la capture de bureau et alerter lorsqu'un champ de mot de passe apparaît."
  • "Enregistrer ma session et produire un résumé exploitable à la fin."
  • "Ingérer ce fichier et retourner un lien de flux lisible."
  • "Indexer ce dossier et trouver chaque scène avec des personnes, retourner les horodatages."
  • "Générer des sous-titres, les incruster, et ajouter une musique de fond légère."
  • "Connecter cette URL RTSP et alerter lorsqu'une personne entre dans la zone."

Enregistrement d'écran (capture de bureau)

Utilisez ws_listener.py pour capturer les événements WebSocket pendant les sessions d'enregistrement. La capture de bureau prend en charge macOS uniquement.

Démarrage rapide

  1. Choisissez le répertoire d'état : STATE_DIR="${VIDEODB_EVENTS_DIR:-$HOME/.local/state/videodb}"
  2. Démarrez l'écouteur : VIDEODB_EVENTS_DIR="$STATE_DIR" python scripts/ws_listener.py --clear "$STATE_DIR" &
  3. Obtenez l'ID WebSocket : cat "$STATE_DIR/videodb_ws_id"
  4. Exécutez le code de capture (voir reference/capture.md pour le workflow complet)
  5. Événements écrits dans : $STATE_DIR/videodb_events.jsonl

Utilisez --clear chaque fois que vous démarrez une nouvelle session de capture afin que les événements de transcription et visuels obsolètes ne fuient pas dans la nouvelle session.

Interroger les événements

import json
import os
import time
from pathlib import Path

repertoire_evenements = Path(os.environ.get("VIDEODB_EVENTS_DIR", Path.home() / ".local" / "state" / "videodb"))
fichier_evenements = repertoire_evenements / "videodb_events.jsonl"
evenements = []

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

transcriptions = [e["data"]["text"] for e in evenements if e.get("channel") == "transcript"]
seuil = time.time() - 300
recent_visuel = [
    e for e in evenements
    if e.get("channel") == "visual_index" and e["unix_ts"] > seuil
]

Documentation supplémentaire

La documentation de référence se trouve dans le répertoire reference/ adjacent à ce fichier SKILL.md. Utilisez l'outil Glob pour le localiser si nécessaire.

N'utilisez pas ffmpeg, moviepy ou des outils d'encodage locaux lorsque VideoDB prend en charge l'opération. Les opérations suivantes sont toutes gérées côté serveur par VideoDB — rognage, combinaison d'extraits, incrustation audio ou musicale, ajout de sous-titres, incrustations texte/image, transcodage, changements de résolution, conversion de rapport hauteur/largeur, redimensionnement pour les exigences de plateforme, transcription et génération de médias. Revenez aux outils locaux uniquement pour les opérations listées dans Limitations dans reference/editor.md (transitions, changements de vitesse, recadrage/zoom, étalonnage des couleurs, mixage de volume).

Quand utiliser quoi

ProblèmeSolution VideoDB
La plateforme rejette le rapport hauteur/largeur ou la résolution de la vidéovideo.reframe() ou conn.transcode() avec VideoConfig
Besoin de redimensionner une vidéo pour Twitter/Instagram/TikTokvideo.reframe(target="vertical") ou target="square"
Besoin de changer la résolution (ex. 1080p → 720p)conn.transcode() avec VideoConfig(resolution=720)
Besoin d'incruster de l'audio/de la musique sur une vidéoAudioAsset sur une Timeline
Besoin d'ajouter des sous-titresvideo.add_subtitle() ou CaptionAsset
Besoin de combiner/rogner des extraitsVideoAsset sur une Timeline
Besoin de générer une voix off, de la musique ou des effets sonorescoll.generate_voice(), generate_music(), generate_sound_effect()

Provenance

Le matériel de référence de cette compétence est fourni localement sous skills/videodb/reference/. Utilisez les copies locales ci-dessus au lieu de suivre des liens de dépôt externes au moment de l'exécution.

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

Skills associés