← Retour aux Projets Personnels

Projet IA Automation - Vue d'ensemble

Essayez l'application ici : https://video-automation.littlenuage.com/

Ce projet est une plateforme de production video entierement automatisee propulsee par l'IA. A partir d'un simple sujet textuel, le systeme genere un script structure, cree des images, synthetise la narration, applique des animations de camera, ajoute des sous-titres et de la musique de fond, et livre une video prete a publier - le tout orchestre via une interface web Streamlit avec gestion de file d'attente et notifications Discord.

Contexte du projet

Developpe comme projet personnel pour industrialiser la creation de contenu video, cette plateforme elimine le besoin de montage manuel. Elle prend en charge plusieurs categories de videos (biographies de celebrites, documentaires geographiques, reportages d'actualite, analyses de films, monuments, oeuvres d'art), plusieurs langues (francais, anglais, espagnol) et deux modes de production (format court et format long). L'application est deployee en ligne et accessible a tous.

Vue d'ensemble de l'architecture

Le systeme suit une architecture modulaire orientee services avec une separation claire des responsabilites :

IA Automation Project Overview

Try the application here: https://video-automation.littlenuage.com/

This project is a fully automated video production platform powered by AI. From a simple text topic, the system generates a structured script, creates images, synthesizes narration, applies camera animations, adds subtitles and background music, and delivers a ready-to-publish video -- all orchestrated through a Streamlit web interface with job queue management and Discord notifications.

Project Context

Developed as a personal project to industrialize video content creation, this platform eliminates the need for manual editing. It supports multiple video categories (celebrity biographies, geography documentaries, news reports, movie analyses, monuments, artworks), multiple languages (French, English, Spanish), and two production modes (short-form and long-form). The application is deployed online and accessible to anyone.

Architecture Overview

The system follows a modular, service-oriented architecture with clear separation of concerns:

User (Streamlit UI)
    |
    v
app2.py --> queue_manager.py --> run_pipeline.py --> pipeline_executor.py
                                                          |
                                    +---------------------+---------------------+
                                    v                     v                     v
                              services/             scripts/              AI Models
                          (script, image,       (generation &          (SD, TTS, LLM,
                          audio, video)          processing)           CLIP, Whisper...)

Ce que j'ai developpe

1. Application Web Streamlit (app2.py)

L'interface utilisateur principale construite avec Streamlit, remplacant le premier prototype Flask :

  • Acces authentifie via streamlit_authenticator avec identifiants YAML
  • Configuration video : selection du type (celebrite, geographie, actu, film, oeuvre, monument), categorie, entite, mode (court/long), langue (FR/EN/ES)
  • Interface a trois onglets : Generation (flux de travail etape par etape), File d'attente (gestion des taches), Historique (productions passees)
  • Controle WebUI : surveillance et lancement du serveur WebUI Stable Diffusion directement depuis l'interface
  • Preferences utilisateur : parametres persistants sauvegardes entre les sessions (user_preferences.json)
  • Integration Excel : listes d'entites chargees depuis des fichiers Excel par categorie

2. Moteur d'execution du pipeline (pipeline_executor.py)

L'orchestrateur principal implementant un pipeline robuste en 6 etapes :

What I Developed

1. Streamlit Web Application (app2.py)

The main user interface built with Streamlit, replacing the earlier Flask prototype:

  • Authenticated access via streamlit_authenticator with YAML-based credentials
  • Video configuration: type selection (celebrity, geography, actu, movie, oeuvre, monument), category, entity, mode (short/long), language (FR/EN/ES)
  • Three-tab interface: Generation (step-by-step workflow), Queue (job management), History (past productions)
  • WebUI control: monitor and launch the Stable Diffusion WebUI server directly from the interface
  • User preferences: persistent settings saved between sessions (user_preferences.json)
  • Excel integration: entity lists loaded from category-specific Excel files

2. Pipeline Execution Engine (pipeline_executor.py)

The core orchestrator implementing a robust 6-step pipeline:

StepDescriptionScript
1Script Generationgenerate_script.py / generate_script_actu.py
2Image Generationgenerate_image.py / get_image_pexels.py
3Audio Synthesisgenerate_audio.py
4Camera Movement & Animationgenerate_movement.py / generate_movement_from_db.py
5Subtitle Alignmentalign_subtitles.py (short mode)
6Music Generationgenerate_music.py (short mode)

