1. Documentation publique
  2. Linux
  3. minimax h3

minimax h3

Soumis par entreprise7pro le jeu, 09/24/2026 - 21:50

Ubuntu 24.04 lts

Installer

Movie making 101

workflows

Movie Factory Blackwell

Une couche d’orchestration non destructive pour le workflow ComfyUI/MiniMax H3 validé, avec un chemin pour la station de travail existante et un paquet de déploiement portable pour une machine neuve.

Pile technologique : PydanticAI pour la planification et la réalisation, Prefect pour les flux Python durables et la gestion de l’état, et ComfyUI comme moteur de rendu GPU sans interface. OpenClaw est volontairement optionnel et n’est pas requis pour le pipeline principal de Movie Factory.

Démarrage rapide : exécuter movie-factory-deploy.tar.gz

Si vous êtes devant une nouvelle machine Ubuntu 24.04 avec l’archive de déploiement, voici le chemin normal.

Important : lancez l’installation avec votre utilisateur Linux normal. Ne faites pas sudo ./install.sh. Le programme d’installation appelle lui-même sudo seulement lorsqu’il doit utiliser apt ou systemd.

1. Mettre l’archive sur la machine cible

Si le fichier est déjà sur la machine, allez dans le répertoire où il se trouve.

Par exemple :

cd ~/Downloads
ls -lh movie-factory-deploy.tar.gz

Si vous le copiez depuis un autre ordinateur :

scp movie-factory-deploy.tar.gz user@target-host:~/
ssh user@target-host
cd ~

2. Extraire l’archive

tar -xzf movie-factory-deploy.tar.gz
cd movie-factory-deploy

Vous devriez maintenant voir des fichiers comme :

install.sh
verify.sh
uninstall.sh
README.md
PACKAGE-MANIFEST.txt
config/
lib/
payload/

Vérification facultative :

ls -la
cat PACKAGE-MANIFEST.txt

3. Vérifier que le pilote GPU et Ollama fonctionnent déjà

Le paquet de déploiement n’installe pas le pilote noyau NVIDIA/AMD de la machine et suppose qu’Ollama est déjà installé.

Pour NVIDIA :

nvidia-smi

Pour AMD :

rocminfo | head

Vérifiez Ollama :

ollama --version
ollama list

Si le pilote GPU lui-même ne fonctionne pas, corrigez ce problème avant de lancer le programme de déploiement.

4. Facultatif : personnaliser le déploiement

Les valeurs par défaut conviennent à un déploiement automatique selon le matériel détecté. Pour les modifier :

cp config/local.env.example config/local.env
nano config/local.env

Valeurs typiques :

MODEL_PROFILE=auto
DOWNLOAD_REF2VA=1
DOWNLOAD_TURBO=1
OLLAMA_MODELS="gemma4:31b-it-qat qwen3.6:35b"
DIRECTOR_MODEL=ollama:gemma4:31b-it-qat

Avec MODEL_PROFILE=auto, le programme choisit le profil H3 selon le GPU et la quantité de VRAM détectés.

Si Hugging Face exige une authentification :

export HF_TOKEN='votre-jeton'

N’enregistrez pas ce jeton dans l’archive.

5. Lancer l’installation

Mode interactif, recommandé :

./install.sh

Le programme affiche d’abord le matériel détecté et les changements qu’il prévoit effectuer. Il demande ensuite :

Continue? [y/N]

Répondez y pour continuer.

Si les permissions exécutables ont été perdues pendant le transfert de l’archive :

chmod +x install.sh verify.sh uninstall.sh
./install.sh

Pour une installation déjà révisée que vous voulez exécuter sans la question de confirmation :

./install.sh --yes

Le programme effectuera essentiellement ceci :

détection du GPU
→ installation des prérequis Ubuntu/Python
→ installation de ComfyUI
→ installation de PyTorch CUDA/ROCm approprié
→ sélection du profil de modèles H3
→ installation de Movie Factory
→ téléchargement des modèles H3
→ téléchargement des modèles Ollama configurés
→ installation des services systemd
→ démarrage de la pile

Les téléchargements de modèles sont volumineux. Le profil complet peut dépasser 90 Go avant les caches Ollama; même les profils élagués représentent plusieurs dizaines de gigaoctets.

6. Vérifier l’installation

Lorsque install.sh est terminé :

./verify.sh

Vérifiez ensuite la cible systemd globale :

