Skill „Video- & Podcast-Digest"
Sende einen Video-/Podcast-Link → erhalte vollständiges Transkript + strukturierte Zusammenfassung
Unterstützte Plattformen
| Plattform | Typ | Untertitel | Whisper-Transkription |
|---|---|---|---|
| YouTube | Video | ✅ | ✅ |
| Bilibili | Video | ✅ | ✅ |
| X/Twitter | Video | ❌ | ✅ |
| Xiaoyuzhou (小宇宙) | Podcast | ❌ | ✅ |
| Apple Podcasts | Podcast | ❌ | ✅ |
| Direkte Links (mp3/mp4/m3u8) | Beliebig | ❌ | ✅ |
Auslöser
Wird automatisch ausgelöst, wenn eine Medien-URL erkannt wird:
- YouTube:
youtube.com,youtu.be - Bilibili:
bilibili.com,b23.tv - X/Twitter:
x.com,twitter.com(Tweets mit Video) - Xiaoyuzhou:
xiaoyuzhoufm.com - Apple Podcasts:
podcasts.apple.com - Direkt:
.mp3,.mp4,.m3u8,.m4a,.webm
Pipeline
Schritt 0: Medientyp erkennen
| URL-Muster | Typ | Pipeline |
|---|---|---|
xiaoyuzhoufm.com/episode/ | Podcast | → Schritt 1b (Xiaoyuzhou) |
podcasts.apple.com | Podcast | → Schritt 1c (Apple) |
bilibili.com, b23.tv | Video | → Schritt 1d (Bilibili-API) |
.mp3, .m4a Direktlink | Audio | → Schritt 2b (direkter Download) |
| Andere | Video | → Schritt 1a (Untertitel-Extraktion) |
Schritt 1a: Video — Untertitel extrahieren
# Temporäre Dateien bereinigen
rm -f /tmp/media_sub*.vtt /tmp/media_audio.mp3 /tmp/media_transcript*.json /tmp/media_segment_*.mp3 2>/dev/null || true
# YouTube (bevorzugt Englisch, Ausweichung Chinesisch)
yt-dlp --skip-download --write-auto-sub --sub-lang "en,zh-Hans" -o "/tmp/media_sub" "VIDEO_URL"
# Bilibili
yt-dlp --skip-download --write-auto-sub --sub-lang "zh-Hans,zh" -o "/tmp/media_sub" "VIDEO_URL"
Prüfen auf Untertitel:
ls /tmp/media_sub*.vtt 2>/dev/null
- Untertitel vorhanden → VTT-Inhalt lesen, zu Schritt 3 springen
- Keine Untertitel → Schritt 2a (Audio herunterladen)
Schritt 1b: Xiaoyuzhou (小宇宙) — Audio-URL extrahieren
# CDN-Direktlink aus __NEXT_DATA__ extrahieren
# Xiaoyuzhou ist eine Next.js SPA, aber das initiale HTML enthält die Audio-URL in __NEXT_DATA__
AUDIO_URL=$(curl -sL -H "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" \
"EPISODE_URL" \
| grep -oE 'https://media\.xyzcdn\.net/[^"]+\.(m4a|mp3)' \
| head -1)
echo "Audio-URL: $AUDIO_URL"
# Audio herunterladen
curl -L -o /tmp/media_audio.mp3 "$AUDIO_URL"
Falls die curl-Extraktion leer ist (selten), Ausweichung: Puppeteer/Browser verwenden, um die gerenderte Seite zu erhalten und zu extrahieren.
→ Schritt 2b (Größe prüfen & transkribieren)
Schritt 1c: Apple Podcasts — via yt-dlp
yt-dlp -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
-o "/tmp/media_audio.%(ext)s" "APPLE_PODCAST_URL"
→ Schritt 2b (Größe prüfen & transkribieren)
Schritt 1d: Bilibili — API Direkter Audiostream
yt-dlp gibt bei Bilibili auch mit Cookies 412 zurück. Verwende stattdessen die Bilibili-API:
# 1. BV-Nummer aus URL extrahieren
BV="BV1xxxxx" # Durch tatsächliche BV-Nummer ersetzen
# 2. Video-Informationen abrufen (Titel, Dauer, CID)
curl -s "https://api.bilibili.com/x/web-interface/view?bvid=$BV" \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
| python3 -c "import json,sys; d=json.load(sys.stdin)['data']; print(f'Titel: {d[\"title\"]}\nDauer: {d[\"duration\"]}s\nCID: {d[\"cid\"]}')"
# 3. Audiostream-URL abrufen
CID=<CID aus vorherigem Schritt>
AUDIO_URL=$(curl -s "https://api.bilibili.com/x/player/playurl?bvid=$BV&cid=$CID&fnval=16&qn=64" \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
| python3 -c "import json,sys; print(json.load(sys.stdin)['data']['dash']['audio'][0]['baseUrl'])")
# 4. Audio herunterladen (Referer-Header erforderlich, sonst 403)
curl -L -o /tmp/media_audio.m4s \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" "$AUDIO_URL"
# 5. In mp3 konvertieren
ffmpeg -y -i /tmp/media_audio.m4s -acodec libmp3lame -q:a 5 /tmp/media_audio.mp3
→ Schritt 2b (Größe prüfen & transkribieren)
Schritt 2a: Video — Audio herunterladen (wenn keine Untertitel)
# YouTube benötigt möglicherweise --cookies-from-browser chrome, um Bot-Erkennung zu umgehen
yt-dlp --cookies-from-browser chrome -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
-o "/tmp/media_audio.%(ext)s" "VIDEO_URL"
Schritt 2b: Audiodateigröße prüfen & segmentieren
FILE_SIZE=$(stat -f%z /tmp/media_audio.* 2>/dev/null || stat -c%s /tmp/media_audio.* 2>/dev/null)
echo "Dateigröße: $FILE_SIZE Bytes"
- ≤ 25 MB (25000000) → Schritt 2c (direkt transkribieren)
- > 25 MB → zuerst aufteilen, dann jedes Segment transkribieren
Große Audiodateien aufteilen (>25 MB):
# Gesamtdauer abrufen
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 /tmp/media_audio.* | head -1)
# In 10-Minuten-Segmente aufteilen (jedes Segment bleibt unter 25 MB)
SEGMENT_SEC=600
SEGMENTS=$(python3 -c "import math; print(math.ceil(float('$DURATION')/$SEGMENT_SEC))")
# Segmente zuschneiden
for i in $(seq 0 $((SEGMENTS-1))); do
START=$((i * SEGMENT_SEC))
ffmpeg -y -i /tmp/media_audio.* -ss $START -t $SEGMENT_SEC -acodec libmp3lame -q:a 5 \
"/tmp/media_segment_${i}.mp3" 2>/dev/null
done
→ Schritt 2c für jedes Segment sequenziell aufrufen (Parallelisierung führt zu Groq 524-Timeout), Ergebnisse verketten
Schritt 2c: Whisper-Transkription
Voraussetzung: Umgebungsvariable GROQ_API_KEY
# API-Schlüssel prüfen
if [ -z "$GROQ_API_KEY" ]; then
echo "❌ GROQ_API_KEY nicht gesetzt. Holen Sie sich einen unter: https://console.groq.com/keys"
exit 1
fi
# Einzelne Datei transkribieren (AUDIO_FILE durch tatsächlichen Pfad ersetzen)
curl -s -X POST "https://api.groq.com/openai/v1/audio/transcriptions" \
-H "Authorization: Bearer $GROQ_API_KEY" \
-H "Content-Type: multipart/form-data" \
-F "file=@AUDIO_FILE" \
-F "model=whisper-large-v3-turbo" \
-F "response_format=verbose_json" \
-F "language=zh" \
> /tmp/media_transcript.json
# Nur Text extrahieren
python3 -c "import json; print(json.load(open('/tmp/media_transcript.json'))['text'])"
Whisper-Modelloptionen:
| Modell | Geschwindigkeit | Genauigkeit | Anwendungsfall |
|---|---|---|---|
whisper-large-v3-turbo | 10x Echtzeit | Hoch | Standardeinstellung |
whisper-large-v3 | 5x Echtzeit | Höchste | Professionelle/verrauschte Inhalte |
Sprachparameter:
- Chinesisch:
language=zh - Englisch:
language=en - Automatische Erkennung: Sprachparameter weglassen
Schritt 3: Strukturierte Zusammenfassung
Ausgabeformat basierend auf Medientyp wählen:
Video (≤20 Min.):
- Überblick (1-2 Sätze)
- Kernpunkte (3-5 Aufzählungspunkte)
- Bemerkenswerte Zitate (sofern vorhanden)
- Aufgaben/Aktionen (falls zutreffend)
Podcast (>20 Min.):
- Überblick (2-3 Sätze: wer worüber gesprochen hat)
- Kapitelzusammenfassung (nach Themen segmentiert, jeweils 2-3 Sätze)
- Kernpunkte (5-8 Aufzählungspunkte)
- Bemerkenswerte Zitate
- Aufgaben/Aktionen (falls zutreffend)
Ausgabeformat
Video
## 📺 Video-Digest
**Titel**: [Video-Titel]
**Dauer**: [x Minuten]
**Sprache**: [Chinesisch/Englisch]
### Überblick
[1-2 Sätze Zusammenfassung]
### Kernpunkte
1. [Punkt 1]
2. [Punkt 2]
...
### Bemerkenswerte Zitate
> "xxx" — [Zeitstempel]
### Aufgaben/Aktionen
- [falls zutreffend]
Podcast
## 🎙️ Podcast-Digest
**Sendung**: [Podcast-Name]
**Episode**: [Episoden-Titel]
**Dauer**: [x Minuten]
**Gäste**: [falls vorhanden]
### Überblick
[2-3 Sätze: wer worüber gesprochen hat, Kernschlussfolgerungen]
### Kapitelzusammenfassung
#### 1. [Thema] (~xx:xx-xx:xx)
[2-3 Sätze Kerninhalt]
#### 2. [Thema] (~xx:xx-xx:xx)
[2-3 Sätze Kerninhalt]
...
### Kernpunkte
1. [Punkt 1]
2. [Punkt 2]
...
### Bemerkenswerte Zitate
> "xxx"
### Aufgaben/Aktionen
- [falls zutreffend]
Fehlerbehandlung
| Situation | Aktion |
|---|---|
| Keine Untertitel + kein GROQ_API_KEY | Benutzer auffordern, API-Schlüssel zu setzen |
| Keine Untertitel + API-Schlüssel vorhanden | Automatische Whisper-Transkription |
| Xiaoyuzhou curl-Extraktion leer | Puppeteer/Browser verwenden, um gerendertes HTML zu erhalten |
| Audio >25 MB | ffmpeg segmentieren (10 Min./Segment), sequenziell transkribieren |
| Podcast >2 Stunden | Benutzer vor Dauer warnen, vor Fortfahren bestätigen lassen |
| Groq 524-Timeout | NICHT parallelisieren — sequenziell transkribieren, 5-8s Pause zwischen Segmenten |
| Groq 429-Ratenlimit | 7200s/Stunde Limit, auf retry-after-Header warten, dann erneut versuchen |
| yt-dlp Bilibili 412 | Stattdessen Bilibili-API verwenden (Schritt 1d) |
| yt-dlp YouTube-Bot-Erkennung | --cookies-from-browser chrome hinzufügen |
| Netzwerk-Timeout | Einmal wiederholen |
| Spotify-Links | Benutzer informieren: nicht unterstützt (DRM-geschützt) |
Groq Whisper-Limits
- Maximal 25 MB pro Anfrage
- Kostenloses Kontingent: 7200 Sekunden Audio/Stunde (gleitendes Fenster), ~20 Stunden/Tag
- Unterstützte Formate: mp3, mp4, mpeg, mpga, m4a, wav, webm
Abhängigkeiten
yt-dlp: Video-Download + Untertitel-Extraktionffmpeg: Audio-Konvertierung + Segmentierungcurl: Xiaoyuzhou Audio-Download, Bilibili-APIGROQ_API_KEY: Whisper-Transkriptions-API (kostenlos unter https://console.groq.com/keys)