Fonctionnalites cles :

  • Execution parallele : les etapes 2 (images) et 3 (audio) s'executent simultanement
  • Reessai automatique : jusqu'a 2 tentatives par etape en cas d'echec
  • Gestion des processus : arret des processus orphelins avant chaque etape pour eviter les conflits de ressources
  • Suivi d'execution : metriques de temps completes par etape et duree totale du pipeline

3. Systeme de file d'attente (queue_manager.py)

Une file d'attente thread-safe pour la production video sequentielle :

  • Etat persistant stocke dans generation_queue.json
  • Cycle de vie des taches : en attente - en cours - termine/echoue
  • Reprise apres echec : redemarrage d'une tache echouee a partir de l'etape exacte qui a echoue
  • Historique : stocke les 50 dernieres taches terminees/echouees
  • Statistiques : comptages en temps reel des taches en attente, en cours, terminees, echouees
  • Thread worker global : traite les taches sequentiellement en arriere-plan

4. Couche de services (services/)

Quatre classes de services encapsulent les E/S fichiers et l'execution de sous-processus :

  • script_service.py : charger, sauvegarder, generer et valider les fichiers JSON de scripts
  • image_service.py : gerer les images/videos generees, suppression par scene, recuperation d'images avec mapping de scenes
  • audio_service.py : resolution des chemins audio, verifications d'existence, segmentation audio, orchestration de generation
  • video_service.py : generation de mouvements, alignement de sous-titres, overlay texte, integration musique, upload YouTube, decoupage TikTok

Tous les services suivent un pattern coherent avec des chemins organises :

Key features:

  • Parallel execution: steps 2 (images) and 3 (audio) run concurrently
  • Automatic retry: up to 2 retries per step on failure
  • Process management: kills orphan processes before each step to prevent resource conflicts
  • Execution tracking: full timing metrics per step and total pipeline duration

3. Job Queue System (queue_manager.py)

A thread-safe job queue for sequential video production:

  • Persistent state stored in generation_queue.json
  • Job lifecycle: pending - running - completed/failed
  • Retry from failure: restart a failed job from the exact step that failed
  • History: stores the last 50 completed/failed jobs
  • Statistics: real-time counts of pending, running, completed, failed jobs
  • Global worker thread: processes jobs sequentially in the background

4. Service Layer (services/)

Four service classes encapsulate file I/O and subprocess execution:

  • script_service.py: load, save, generate, and validate script JSON files
  • image_service.py: manage generated images/videos, scene-level deletion, image retrieval with scene mapping
  • audio_service.py: audio path resolution, existence checks, audio segmentation, generation orchestration
  • video_service.py: movement generation, subtitle alignment, text overlay, music integration, YouTube upload, TikTok cutting

All services follow a consistent pattern with organized paths:

output/{type}/{video}/{category}/{entity_name}/{mode}/{language_code}/

5. Composants UI (ui/)

Composants Streamlit modulaires separes pour la maintenabilite :

  • generation_tab.py : flux de travail progressif en 9 sections (script - images - audio - mouvement - sous-titres - overlay texte - musique - TikTok - YouTube)
  • queue_tab.py : surveillance de file d'attente, gestion des taches, reessai, navigation historique, upload YouTube rapide
  • components.py : utilitaires reutilisables (arret de processus, preferences, controle WebUI)
  • styles.py : CSS personnalise pour indicateurs de statut, boutons, lecteurs video, cartes de metriques

6. Modules d'infrastructure

Gestionnaire de cache (cache_manager.py) :

  • Generation de cles de cache basee sur MD5 par categorie (scripts, images, audio)
  • Index de cache stocke dans cache/cache_index.json
  • Nettoyage du cache obsolete avec age configurable
  • Prevention de la regeneration inutile des ressources existantes

Logger (logger.py) :

  • Handlers de fichiers rotatifs (10 Mo max, 5 sauvegardes)
  • Fichiers de logs specifiques aux taches (logs/job_{id}.log)
  • Loggers dedies pour le pipeline, la file d'attente et l'application
  • Journalisation structuree du cycle de vie des etapes (debut, fin, echec)

Notifications (notifications.py) :

  • Integration webhook Discord avec embeds enrichis
  • Messages de statut codes par couleur (vert=succes, rouge=erreur, orange=avertissement, bleu=info)
  • Notifications du cycle de vie des taches (demarrage, progression des etapes, fin, echec)