sudo systemctl status movie-factory.target

Vous pouvez aussi exécuter directement le diagnostic Movie Factory :

cd ~/movie-factory-blackwell
source .venv/bin/activate
movie-factory doctor

L’état final attendu est :

Workflow    : OK
Nodes       : OK
Wf models   : OK
Status      : READY

7. Après un redémarrage

Le déploiement active Movie Factory avec systemd. Vérifiez son état avec :

sudo systemctl status movie-factory.target
sudo systemctl status movie-factory-comfyui.service
sudo systemctl status movie-factory-prefect.service

Commandes utiles :

sudo systemctl restart movie-factory-comfyui.service
sudo systemctl restart movie-factory-prefect.service

sudo systemctl stop movie-factory.target
sudo systemctl start movie-factory.target

Journaux :

journalctl -u movie-factory-comfyui.service -f
journalctl -u movie-factory-prefect.service -f

8. Premier test de Movie Factory

cd ~/movie-factory-blackwell
source .venv/bin/activate

movie-factory plan \
  "Test Movie" \
  examples/treatment.txt \
  --id test_movie

Examinez :

projects/test_movie/project.yaml

Passez au moins un plan à :

approved: true

Puis :

movie-factory render \
  projects/test_movie/project.yaml \
  --dry-run

Si l’essai à blanc est correct :

movie-factory render projects/test_movie/project.yaml

La version courte

Pour un déploiement automatique normal avec les valeurs par défaut :

tar -xzf movie-factory-deploy.tar.gz
cd movie-factory-deploy
./install.sh
./verify.sh

C’est la façon prévue de lancer l’archive de déploiement.

Politique de sécurité / « pas de sorcellerie »

Pour le chemin d’installation sur une machine déjà préparée, setup.sh n’utilise pas sudo, apt, PPA, dépôts de paquets tiers, remotes Git, systemd, modifications de CUDA ou des pilotes, mises à jour de ComfyUI, installation d’OpenClaw ni téléchargements de modèles.

Le paquet séparé movie-factory-deploy.tar.gz est volontairement différent : son install.sh est un programme d’installation pour machine neuve qui doit être révisé avant exécution. Il utilise sudo pour les paquets Ubuntu et systemd, installe ComfyUI et les dépendances Python, sélectionne PyTorch CUDA ou ROCm, télécharge les modèles H3 configurés et récupère les modèles Ollama configurés. Il n’installe ni ne remplace les pilotes GPU du noyau de l’hôte.

Il crée uniquement l’environnement virtuel local du projet, .env et les métadonnées du paquet Python à l’intérieur de ce projet. Les dépendances Python proviennent du PyPI standard.

Si une étape future nécessite un nouveau dépôt apt, un remote Git, un installateur externe, un service système, un téléchargement de modèle ou une modification similaire à l’échelle de la machine, traitez cela comme une étape distincte et explicite et révisez-la d’abord.

Stratégie de déploiement portable (.tar.gz / .tgz)

Il existe maintenant deux archives distinctes ayant des rôles différents :

movie-factory-blackwell-source.tgz
movie-factory-deploy.tar.gz

movie-factory-blackwell-source.tgz

Il s’agit d’un instantané du code et du projet. Cette archive conserve le code Movie Factory fonctionnel, le JSON du workflow, les exemples, les fichiers de projets et les scripts utilitaires.

Utilisez-la pour :

  • sauvegarder ou déplacer le projet Movie Factory actuel

  • examiner ou modifier le code source

  • restaurer le projet sur une machine où la pile logicielle nécessaire existe déjà

Ce n’est pas le paquet recommandé pour préparer une machine neuve. À elle seule, cette archive n’installe pas les paquets Ubuntu, Python, ComfyUI, PyTorch adapté au GPU, les modèles MiniMax H3, les modèles Ollama ni l’intégration systemd.

movie-factory-deploy.tar.gz

Il s’agit du paquet de déploiement portable pour une nouvelle machine Ubuntu. Utilisez cette archive pour reproduire la pile sur un autre serveur ou poste de travail.

La cible de déploiement actuelle est :

Ubuntu 24.04 LTS
x86_64
un GPU NVIDIA ou AMD
pilote GPU de l’hôte fonctionnel
Ollama déjà installé
Python peut être absent
ComfyUI peut être absent

