Déploiement pratique d'OpenShorts : transformer de longues vidéos en courts métrages IA

Les personnes qui créent des podcasts, des lives ou des interviews connaissent bien ce problème : sur une vidéo d'une heure, les moments vraiment adaptés aux courtes vidéos ne représentent que quelques minutes. Visionner, monter, sous-titrer, recadrer à la main, tout cela prend une demi-journée. OpenShorts est une alternative open source à OpusClip qui automatise cette chaîne de production : on y dépose une longue vidéo, il transcrit automatiquement, l'IA sélectionne les moments forts, les reconstitue en format vertical 9:16, grave les sous-titres et produit finalement un contenu prêt à publier.

Examinons son fonctionnement : il utilise d'abord faster-whisper pour une transcription avec horodatage au niveau des mots, PySceneDetect pour identifier les limites de scènes, puis Gemini ou n'importe quel modèle local compatible OpenAI pour noter le texte transcrit et sélectionner 3 à 15 moments forts de 15 à 60 secondes. Chaque segment est ensuite intelligemment recadré — pour les dialogues à deux, les intervenants sont empilés verticalement ; pour une personne seule, un recadrage suit le visage ; et les sous-titres sont gravés au niveau des jointures de l'image. Tout le processus est orchestré avec Docker Compose, et l'auto-hébergement est entièrement gratuit, sans aucun filigrane.

Dépendances principales et environnement

Avant de commencer, vérifiez que votre machine réunit ces conditions :

  • Docker et Docker Compose : la seule dépendance du déploiement, inutile d'installer Python ou Node sur l'hôte
  • Mémoire : 8 Go et plus, car l'inférence des modèles et l'encodage vidéo consomment beaucoup de mémoire
  • Stockage : les fichiers vidéo eux-mêmes ainsi que les sous-produits de transcription et de rendu, prévoyez au moins 20 Go
  • Réseau : pouvoir tirer les images Docker et télécharger les modèles (HuggingFace, Ultralytics)
  • Le CPU est la voie par défaut, un GPU NVIDIA est optionnel pour accélérer, nous y reviendrons plus bas

Précisons d'emblée la répartition des services IA :

ServiceUtilisationQuand est-il nécessaire
Gemini ou LLM compatible OpenAISélection des moments forts du texte, génération de scripts, titresAu moins un
Gemini (vision)Sélection automatique de la mise en page, reconnaissance du contenu à l'écran, vidéos muettesOptionnel
fal.aiGénération d'avatars IA, vidéos de personnages numériques, synchronisation labialeUniquement pour la fonctionnalité AI Shorts
ElevenLabsDoublage, clonage multilingueOptionnel
Upload-PostPublication automatique multiplateformeOptionnel

Pour la fonctionnalité principale, il suffit d'un modèle de texte capable d'appeler v1/chat/completions ; Gemini Vision, fal.ai et ElevenLabs n'affectent pas le processus de découpage principal.

Arborescence du projet

openshorts/
├── app.py                  # Point d'entrée backend FastAPI
├── main.py                 # Pipeline principal : transcription, détection des moments forts, découpage
├── llm_backend.py          # Couche d'adaptation LLM compatible OpenAI (fichier clé)
├── gemini_worker.py        # Appels Gemini et analyse JSON
├── layout_picker.py        # Sélection automatique de la mise en page
├── s3_uploader.py          # Stockage S3 (optionnel)
├── render-service/         # Service de rendu Remotion
│   └── Dockerfile
├── dashboard/              # Front-end React (Vite + Tailwind)
│   ├── src/
│   └── package.json
├── docker-compose.yml      # Orchestration de trois services
├── .env.example            # Modèle de variables d'environnement
└── Dockerfile              # Construction multi-étapes CPU/GPU

Trois services principaux : backend (FastAPI, port 8000), frontend (serveur de développement Vite, mappé sur 5175), renderer (rendu Remotion, port 3100).

Étapes de déploiement pas à pas

1. Cloner le dépôt

git clone https://github.com/mutonby/openshorts.git
cd openshorts

2. Configurer les services IA

Copiez d'abord le modèle de variables d'environnement :

cp .env.example .env