7. Organisation des scripts (scripts/)

Tous les scripts de traitement sont organises par domaine :

5. UI Components (ui/)

Modular Streamlit components split for maintainability:

  • generation_tab.py: 9-section progressive workflow (script - images - audio - movement - subtitles - text overlay - music - TikTok - YouTube)
  • queue_tab.py: queue monitoring, job management, retry, history browsing, quick YouTube upload
  • components.py: reusable utilities (process killing, preferences, WebUI control)
  • styles.py: custom CSS for status indicators, buttons, video players, metric cards

6. Infrastructure Modules

Cache Manager (cache_manager.py):

  • MD5-based cache key generation per category (scripts, images, audio)
  • Cache index stored in cache/cache_index.json
  • Stale cache cleanup with configurable age
  • Prevents unnecessary regeneration of existing assets

Logger (logger.py):

  • Rotating file handlers (10 MB max, 5 backups)
  • Job-specific log files (logs/job_{id}.log)
  • Dedicated loggers for pipeline, queue, and application
  • Structured step lifecycle logging (start, complete, fail)

Notifications (notifications.py):

  • Discord webhook integration with rich embeds
  • Color-coded status messages (green=success, red=error, orange=warning, blue=info)
  • Job lifecycle notifications (started, step progress, completed, failed)

7. Scripts Organization (scripts/)

All processing scripts are organized by domain:

scripts/
├── script/           # LLM-based script generation & verification
├── images/           # Image generation, validation & thumbnails
├── audio/            # TTS synthesis & audio processing
├── video/            # Video editing, animation & subtitles
├── music/            # Background music generation
├── batch/            # Batch operations
├── publishing/       # Publishing & promotion
└── experimental/     # Experimental features

Organisation des fichiers

File Organization

.
├── app2.py                    # Streamlit web application
├── pipeline_executor.py       # 6-step pipeline engine
├── queue_manager.py           # Job queue management
├── run_pipeline.py            # Subprocess launcher
├── utils.py                   # Configuration & environment utilities
├── cache_manager.py           # Intelligent caching system
├── logger.py                  # Structured logging
├── notifications.py           # Discord webhook notifications
├── config.xml                 # Application configuration
├── services/
│   ├── script_service.py
│   ├── image_service.py
│   ├── audio_service.py
│   └── video_service.py
├── ui/
│   ├── generation_tab.py
│   ├── queue_tab.py
│   ├── components.py
│   └── styles.py
├── scripts/                   # Processing scripts
├── input/
│   ├── Audio/                 # Voice reference files (FR/EN/ES)
│   └── Video_List/            # Excel entity lists per category
├── output/                    # Generated content
├── logs/                      # Rotating log files
├── cache/                     # Cache index & metadata
└── stable-diffusion-webui/    # AUTOMATIC1111 WebUI (submodule)

Flux de travail du pipeline automatise