Le programme de déploiement n’installe ni ne remplace volontairement les pilotes noyau NVIDIA/AMD. Le pilote GPU de la machine doit déjà fonctionner avant le début du déploiement.

Le paquet installe ou configure :

  • les prérequis Ubuntu et Python

  • ComfyUI dans son propre environnement virtuel

  • la sélection du runtime PyTorch NVIDIA CUDA ou AMD ROCm

  • les modèles MiniMax H3 depuis Hugging Face

  • les LoRA Turbo FL2V/Ref2V optionnels

  • les modèles Ollama configurés

  • Movie Factory

  • PydanticAI et Prefect

  • la sélection du checkpoint H3 selon le matériel

  • movie-factory-comfyui.service

  • movie-factory-prefect.service

  • movie-factory.target

  • la vérification après installation

Ollama lui-même est supposé déjà installé. Le paquet de déploiement peut télécharger les modèles Ollama configurés, mais ne remplace pas l’installation d’Ollama.

Déployer sur une autre machine

Copiez l’archive vers la machine cible, par exemple :

scp movie-factory-deploy.tar.gz user@target-host:~/

Puis, sur la machine cible :

cd ~
tar -xzf movie-factory-deploy.tar.gz
cd movie-factory-deploy

Examinez le paquet avant l’installation :

less README.md
cat PACKAGE-MANIFEST.txt

Pour personnaliser la configuration :

cp config/local.env.example config/local.env
nano config/local.env

Les principales valeurs configurables comprennent :

MODEL_PROFILE=auto
DOWNLOAD_REF2VA=1
DOWNLOAD_TURBO=1
OLLAMA_MODELS="gemma4:31b-it-qat qwen3.6:35b"
DIRECTOR_MODEL=ollama:gemma4:31b-it-qat
COMFYUI_ROOT=/home/YOU/comfy/ComfyUI
MOVIE_FACTORY_ROOT=/home/YOU/movie-factory-blackwell

Si Hugging Face exige une authentification ou l’acceptation d’une licence, exportez le jeton dans le shell plutôt que de l’enregistrer dans l’archive de déploiement :

export HF_TOKEN='...'

Lancez l’installation interactive :

./install.sh

Le programme d’installation affiche les changements prévus sur la machine avant de continuer.

Pour une installation sans interaction après avoir déjà vérifié le paquet :

./install.sh --yes

Après l’installation :

./verify.sh

Vous pouvez également exécuter directement le diagnostic Movie Factory :

cd ~/movie-factory-blackwell
source .venv/bin/activate
movie-factory doctor

Une configuration saine devrait se terminer par :

Workflow    : OK
Nodes       : OK
Wf models   : OK
Status      : READY

Profils GPU et modèles automatiques

Avec :

MODEL_PROFILE=auto

le paquet de déploiement sélectionne actuellement :

Matériel Profil automatique Configuration H3
NVIDIA avec au moins 48 Gio de VRAM nvidia-full-int8 INT8 ConvRot complet
NVIDIA avec moins de 48 Gio de VRAM nvidia-pruned-int8 INT8 ConvRot élagué
AMD amd-pruned-int8 INT8 ConvRot élagué

Exemples :

RTX PRO 6000 96 GB -> nvidia-full-int8
RTX 5090 32 GB     -> nvidia-pruned-int8
RX 7900 XTX 24 GB  -> amd-pruned-int8

Pour le profil RTX PRO 6000 96 Go, ComfyUI utilise --highvram. Les profils NVIDIA avec moins de VRAM et les profils AMD utilisent le comportement normal de gestion et de déchargement de la VRAM de ComfyUI.

Le programme d’installation ne modifie dans le workflow API exporté et validé que les noms de fichiers des modèles adaptés au matériel. Il ne reconstruit pas et ne recâble pas dynamiquement le graphe H3.

Pour AMD RDNA3, particulièrement la RX 7900 XTX, le chemin de déploiement est disponible, mais les workflows MiniMax H3 basés sur une image ou une référence doivent actuellement être considérés comme expérimentaux, car des problèmes en amont dans ComfyUI/ROCm peuvent affecter le comportement I2V/R2V. Un movie-factory doctor réussi confirme la compatibilité de l’installation et du workflow, mais pas une parité complète des fonctionnalités entre NVIDIA et AMD.

Emplacements installés

Les emplacements par défaut sont :

~/comfy/ComfyUI
~/movie-factory-blackwell

