Communitygithub.com

runesleo/x-reader

Transkribieren und zusammenfassen von Video- oder Podcast-Links, einschließlich YouTube, Bilibili, X-Video, Xiaoyuzhou, Apple Podcasts und direkten Medien-URLs.

Was ist x-reader?

Diese Fähigkeit ermöglicht es einem KI-Agenten, einen Medienlink (Video oder Podcast) zu empfangen und automatisch eine vollständige Transkription sowie eine strukturierte Zusammenfassung zu erstellen. Sie unterstützt eine Vielzahl von Plattformen, darunter YouTube, Bilibili, X/Twitter, Xiaoyuzhou (小宇宙) und Apple Podcasts sowie direkte Links zu Audio- und Videodateien. Die Pipeline beginnt mit der Erkennung des Medientyps und extrahiert entweder vorhandene Untertitel oder lädt das Audio herunter. Falls keine Untertitel verfügbar sind, wird die Groq-Whisper-API zur Transkription verwendet. Bei großen Audiodateien (>25 MB) wird die Datei automatisch segmentiert. Abschließend wird eine Zusammenfassung im strukturierten Markdown-Format erstellt, die je nach Medientyp (Video oder Podcast) variiert. Die Fähigkeit ist plattformunabhängig und nutzt gängige Tools wie yt-dlp, ffmpeg und curl.

Funktioniert mit~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/runesleo/x-reader/tree/HEAD/skills/video

In Ihrer bevorzugten KI fragen

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

Dokumentation

Skill „Video- & Podcast-Digest"

Sende einen Video-/Podcast-Link → erhalte vollständiges Transkript + strukturierte Zusammenfassung

Unterstützte Plattformen

PlattformTypUntertitelWhisper-Transkription
YouTubeVideo✅✅
BilibiliVideo✅✅
X/TwitterVideo❌✅
Xiaoyuzhou (小宇宙)Podcast❌✅
Apple PodcastsPodcast❌✅
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-MusterTypPipeline
xiaoyuzhoufm.com/episode/Podcast→ Schritt 1b (Xiaoyuzhou)
podcasts.apple.comPodcast→ Schritt 1c (Apple)
bilibili.com, b23.tvVideo→ Schritt 1d (Bilibili-API)
.mp3, .m4a DirektlinkAudio→ Schritt 2b (direkter Download)
AndereVideo→ 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:

ModellGeschwindigkeitGenauigkeitAnwendungsfall
whisper-large-v3-turbo10x EchtzeitHochStandardeinstellung
whisper-large-v35x EchtzeitHöchsteProfessionelle/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.):

  1. Überblick (1-2 Sätze)
  2. Kernpunkte (3-5 Aufzählungspunkte)
  3. Bemerkenswerte Zitate (sofern vorhanden)
  4. Aufgaben/Aktionen (falls zutreffend)

Podcast (>20 Min.):

  1. Überblick (2-3 Sätze: wer worüber gesprochen hat)
  2. Kapitelzusammenfassung (nach Themen segmentiert, jeweils 2-3 Sätze)
  3. Kernpunkte (5-8 Aufzählungspunkte)
  4. Bemerkenswerte Zitate
  5. 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

SituationAktion
Keine Untertitel + kein GROQ_API_KEYBenutzer auffordern, API-Schlüssel zu setzen
Keine Untertitel + API-Schlüssel vorhandenAutomatische Whisper-Transkription
Xiaoyuzhou curl-Extraktion leerPuppeteer/Browser verwenden, um gerendertes HTML zu erhalten
Audio >25 MBffmpeg segmentieren (10 Min./Segment), sequenziell transkribieren
Podcast >2 StundenBenutzer vor Dauer warnen, vor Fortfahren bestätigen lassen
Groq 524-TimeoutNICHT parallelisieren — sequenziell transkribieren, 5-8s Pause zwischen Segmenten
Groq 429-Ratenlimit7200s/Stunde Limit, auf retry-after-Header warten, dann erneut versuchen
yt-dlp Bilibili 412Stattdessen Bilibili-API verwenden (Schritt 1d)
yt-dlp YouTube-Bot-Erkennung--cookies-from-browser chrome hinzufügen
Netzwerk-TimeoutEinmal wiederholen
Spotify-LinksBenutzer 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-Extraktion
  • ffmpeg: Audio-Konvertierung + Segmentierung
  • curl: Xiaoyuzhou Audio-Download, Bilibili-API
  • GROQ_API_KEY: Whisper-Transkriptions-API (kostenlos unter https://console.groq.com/keys)

Verwandte Skills