Pipeline complet (mode file d'attente)

  1. L'utilisateur configure le type de video, la categorie, l'entite, le mode et la langue dans l'interface Streamlit
  2. La tache est ajoutee a la file d'attente persistante via queue_manager.py
  3. Le thread worker prend la tache et lance run_pipeline.py comme sous-processus
  4. PipelineExecutor orchestre les 6 etapes :
    • Etape 1 : Le LLM genere un script JSON structure (scenes, prompts, titres)
    • Etapes 2-3 : Images et audio s'executent en parallele - Stable Diffusion ou Pexels pour les images, XTTS v2 pour le clonage vocal
    • Etape 4 : Animation de mouvement de camera appliquee a chaque scene (zoom, pan, slide)
    • Etape 5 : Alignement des sous-titres base sur Whisper (mode court)
    • Etape 6 : Generation de musique de fond MusicGen (mode court)
  5. Notification Discord envoyee au demarrage, a la fin ou en cas d'echec de la tache
  6. L'utilisateur consulte le resultat dans l'onglet Historique, peut uploader sur YouTube directement

Mode manuel (onglet Generation)

Chaque etape peut aussi etre executee individuellement avec apercu en direct :

  • Editer le JSON du script directement dans l'interface
  • Previsualiser les images generees en grille
  • Ecouter l'audio par scene avec edition des prompts
  • Regarder les previsualisations video animees
  • Editer le JSON des sous-titres avec rendu en direct
  • Decouper les videos pour TikTok avec selection temporelle
  • Uploader sur YouTube avec miniature et metadonnees

Configuration (config.xml)

Automated Pipeline Workflow

Full Pipeline (Queue Mode)

  1. User configures video type, category, entity, mode, language in the Streamlit UI
  2. Job added to the persistent queue via queue_manager.py
  3. Worker thread picks up the job and spawns run_pipeline.py as a subprocess
  4. PipelineExecutor orchestrates the 6 steps:
    • Step 1: LLM generates a structured JSON script (scenes, prompts, titles)
    • Steps 2-3: Images and audio run in parallel - Stable Diffusion or Pexels for images, XTTS v2 for voice cloning
    • Step 4: Camera movement animation applied to each scene (zoom, pan, slide)
    • Step 5: Whisper-based subtitle alignment (short mode)
    • Step 6: MusicGen background music generation (short mode)
  5. Discord notification sent at job start, completion, or failure
  6. User reviews the result in the History tab, can upload to YouTube directly

Manual Mode (Generation Tab)

Each step can also be executed individually with live preview:

  • Edit the script JSON directly in the UI
  • Preview generated images in a grid view
  • Listen to audio per scene with prompt editing
  • Watch animated video previews
  • Edit subtitle JSON with live rendering
  • Cut videos for TikTok with time-based selection
  • Upload to YouTube with thumbnail and metadata

Configuration (config.xml)

<!-- Languages with voice reference files -->
<languages>
  <language name="Francais" code="fr" audio="Enregistrement-francais.wav" />
  <language name="English" code="en" audio="Enregistrement-anglais.wav" />
  <language name="Espanol" code="es" audio="Enregistrement-espagnol.wav" />
</languages>

<!-- Production modes -->
<modes>
  <mode name="short" nb_scenes="5" nb_images="3" width="1024" height="1024" />
  <mode name="long" nb_scenes="20" nb_images="3" width="1280" height="720" />
</modes>

<!-- AI Models -->
<models>
  <model name="juggernaut-xl" type="image" />
  <model name="xtts_v2" type="audio" />
  <script_models>gemma, deepseek-r1, ministral</script_models>
</models>

Architecture technique

Stack backend :

  • Python 3.9+ : Langage principal
  • Streamlit : Framework web avec authentification
  • XML/YAML/JSON : Gestion de la configuration
  • Threading : Execution parallele et worker de file d'attente

Modeles IA (8 modeles integres) :

  • Stable Diffusion (AUTOMATIC1111 WebUI) - Generation d'images
  • Coqui TTS (XTTS v2) - Clonage vocal multilingue
  • Ollama (Gemma, DeepSeek, Ministral) - Generation de scripts via LLM
  • CLIP (OpenAI) - Verification de similarite image-texte
  • Whisper (OpenAI) - Alignement de sous-titres depuis l'audio
  • MediaPipe - Detection de visages dans les images generees
  • Facebook MusicGen - Musique de fond generee par IA
  • MoviePy + OpenCV - Edition video, animation, effets

APIs externes :

  • API Stable Diffusion (http://127.0.0.1:7860)
  • API Ollama (http://localhost:11434)
  • API Pexels (images/videos stock pour geographie/actu)
  • API YouTube Data v3 (uploads automatises)
  • Webhooks Discord (notifications)

Categories de traitement :

Technical Architecture

Backend Stack:

  • Python 3.9+: Core language
  • Streamlit: Web framework with authentication
  • XML/YAML/JSON: Configuration management
  • Threading: Parallel execution and queue worker

AI Models (8 models integrated):

  • Stable Diffusion (AUTOMATIC1111 WebUI) - Image generation
  • Coqui TTS (XTTS v2) - Multilingual voice cloning
  • Ollama (Gemma, DeepSeek, Ministral) - Script generation via LLM
  • CLIP (OpenAI) - Image-text similarity verification
  • Whisper (OpenAI) - Subtitle alignment from audio
  • MediaPipe - Face detection in generated images
  • Facebook MusicGen - AI-generated background music
  • MoviePy + OpenCV - Video editing, animation, effects

External APIs:

  • Stable Diffusion API (http://127.0.0.1:7860)
  • Ollama API (http://localhost:11434)
  • Pexels API (stock images/videos for geography/actu)
  • YouTube Data API v3 (automated uploads)
  • Discord Webhooks (notifications)

Processing Categories:

CategoryImage SourceScript ModelDescription
CelebrityStable DiffusionLLMBiography and career videos
GeographyPexels APILLMLocation and travel documentaries
Actu (News)Pexels APILLM (actu variant)Current events reports
MoviePexels APILLMFilm analysis and summaries
MonumentStable DiffusionLLMHistorical and architectural features
Oeuvre (Art)Stable DiffusionLLMArtistic works and analysis

Defis de developpement et solutions

Defi 1 : Fiabilite du pipeline

  • Probleme : Les pipelines de longue duree (5-20 scenes) pouvaient echouer en cours d'execution, gaspillant tout le travail precedent
  • Solution : Execution etape par etape avec reessai automatique (2 tentatives par etape), gestion des processus pour arreter les orphelins, et redemarrage des taches de la file d'attente a partir de l'etape exacte d'echec

Defi 2 : Synchronisation audio-visuelle

  • Probleme : S'assurer que la narration audio correspond parfaitement a la duree video sur toutes les scenes
  • Solution : Calcul dynamique du timing, alignement des sous-titres base sur Whisper, et ajustement du debit d'images avec MoviePy

Defi 3 : Contention des ressources

  • Probleme : Plusieurs modeles IA (SD, TTS, LLM) en competition pour le GPU et la memoire
  • Solution : Execution sequentielle des taches via le worker de file d'attente, etapes image/audio paralleles au sein d'une tache, et arret des processus avant chaque etape pour liberer les ressources

Defi 4 : Coherence de qualite

  • Probleme : Le contenu genere par IA varie en qualite entre les scenes
  • Solution : Pipeline de verification multi-etapes (score CLIP pour les images, detection de visages via MediaPipe, validation du script via LLM), avec points d'intervention manuelle dans l'interface

Defi 5 : Support multilingue

  • Probleme : Prendre en charge plusieurs langues pour la narration, les scripts et les sous-titres
  • Solution : Fichiers de reference vocale par langue, repertoires de sortie par langue, et prompts LLM adaptes pour chaque langue

Defi 6 : Observabilite

  • Probleme : Deboguer les taches echouees dans un pipeline automatise avec plusieurs modeles IA
  • Solution : Journalisation structuree avec fichiers rotatifs, fichiers de logs specifiques aux taches, suivi du cycle de vie des etapes, et notifications Discord avec details d'erreur

Prerequis

  • Python 3.9+
  • ffmpeg installe sur le systeme
  • GPU recommande (NVIDIA pour le support CUDA)

Packages Python :

Development Challenges and Solutions

Challenge 1: Pipeline Reliability

  • Problem: Long-running pipelines (5-20 scenes) could fail mid-execution, wasting all prior work
  • Solution: Step-by-step execution with automatic retry (2 attempts per step), process management to kill orphans, and queue-based job restart from the exact failed step

Challenge 2: Audio-Visual Synchronization

  • Problem: Ensuring audio narration perfectly matches video duration across scenes
  • Solution: Dynamic timing calculation, Whisper-based subtitle alignment, and frame rate adjustment with MoviePy

Challenge 3: Resource Contention

  • Problem: Multiple AI models (SD, TTS, LLM) competing for GPU and memory
  • Solution: Sequential job execution via queue worker, parallel image/audio steps within a job, and process killing before each step to release resources

Challenge 4: Quality Consistency

  • Problem: AI-generated content varies in quality across scenes
  • Solution: Multi-stage verification pipeline (CLIP score for images, face detection via MediaPipe, script validation via LLM), with manual intervention points in the UI

Challenge 5: Multi-language Support

  • Problem: Supporting multiple languages for narration, scripts, and subtitles
  • Solution: Language-specific voice reference files, per-language output directories, and LLM prompts adapted for each language

Challenge 6: Observability

  • Problem: Debugging failed jobs in an automated pipeline with multiple AI models
  • Solution: Structured logging with rotating files, job-specific log files, step lifecycle tracking, and Discord notifications with error details

Prerequisites

  • Python 3.9+
  • ffmpeg installed on the system
  • GPU recommended (NVIDIA for CUDA support)

Python packages:

pip install streamlit streamlit-authenticator
pip install moviepy requests TTS openai-whisper
pip install transformers mediapipe ollama
pip install pydub soundfile openpyxl pyyaml
pip install -r stable-diffusion-webui/requirements.txt

Services a executer :

Services to run:

# Stable Diffusion WebUI (image generation)
cd stable-diffusion-webui && ./webui.sh --api

# Ollama (LLM for script generation)
ollama serve
ollama pull gemma3:12b

# Streamlit application
streamlit run app2.py

Depannage

  • Erreur API Stable Diffusion : verifier que le WebUI est en cours d'execution sur le port 7860 avec le flag --api
  • Connexion Ollama refusee : s'assurer que ollama serve est en cours d'execution sur le port 11434
  • Audio non genere : verifier le chemin du fichier WAV de reference vocale dans config.xml
  • File d'attente bloquee : verifier logs/queue.log et logs/job_{id}.log pour les details d'erreur
  • Notifications Discord non envoyees : verifier l'URL du webhook dans .env
  • Decalage image/audio : s'assurer que les numeros de scenes correspondent dans le JSON du script
  • Conflits de processus : utiliser le bouton "kill process" dans l'interface ou verifier les processus Python orphelins

Cas d'utilisation et applications

  • Contenu educatif : Videos explicatives sur n'importe quel sujet avec narration IA
  • Reseaux sociaux : Contenu format court pret pour TikTok avec decoupage automatique
  • Actualites : Reportages automatises avec images stock Pexels
  • Documentaire : Documentaires geographiques et monumentaux avec images
  • Divertissement : Biographies de celebrites, analyses de films, presentations d'oeuvres d'art
  • Marketing : Presentations de produits avec voix et musique personnalisees

Ameliorations futures

  • Apercu et streaming de generation video en temps reel
  • Effets d'animation avances (transitions 3D, particules)
  • Transfert de style video et filtres artistiques
  • Integration avec d'autres modeles TTS (ElevenLabs, Bark)
  • Deploiement cloud pour scalabilite horizontale
  • Tests A/B pour l'optimisation des miniatures et titres
  • Tableau de bord analytique pour les performances du contenu genere

Metriques de performance

  • Generation de script : ~10-30 secondes (selon le LLM)
  • Generation d'images : ~5-10 secondes par scene (selon le GPU)
  • Synthese audio : ~3-5 secondes par scene
  • Animation video : ~2-4 secondes par scene
  • Alignement sous-titres : ~5-10 secondes au total
  • Generation musique : ~15-30 secondes
  • Pipeline total (court, 5 scenes) : ~3-5 minutes
  • Pipeline total (long, 20 scenes) : ~15-25 minutes

Modeles IA detailles

1. Stable Diffusion (AUTOMATIC1111 WebUI)

Modele : Juggernaut-XL avec LoRA de detail de visage. Utilise pour la generation d'images a partir de prompts textuels (scenes, miniatures). Prerequis : WebUI en cours d'execution avec le flag --api, modeles .safetensors dans models/Stable-diffusion/.

2. Coqui TTS (XTTS v2)

Modele : tts_models/multilingual/multi-dataset/xtts_v2. Clonage vocal multilingue a partir d'un fichier WAV de reference. Prerequis : pip install TTS, fichier WAV de reference par langue.

3. Ollama (Gemma, DeepSeek, Ministral)

Modeles : gemma3:12b, deepseek-r1:latest, ministral-3:14b. Generation de scripts basee sur LLM, verification, traduction. Sortie JSON structuree avec scenes, titres et prompts.

4. CLIP (OpenAI)

Modele : openai/clip-vit-base-patch32. Scoring de similarite image-texte pour la verification de qualite. Filtrage automatique des images a faible pertinence.

5. Whisper (OpenAI)

Modele : Whisper base. Alignement automatique des sous-titres a partir de la transcription audio. Timing au niveau des mots et export JSON des sous-titres.

6. MediaPipe (Detection de visages)

Detection de visages dans les images generees pour le filtrage qualite. Rejet automatique des images sans visages attendus.

7. Facebook MusicGen

Modele : facebook/musicgen-medium. Musique de fond generee par IA a partir de prompts textuels. Correspondance automatique de la duree et integration directe dans le pipeline.

8. MoviePy + OpenCV

Edition video, animation de camera (zoom, pan, slide), synchronisation audio, overlay de sous-titres. Recadrage TikTok/YouTube, rendu de sous-titres, concatenation video, mixage musical.

Ressources et credits

Essayez vous-meme !

Acceder a l'application : https://video-automation.littlenuage.com/

  1. Selectionnez votre type de video et categorie
  2. Choisissez une entite dans la liste (ou ajoutez la votre)
  3. Choisissez une langue et un mode de production (court/long)
  4. Ajoutez la tache a la file d'attente ou generez etape par etape
  5. Suivez la progression via les notifications Discord
  6. Telechargez ou uploadez directement sur YouTube

Troubleshooting

  • Stable Diffusion API error: check that the WebUI is running on port 7860 with --api flag
  • Ollama connection refused: ensure ollama serve is running on port 11434
  • Audio not generated: verify the voice reference WAV file path in config.xml
  • Queue stuck: check logs/queue.log and logs/job_{id}.log for error details
  • Discord notifications not sent: verify the webhook URL in .env
  • Image/audio mismatch: ensure scene numbers match in the script JSON
  • Process conflicts: use the "kill process" button in the UI or check for orphan Python processes

Use Cases and Applications

  • Educational Content: Explainer videos on any topic with AI narration
  • Social Media: TikTok-ready short-form content with automatic cutting
  • News: Automated news reports with Pexels stock footage
  • Documentary: Geography and monument documentaries with images
  • Entertainment: Celebrity biographies, movie analyses, art features
  • Marketing: Product presentations with custom voice and music

Future Enhancements

  • Real-time video generation preview and streaming
  • Advanced animation effects (3D transitions, particles)
  • Video style transfer and artistic filters
  • Integration with more TTS models (ElevenLabs, Bark)
  • Cloud deployment for horizontal scalability
  • A/B testing for thumbnail and title optimization
  • Analytics dashboard for generated content performance

Performance Metrics

  • Script Generation: ~10-30 seconds (LLM-dependent)
  • Image Generation: ~5-10 seconds per scene (GPU-dependent)
  • Audio Synthesis: ~3-5 seconds per scene
  • Video Animation: ~2-4 seconds per scene
  • Subtitle Alignment: ~5-10 seconds total
  • Music Generation: ~15-30 seconds
  • Total Pipeline (short, 5 scenes): ~3-5 minutes
  • Total Pipeline (long, 20 scenes): ~15-25 minutes

Detailed AI Models

1. Stable Diffusion (AUTOMATIC1111 WebUI)

Model: Juggernaut-XL with face detail LoRA. Used for image generation from text prompts (scenes, thumbnails). Prerequisites: WebUI running with --api flag, .safetensors models in models/Stable-diffusion/.

2. Coqui TTS (XTTS v2)

Model: tts_models/multilingual/multi-dataset/xtts_v2. Multilingual voice cloning from a WAV reference file. Prerequisites: pip install TTS, WAV reference file per language.

3. Ollama (Gemma, DeepSeek, Ministral)

Models: gemma3:12b, deepseek-r1:latest, ministral-3:14b. LLM-based script generation, verification, translation. Structured JSON output with scenes, titles, and prompts.

4. CLIP (OpenAI)

Model: openai/clip-vit-base-patch32. Image-text similarity scoring for quality verification. Automatic filtering of low-relevance images.

5. Whisper (OpenAI)

Model: Whisper base. Automatic subtitle alignment from audio transcription. Word-level timing and subtitle JSON export.

6. MediaPipe (Face Detection)

Face detection in generated images for quality filtering. Automatic rejection of images without expected faces.

7. Facebook MusicGen

Model: facebook/musicgen-medium. AI-generated background music from text prompts. Automatic duration matching and direct pipeline integration.

8. MoviePy + OpenCV

Video editing, camera animation (zoom, pan, slide), audio synchronization, subtitle overlay. TikTok/YouTube crop, subtitle rendering, video concatenation, music mixing.

Resources and Credits

Try It Yourself!

Access the application: https://video-automation.littlenuage.com/

  1. Select your video type and category
  2. Choose an entity from the list (or add your own)
  3. Pick a language and production mode (short/long)
  4. Add the job to the queue or generate step-by-step
  5. Monitor progress via Discord notifications
  6. Download or upload directly to YouTube

IA Automation Workflow