ComfyUI reçoit son propre environnement :

~/comfy/ComfyUI/.venv

Movie Factory reçoit un environnement séparé :

~/movie-factory-blackwell/.venv

Cette séparation est volontaire.

Démarrage et contrôle des services

Le programme de déploiement crée et active :

movie-factory.target
movie-factory-comfyui.service
movie-factory-prefect.service

Si un ollama.service existant est détecté, movie-factory.target l’inclut également.

Commandes utiles :

sudo systemctl status movie-factory.target
sudo systemctl status movie-factory-comfyui.service
sudo systemctl status movie-factory-prefect.service

sudo systemctl restart movie-factory-comfyui.service
sudo systemctl restart movie-factory-prefect.service

sudo systemctl stop movie-factory.target
sudo systemctl start movie-factory.target

Journaux :

journalctl -u movie-factory-comfyui.service -f
journalctl -u movie-factory-prefect.service -f

Ne faites pas fonctionner un ancien comfyui.service sur le port 8188 en même temps que movie-factory-comfyui.service.

Si vous voulez explicitement que le programme de déploiement désactive un service ComfyUI existant qui entre en conflit, définissez ceci dans config/local.env avant l’installation :

DISABLE_EXISTING_COMFYUI_SERVICE=1

Relancer l’installation et désinstaller

Le programme de déploiement est conçu pour être raisonnablement idempotent. Les paquets apt, environnements virtuels, fichiers de modèles et un dépôt ComfyUI déjà présents peuvent être réutilisés. Il n’exécute pas automatiquement git pull sur un dépôt ComfyUI existant.

Pour supprimer uniquement l’intégration systemd de Movie Factory tout en conservant les applications et les modèles :

./uninstall.sh

Pour supprimer également les répertoires ComfyUI et Movie Factory installés :

PURGE=1 ./uninstall.sh

Ollama et ses modèles ne sont pas supprimés par le script de désinstallation du paquet de déploiement.

Règle de déploiement recommandée

Pour une nouvelle machine, utilisez :

movie-factory-deploy.tar.gz

Pour une sauvegarde du code source, un transfert de développement ou une restauration sur une machine déjà préparée, utilisez :

movie-factory-blackwell-source.tgz

Conservez une version du paquet de déploiement avec l’instantané du code source afin de pouvoir reproduire une version fonctionnelle de Movie Factory sans dépendre de l’état de la station de travail d’origine.

1. Installation sur une machine déjà préparée

Depuis le répertoire du projet :

cd ~/movie-factory-blackwell
./setup.sh
source .venv/bin/activate

L’installation se termine par un diagnostic en lecture seule. Vous pouvez le relancer à tout moment :

movie-factory doctor

Environnement local actuellement validé

La station de travail utilise actuellement :

ComfyUI URL : http://127.0.0.1:8188
ComfyUI root: /home/bruce/comfy/ComfyUI
GPU         : NVIDIA RTX PRO 6000 Blackwell Workstation Edition
VRAM        : ~94.9 GiB reported by ComfyUI

L’environnement virtuel du projet comprend :

PydanticAI  2.49.0
Prefect     3.8.6

Fonctionnement de Doctor

movie-factory doctor valide maintenant le workflow API ComfyUI réellement exporté, plutôt que de s’appuyer sur des noms supposés ou codés en dur de nœuds personnalisés H3.

Il vérifie :

  • la connectivité à ComfyUI via COMFYUI_URL

  • les informations GPU et périphérique rapportées par ComfyUI

  • COMFYUI_ROOT

  • les fichiers de modèles sous COMFYUI_ROOT/models

  • l’existence de workflows/h3_fl2va.api.json

  • chaque class_type unique référencé par le workflow par rapport à /object_info de l’instance ComfyUI active

  • chaque nom de fichier de modèle référencé par le workflow par rapport à l’inventaire local des modèles ComfyUI

Une configuration de base saine rapporte actuellement :

Workflow    : OK
Nodes       : OK
Wf models   : OK
Status      : READY

Si ComfyUI est en cours d’exécution mais que le chemin local ne peut pas être détecté automatiquement, modifiez .env :

COMFYUI_ROOT=/home/bruce/comfy/ComfyUI

2. Inventaire actuel des modèles H3

La pile H3 de base comprend actuellement :

diffusion_models/
  minimax_h3_fl2va_int8_convrot.safetensors
  minimax_h3_ref2va_int8_convrot.safetensors

