Compétence de Résumé Vidéo & Podcast
Envoyez un lien vidéo/podcast → obtenez la transcription complète + un résumé structuré.
Plateformes Prises en Charge
| Plateforme | Type | Sous-titres | Transcription Whisper |
|---|---|---|---|
| YouTube | Vidéo | ✅ | ✅ |
| Bilibili | Vidéo | ✅ | ✅ |
| X/Twitter | Vidéo | ❌ | ✅ |
| Xiaoyuzhou (小宇宙) | Podcast | ❌ | ✅ |
| Apple Podcasts | Podcast | ❌ | ✅ |
| Liens directs (mp3/mp4/m3u8) | Quelconque | ❌ | ✅ |
Déclencheur
Déclenché automatiquement lorsqu'une URL média est détectée :
- YouTube :
youtube.com,youtu.be - Bilibili :
bilibili.com,b23.tv - X/Twitter :
x.com,twitter.com(tweets avec vidéo) - Xiaoyuzhou :
xiaoyuzhoufm.com - Apple Podcasts :
podcasts.apple.com - Direct :
.mp3,.mp4,.m3u8,.m4a,.webm
Pipeline
Étape 0 : Détection du Type de Média
| Motif URL | Type | Pipeline |
|---|---|---|
xiaoyuzhoufm.com/episode/ | Podcast | → Étape 1b (Xiaoyuzhou) |
podcasts.apple.com | Podcast | → Étape 1c (Apple) |
bilibili.com, b23.tv | Vidéo | → Étape 1d (API Bilibili) |
.mp3, .m4a lien direct | Audio | → Étape 2b (téléchargement direct) |
| Autre | Vidéo | → Étape 1a (extraction de sous-titres) |
Étape 1a : Vidéo — Extraire les Sous-titres
# Nettoyer les fichiers temporaires
rm -f /tmp/media_sub*.vtt /tmp/media_audio.mp3 /tmp/media_transcript*.json /tmp/media_segment_*.mp3 2>/dev/null || true
# YouTube (préférer anglais, fallback chinois)
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"
Vérification des sous-titres :
ls /tmp/media_sub*.vtt 2>/dev/null
- A des sous-titres → Lire le contenu VTT, passer à l'Étape 3
- Pas de sous-titres → Étape 2a (télécharger l'audio)
Étape 1b : Xiaoyuzhou (小宇宙) — Extraire l'URL Audio
# Extraire le lien CDN direct depuis __NEXT_DATA__
# Xiaoyuzhou est une SPA Next.js, mais le HTML initial contient l'URL audio dans __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 "URL Audio : $AUDIO_URL"
# Télécharger l'audio
curl -L -o /tmp/media_audio.mp3 "$AUDIO_URL"
Si l'extraction par curl est vide (rare), solution de repli : utiliser Puppeteer/navigateur pour obtenir la page rendue et extraire.
→ Étape 2b (vérifier la taille et transcrire)
Étape 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"
→ Étape 2b (vérifier la taille et transcrire)
Étape 1d : Bilibili — Flux Audio Direct via API
yt-dlp renvoie 412 pour Bilibili même avec des cookies. Utilisez plutôt l'API de Bilibili :
# 1. Extraire le numéro BV de l'URL
BV="BV1xxxxx" # Remplacer par le vrai numéro BV
# 2. Obtenir les infos vidéo (titre, durée, 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\"Titre: {d['title']}\nDurée: {d['duration']}s\nCID: {d['cid']}\")"
# 3. Obtenir l'URL du flux audio
CID=<CID de l'étape précédente>
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. Télécharger l'audio (l'en-tête Referer est requis, sinon 403)
curl -L -o /tmp/media_audio.m4s \
-H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" "$AUDIO_URL"
# 5. Convertir en mp3
ffmpeg -y -i /tmp/media_audio.m4s -acodec libmp3lame -q:a 5 /tmp/media_audio.mp3
→ Étape 2b (vérifier la taille et transcrire)
Étape 2a : Vidéo — Télécharger l'Audio (quand pas de sous-titres)
# YouTube peut nécessiter --cookies-from-browser chrome pour contourner la détection de bot
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"
Étape 2b : Vérifier la Taille Audio et Segmenter
FILE_SIZE=$(stat -f%z /tmp/media_audio.* 2>/dev/null || stat -c%s /tmp/media_audio.* 2>/dev/null)
echo "Taille du fichier : $FILE_SIZE octets"
- ≤ 25 Mo (25000000) → Étape 2c (transcrire directement)
- > 25 Mo → Segmenter d'abord, puis transcrire chaque segment
Segmentation d'audio volumineux (>25 Mo) :
# Obtenir la durée totale
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 /tmp/media_audio.* | head -1)
# Segmenter en morceaux de 10 minutes (chacun reste sous 25 Mo)
SEGMENT_SEC=600
SEGMENTS=$(python3 -c "import math; print(math.ceil(float('$DURATION')/$SEGMENT_SEC))")
# Découper les segments
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
→ Appeler l'Étape 2c pour chaque segment séquentiellement (le parallélisme déclenche le timeout 524 de Groq), concaténer les résultats.
Étape 2c : Transcription Whisper
Prérequis : Variable d'environnement GROQ_API_KEY
# Vérifier la clé API
if [ -z "$GROQ_API_KEY" ]; then
echo "❌ GROQ_API_KEY non définie. Obtenez-en une sur : https://console.groq.com/keys"
exit 1
fi
# Transcrire un seul fichier (remplacer AUDIO_FILE par le chemin réel)
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
# Extraire le texte brut
python3 -c "import json; print(json.load(open('/tmp/media_transcript.json'))['text'])"
Options du modèle Whisper :
| Modèle | Vitesse | Précision | Cas d'utilisation |
|---|---|---|---|
whisper-large-v3-turbo | 10x temps réel | Élevée | Choix par défaut |
whisper-large-v3 | 5x temps réel | Maximale | Contenu professionnel/bruyant |
Paramètre de langue :
- Chinois :
language=zh - Anglais :
language=en - Détection automatique : omettre le paramètre language
Étape 3 : Résumé Structuré
Choisir le format de sortie en fonction du type de média :
Vidéo (≤20 min) :
- Aperçu (1-2 phrases)
- Points clés (3-5 points)
- Citations notables (si présentes)
- Éléments d'action (si applicables)
Podcast (>20 min) :
- Aperçu (2-3 phrases : qui a discuté de quoi)
- Résumé des chapitres (segmenté par sujet, 2-3 phrases chacun)
- Points clés (5-8 points)
- Citations notables
- Éléments d'action (si applicables)
Format de Sortie
Vidéo
## 📺 Résumé Vidéo
**Titre** : [Titre de la vidéo]
**Durée** : [x minutes]
**Langue** : [Chinois/Anglais]
### Aperçu
[Résumé en 1-2 phrases]
### Points clés
1. [Point 1]
2. [Point 2]
...
### Citations notables
> "xxx" — [horodatage]
### Éléments d'action
- [si applicables]
Podcast
## 🎙️ Résumé Podcast
**Émission** : [Nom du podcast]
**Épisode** : [Titre de l'épisode]
**Durée** : [x minutes]
**Invités** : [si présents]
### Aperçu
[2-3 phrases : qui a discuté de quoi, conclusions principales]
### Résumé des chapitres
#### 1. [Sujet] (~xx:xx-xx:xx)
[2-3 phrases du contenu principal]
#### 2. [Sujet] (~xx:xx-xx:xx)
[2-3 phrases du contenu principal]
...
### Points clés
1. [Point 1]
2. [Point 2]
...
### Citations notables
> "xxx"
### Éléments d'action
- [si applicables]
Gestion des Erreurs
| Situation | Action |
|---|---|
| Pas de sous-titres + pas de GROQ_API_KEY | Inviter l'utilisateur à définir la clé API |
| Pas de sous-titres + clé API présente | Transcription Whisper automatique |
| Extraction Xiaoyuzhou curl vide | Utiliser Puppeteer/navigateur pour obtenir le HTML rendu |
| Audio >25 Mo | Segmenter avec ffmpeg (10 min/segment), transcrire séquentiellement |
| Podcast >2 heures | Avertir l'utilisateur sur la durée, confirmer avant de continuer |
| Timeout 524 de Groq | NE PAS paralléliser — transcrire séquentiellement, attendre 5 à 8 s entre les segments |
| Limite de débit 429 de Groq | Limite de 7200 s/heure, attendre l'en-tête retry-after, puis réessayer |
| yt-dlp Bilibili 412 | Utiliser l'API Bilibili à la place (Étape 1d) |
| Détection de bot YouTube | Ajouter --cookies-from-browser chrome |
| Timeout réseau | Réessayer une fois |
| Liens Spotify | Informer l'utilisateur : non pris en charge (protégé par DRM) |
Limites de Groq Whisper
- Maximum 25 Mo par requête
- Niveau gratuit : 7200 secondes d'audio/heure (fenêtre glissante), ~20 heures/jour
- Formats pris en charge : mp3, mp4, mpeg, mpga, m4a, wav, webm
Dépendances
yt-dlp: téléchargement vidéo + extraction de sous-titresffmpeg: conversion audio + segmentationcurl: téléchargement audio Xiaoyuzhou, API BilibiliGROQ_API_KEY: API de transcription Whisper (gratuite sur https://console.groq.com/keys)