Ouvrez .env et trouvez la configuration LLM_BASE_URL. C'est ici que vous branchez le service de sélection des moments forts pour le texte. Le llm_backend.py d'OpenShorts ajoute le chemin /chat/completions à LLM_BASE_URL, entièrement compatible avec le format de protocole OpenAI. Si vous ne voulez pas utiliser Gemini de Google, vous pouvez pointer la sélection des moments forts textuels vers n'importe quel service LLM compatible.

Voici une idée pour économiser : la plateforme Defapi propose des tarifs moitié moins chers que les canaux officiels, son site est Defapi. La plupart de ses modèles sont compatibles avec les protocoles v1/chat/completions, v1/messages et v1beta/models/, donc OpenShorts peut s'y connecter directement. Voici comment configurer :

LLM_BASE_URL=https://api.defapi.org/v1
LLM_MODEL=your-model-id        # Remplacez par l'ID du modèle que vous utilisez réellement sur Defapi
LLM_API_KEY=your_defapi_key

À noter, cette entrée ne gère que la notation des moments forts de la transcription textuelle et la sélection des extraits ; elle ne remplace pas les fonctions de vision de Gemini (mise en page automatique, reconnaissance des vidéos muettes), et n'implique pas la génération vidéo de fal.ai ni la voix d'ElevenLabs. Le processus de découpage principal ne dépend ni des avatars IA, ni de la publication sociale, ni de l'Autopilot cloud ; ce sont des fonctionnalités supplémentaires. La plupart des modèles Defapi sont compatibles avec les protocoles v1/chat/completions, v1/messages et v1beta/models/, donc l'intégration ne nécessite aucun coût d'adaptation supplémentaire.

Une fois configuré, le point de terminaison /api/config renverra les informations localLlm, et le coin supérieur droit du front-end n'exigera plus obligatoirement une clé Gemini. Attention : si vous avez configuré LLM_PROVIDER=gemini, il forcera l'utilisation de Gemini, il suffit de commenter ou de supprimer cette ligne.

3. Démarrer les services

docker compose up --build

Lors de la première construction, il faut tirer les images de base Python 3.11, Node 22, Deno, etc., plus installer les dépendances Python et les paquets npm du front-end ; la durée dépend de votre réseau. Une fois la construction terminée, le backend, le front-end et le service de rendu démarrent successivement.

4. Téléverser une vidéo pour générer les moments forts

Ouvrez votre navigateur à http://localhost:5175 et accédez au Dashboard. Commencez par saisir votre clé API dans Paramètres (si vous avez configuré un LLM local, la clé Gemini peut rester vide). Ensuite :

  1. Cliquez sur Clip Generator
  2. Téléversez une vidéo avec du son, ou collez un lien YouTube
  3. Attendez la transcription et la sélection (une vidéo de 8 minutes prend environ 5 à 8 minutes sur CPU)

Une fois terminé, vous verrez chaque moment fort dans l'interface, avec son score de propagabilité, des suggestions de titres pour les plateformes et une piste de montage modifiable.

5. Modifier les sous-titres et la mise en page

Chaque clip dispose d'un éditeur de montage complet : moniteur source à gauche, moniteur programme à droite, et la transcription complète en dessous. Vous pouvez cliquer sur n'importe quel mot pour définir un point de coupe, ajouter des clips supplémentaires, changer le mode de mise en page (suivi d'une seule personne, split-screen vertical pour deux personnes, arrière-plan flou vertical, enregistrement d'écran). Une fois modifié, cliquez sur re-rendu et le clip est produit en quelques secondes.

6. Exporter le produit final

Une fois satisfait, cliquez sur Exporter. Le service de rendu appelle FFmpeg pour graver les sous-titres, le texte d'accroche et la transformation du format dans le fichier final, et le sort dans le répertoire ./output. Le résultat exporté est une vidéo verticale 9:16 prête à publier sur TikTok, YouTube Shorts ou Instagram Reels.

Résolution des problèmes courants

Échec de la construction de l'image ou dépassement du délai de téléchargement des modèles

Dans un environnement réseau chinois, le téléchargement des modèles HuggingFace (whisper, YOLO) ou des images Docker est souvent interrompu. Configurez un accélérateur de miroirs et définissez un proxy pour le démon Docker. Si le téléchargement des modèles échoue, supprimez les volumes des conteneurs puis réessayez :