text_encoders/
  qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors

vae/
  minimax_h3_video_vae_int8_convrot.safetensors
  minimax_h3_audio_vae_fp32.safetensors

loras/
  minimax_h3_fl2v_turbo_4step_v0.1.safetensors

Le workflow de base connu comme fonctionnel ne dépend pas du LoRA Turbo. Turbo demeure une voie d’accélération optionnelle à tester après que le pipeline de base a réussi un rendu complet de bout en bout.

Le modèle REF2VA est installé et sera utile pour de futurs workflows utilisant une image de référence ou nécessitant une cohérence d’identité.

3. Interface utilisateur et serveur Prefect optionnels

Movie Factory peut exécuter les flux Prefect localement sans serveur Prefect.

Pour utiliser le tableau de bord Prefect et l’API d’orchestration persistante, ouvrez un autre terminal :

cd ~/movie-factory-blackwell
./scripts/start-prefect.sh

Le serveur ne devrait écouter que sur :

127.0.0.1:4200

Pour enregistrer les exécutions de Movie Factory dans le serveur Prefect, définissez dans .env :

PREFECT_API_URL=http://127.0.0.1:4200/api

Laissez cette valeur commentée ou non définie lorsque le serveur Prefect n’est pas en cours d’exécution.

4. Workflow H3 validé

Ne reconstruisez pas le graphe H3 à partir de zéro.

Le workflow d’interface ComfyUI connu comme fonctionnel est conservé ici :

workflows/reference/H3_FULL_INT8_20STEP_FLAT.ui.json

Le workflow correspondant au format API utilisé par Movie Factory est :

workflows/h3_fl2va.api.json

Le workflow API actuel contient :

18 API nodes
17 unique node types

et tous les types de nœuds requis sont actuellement disponibles dans l’instance ComfyUI active.

Caractéristiques actuelles du workflow de base

Le workflow exporté utilise actuellement :

Model        : minimax_h3_fl2va_int8_convrot.safetensors
Text encoder : qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
Video VAE    : minimax_h3_video_vae_int8_convrot.safetensors
Audio VAE    : minimax_h3_audio_vae_fp32.safetensors
Sampler      : res_multistep
Scheduler    : simple
Steps        : 20
FPS          : 24
Duration     : 5 seconds
Aspect ratio : 16:9
Megapixels   : 0.4

Le workflow est actuellement piloté par prompt. Le nœud MiniMaxH3ImageToVideo existe dans le graphe, mais aucune entrée d’image externe n’est connectée dans cet export de base.

C’est intentionnel pour l’instant : validez d’abord le pipeline de base original de bout en bout, puis ajoutez un workflow image-vers-vidéo séparé sans modifier ce graphe connu comme fonctionnel.

5. Paramètres de workflow sûrs

Movie Factory ne devrait modifier qu’un petit ensemble documenté d’entrées du workflow.

Pour le workflow API exporté actuel, les correspondances pertinentes sont :

Prompt        -> node 131 / inputs.prompt
Aspect ratio  -> node 115 / inputs.aspect_ratio
Megapixels    -> node 115 / inputs.megapixels
Duration      -> node 133 / inputs.value
Steps         -> node 137 / inputs.value
Seed          -> node 129 / inputs.noise_seed
FPS           -> node 130 / inputs.fps
Output prefix -> node 92  / inputs.filename_prefix

La couche d’orchestration ne devrait pas réécrire arbitrairement les connexions entre nœuds, la sélection du modèle, le câblage du sampler, le câblage du scheduler, les VAE ou les composants internes du décodeur dans la première version.

6. Planifier un film avec PydanticAI

Le backend de réalisation par défaut utilise le service Ollama local.

Exemple de valeurs .env :

OLLAMA_BASE_URL=http://127.0.0.1:11434/v1
DIRECTOR_MODEL=ollama:qwen3.6:35b

Utilisez le modèle local réellement installé et sélectionné pour le travail de réalisation.

Vérifiez les modèles disponibles :

ollama list

Testez la planification :

movie-factory plan \
  "Edmonton Championship Parade" \
  examples/treatment.txt \
  --id edmonton_parade

Sortie attendue :

projects/edmonton_parade/project.yaml

Chaque plan généré commence avec :

approved: false

Révisez le YAML et passez explicitement à true uniquement les plans que vous souhaitez rendre :

approved: true

Si vous ne voulez pas encore faire intervenir le modèle réalisateur, copiez :

examples/project-manual.yaml

et modifiez-le manuellement.

7. Compiler avant le rendu

Compilez une requête ComfyUI concrète sans utiliser de temps GPU :

movie-factory compile \
  projects/edmonton_parade/project.yaml \
  --shot s01_001 \
  --output /tmp/s01_001.api.json

Inspectez :

/tmp/s01_001.api.json

Avant le rendu, confirmez que :

  • la structure du workflow reste intacte

  • seuls les paramètres Movie Factory approuvés ont changé

  • les noms de modèles correspondent toujours à la configuration de base validée

  • le câblage sampler/scheduler demeure inchangé

  • le nom du fichier de sortie est raisonnable

8. Exécuter un essai à blanc du projet approuvé

movie-factory render \
  projects/edmonton_parade/project.yaml \
  --dry-run

L’essai à blanc doit compiler chaque plan approuvé sans rien soumettre à ComfyUI.

Utilisez-le pour vérifier l’analyse du projet, l’approbation des plans, l’injection des paramètres et les charges utiles API générées avant d’utiliser du temps GPU.

9. Rendu

Lorsque le graphe compilé a été vérifié :

movie-factory render \
  projects/edmonton_parade/project.yaml

Le chemin d’exécution prévu est :

project.yaml
    ↓
Validation Movie Factory
    ↓
Flux Prefect
    ↓
Injection sécurisée des paramètres du workflow
    ↓
POST /prompt vers ComfyUI :8188
    ↓
Interrogation de l’historique ComfyUI
    ↓
Sortie SaveVideo
    ↓
renders/

Movie Factory soumet un plan à la fois au service ComfyUI existant.

Pour chaque prompt terminé, il enregistre l’historique ComfyUI sous :

renders/

La première version limite volontairement la concurrence à une seule tâche.

La RTX PRO 6000 possède beaucoup plus de VRAM qu’une 3060 12 Go, mais plusieurs rendus H3 simultanés peuvent tout de même réduire le débit en se disputant les mêmes ressources de calcul GPU. Mesurez d’abord les performances; le parallélisme viendra ensuite.

10. Profils

Le README original définissait :

draft      : 704×384, 8 steps, ref_image_size=match
production : 1024×576, 8 steps, ref_image_size=match
hero       : 1024×576, 20 steps, ref_image_size=max

Ces définitions de profils doivent maintenant être considérées comme provisoires jusqu’à ce qu’elles soient harmonisées avec le workflow exporté et validé.

La configuration de base actuellement connue comme fonctionnelle est :

16:9
0.4 megapixels
20 steps
24 fps
5 seconds

Ne forcez pas silencieusement des valeurs de profil qui modifient de façon importante le graphe connu comme fonctionnel tant que le chemin de rendu de base n’a pas été validé.

Tous les futurs profils devraient continuer de laisser le sampler, le scheduler, le modèle, les LoRA, les VAE et la configuration du décodeur réellement fonctionnels dans le workflow ComfyUI exporté, plutôt que de les deviner ou de les reconstruire en Python.

11. Chemin prévu image-vers-film

Un objectif important à court terme est une commande image-vers-vidéo simple comme :

movie-factory render \
  --image ~/Pictures/scene.jpg \
  --prompt "Cinematic dusk, slow camera push-in, natural movement." \
  --duration 5

N’ajoutez pas cette fonction au workflow de base connu comme fonctionnel en recâblant dynamiquement le graphe.

Créez plutôt un second workflow ComfyUI avec une véritable entrée d’image connectée, vérifiez-le manuellement, puis exportez-le au format API, par exemple :

workflows/h3_i2v.api.json

Movie Factory pourra ensuite :

  1. téléverser ou copier l’image source vers le mécanisme d’entrée de ComfyUI

  2. définir le nom de fichier LoadImage

  3. modifier uniquement les entrées documentées et sûres

  4. soumettre le graphe image-vers-vidéo connu comme fonctionnel

  5. récupérer la vidéo rendue

Les futures variantes de workflow liées aux images pourraient inclure :

h3_i2v.api.json
h3_ref2va.api.json
h3_fl2va_turbo.api.json

Gardez chaque workflow séparé et validé plutôt que de construire les graphes dynamiquement.

12. OpenClaw

OpenClaw est optionnel.

L’architecture principale demeure :