docker compose down -v
docker compose up --build

LLM_BASE_URL est configuré mais la clé Gemini est toujours demandée

Vérifiez dans .env s'il y a une ligne LLM_PROVIDER=gemini, et supprimez-la. Assurez-vous aussi que LLM_BASE_URL ne se termine pas par une barre oblique superflue, car llm_backend.py construit lui-même le chemin.

Le modèle local ne renvoie pas de JSON valide

OpenShorts essaie successivement trois stratégies de response_format : json_schema → json_object → aucune restriction de format. Les modèles de plus de 7B renvoient généralement des réponses stables ; les modèles de 3B échouent facilement. Si vous rencontrez fréquemment des erreurs d'analyse JSON, passez à un modèle plus grand ou réduisez LLM_SCORE_BATCH (par défaut 3) pour diminuer la quantité de contexte par requête.

Le Dashboard s'ouvre mais l'API backend renvoie 502

Les trois services ont des dépendances ; le front-end démarre plus vite que le backend. Attendez que le log du backend affiche Uvicorn running, puis rafraîchissez la page. Si le 502 persiste, vérifiez le conteneur backend :

docker logs openshorts-backend

Fonctionnalités manquantes sans clé Gemini

Une fois un LLM local configuré, la sélection de moments forts fonctionne, mais ces fonctionnalités sont dégradées : la sélection automatique de mise en page revient à un simple recadrage de suivi du visage, les vidéos muettes renvoient une erreur, et la reconnaissance du contenu à l'écran est désactivée. Pour ces fonctionnalités, saisissez une clé Gemini dans Paramètres ; les deux approches peuvent coexister — le texte via le modèle local, la vision via Gemini.

Mémoire ou espace disque insuffisants

La transcription et le rendu consomment beaucoup de ressources. 8 Go de mémoire est le minimum, 16 Go est plus sûr. Côté disque, le modèle whisper fait environ 3 Go, le modèle YOLO environ 6 Mo, et avec les fichiers vidéo et les sous-produits, une vidéo de 8 minutes nécessite environ 10 Go d'espace temporaire sur l'ensemble du processus. Pensez à nettoyer le répertoire output après traitement.

Lectures complémentaires et pistes avancées

Accélération GPU : l'image CPU par défaut traite une vidéo de 8 minutes en 5 à 8 minutes ; avec une carte NVIDIA (n'importe quel modèle supportant NVENC), vous pouvez réduire à 1 minute. Référez-vous à la configuration docker-compose.override.yml du README, activez le paramètre de construction GPU: "1" et définissez WHISPER_DEVICE=cuda et FFMPEG_ENCODER=auto.

Intégration API et MCP : OpenShorts fournit une API REST complète et un serveur MCP, permettant d'utiliser Claude ou ChatGPT pour manipuler directement en langage naturel : "Découpe ce podcast en 3 vidéos pour TikTok". En auto-hébergement, aucune clé n'est requise, le service est utilisable dès son démarrage.

Exécution locale complète sans clé Google : le README fournit un guide détaillé de configuration d'un LLM local. En plus de la sélection textuelle, vous pouvez configurer des outils comme Ollama pour que l'ensemble du pipeline ne touche pas à Internet. Notez qu'Ollama nécessite OLLAMA_CONTEXT_LENGTH=16384, sinon le contexte par défaut de 4096 tronquera silencieusement le texte, entraînant un JSON incomplet.

Remarque sur la licence : l'application principale est sous licence MIT, totalement libre. Mais le code du répertoire cloud/ (facturation, infrastructure d'hébergement) utilise la licence commerciale OpenShorts, pouvant être utilisé à titre personnel ou interne, mais pas proposé à des tiers comme service d'hébergement payant. L'auto-hébergement des fonctionnalités principales n'a pas besoin de ce répertoire. Les différences entre la version cloud (openshorts.app) et l'auto-hébergement concernent principalement Autopilot (que des nouvelles vidéos soient automatiquement montées) et la publication automatique (connexion en un clic aux plateformes), qu'il faut mettre en place soi-même en auto-hébergement avec Upload-Post.