PydanticAI
    ↓
Prefect
    ↓
ComfyUI
    ↓
MiniMax H3

Si OpenClaw est ajouté plus tard, il devrait se placer au-dessus ou à côté de l’API ou de l’interface en ligne de commande de Movie Factory comme opérateur pratique en langage naturel.

Il ne devrait pas remplacer Prefect ni modifier directement du JSON arbitraire de workflow ComfyUI.

Un futur modèle sûr serait :

OpenClaw
    ↓
Outil/API Movie Factory
    ↓
PydanticAI
    ↓
Prefect
    ↓
ComfyUI

13. Ce qui n’est volontairement pas encore automatisé

Les éléments suivants restent hors de la première configuration de base validée :

  • téléchargement automatique des modèles

  • mises à niveau de ComfyUI et des nœuds personnalisés

  • basculement automatique entre checkpoints et LoRA

  • recâblage dynamique du graphe

  • chemin simplifié image-vers-vidéo

  • routage REF2VA

  • sélection du workflow Turbo

  • génération de scénarimages avec Qwen-Image

  • passe d’agrandissement SeedVR2

  • génération musicale ACE-Step

  • vérification des dialogues avec Whisper

  • contrôle qualité visuel et de continuité

  • montage final et multiplexage avec FFmpeg

  • rendu H3 multi-GPU ou parallèle

Ces éléments constituent la couche suivante, une fois que le chemin du README original fonctionne de bout en bout :

plan
→ compile
→ dry-run
→ un rendu réel

Dépannage

does not appear to be a Python project

Une copie complète doit contenir :

pyproject.toml
src/movie_factory/cli.py

setup.sh vérifie la présence des métadonnées du projet avant d’exécuter pip.

Au besoin :

cd ~/movie-factory-blackwell
source .venv/bin/activate
python -m pip install -e .

movie-factory: command not found

Assurez-vous que l’environnement virtuel du projet est actif :

cd ~/movie-factory-blackwell
source .venv/bin/activate

Vérifiez :

echo "$VIRTUAL_ENV"
command -v movie-factory

Les chemins attendus devraient se trouver sous :

/home/bruce/movie-factory-blackwell/.venv

Si le point d’entrée CLI est toujours absent :

python -m pip install -e .
hash -r

ComfyUI fonctionne dans le navigateur, mais Doctor échoue

Vérifiez :

curl http://127.0.0.1:8188/system_stats

Puis inspectez :

COMFYUI_URL
COMFYUI_ROOT

dans .env.

Les valeurs actuellement fonctionnelles sont :

COMFYUI_URL=http://127.0.0.1:8188
COMFYUI_ROOT=/home/bruce/comfy/ComfyUI

Trouver le véritable répertoire ComfyUI en cours d’exécution

Trouvez le processus :

pgrep -af 'ComfyUI|main.py'

Puis inspectez son répertoire de travail courant :

readlink -f /proc/<PID>/cwd

Pour la station de travail actuelle, cela donne :

/home/bruce/comfy/ComfyUI

Vérifier manuellement la compatibilité des nœuds du workflow API

Affichez les classes de nœuds uniques du workflow :

jq -r '.[].class_type' \
  workflows/h3_fl2va.api.json \
  | sort -u

Comparez-les à l’instance ComfyUI active :

comm -23 \
  <(jq -r '.[].class_type' workflows/h3_fl2va.api.json | sort -u) \
  <(curl -s http://127.0.0.1:8188/object_info | jq -r 'keys[]' | sort -u)

Si cette commande n’affiche rien, tous les types de nœuds du workflow sont disponibles.

La planification ne peut pas se connecter à Ollama

Vérifiez :

ollama list
curl http://127.0.0.1:11434/api/tags

Si le nom du modèle local choisi est différent, mettez à jour :

DIRECTOR_MODEL

dans .env.

Prochaine étape immédiate

N’ajoutez pas d’autres variantes de workflow tant que le pipeline original n’a pas été validé.

La prochaine séquence est :

movie-factory plan --help
movie-factory compile --help
movie-factory render --help

Puis :

plan
→ inspecter project.yaml
→ approuver un plan
→ compiler
→ inspecter le JSON API
→ exécuter render --dry-run
→ rendre un vrai plan

Une fois cela fonctionnel, ajoutez le workflow image-vers-vidéo séparé et simplifiez l’utilisation de --image.