root 642d53a927 PLAN.md: Produktions-DB Schema, Verzeichnisstruktur, Statusmaschine, Orchestrator-Logik, CLI

2026-03-16 12:11:04 +07:00

40 KiB

Raw Blame History

KI-Video — Lokale Produktionspipeline

Stand: 16.03.2026

Ziel

Lokale, praktisch nutzbare Produktionsstrecke fuer YouTube-Videos im Commentary-/Erklaerstil. Kein Spielzeug-Demo, kein Forschungsprojekt: Thema rein → fertiges Video raus.

Videoformat

Referenz-Stil: "Geld & Imperien" / "Money & People" (YouTube, geopolitische Commentary-Kanaele) Beispielvideos:

https://youtu.be/4XfhrrbklbM (24 Min, "Irans Hyperschall-Schlag", Geld & Imperien)
https://youtu.be/MIkAOwJYaP0 (19 Min, "Irans Machtuebernahme", Money & People)

Eigenschaft	Beschreibung
Typ	Commentary, Erklaervideos, Meinungs-/Analyseformate
Laenge	10-30 Minuten
Stil	Professionelle Erzaehlstimme + Bilder + Karten + Infografiken + Text-Overlays + Ken-Burns
Avatar	Sprechender KI-Avatar als PiP-Overlay (~20% Bildschirm, unten rechts)
Kein	Echte Face-Cam, Realfilm, Hollywood-VFX

Avatar-Konzept (Picture-in-Picture)

┌─────────────────────────────────────────────────────────┐
│                                                         │
│                  HAUPTBILD (80%)                         │
│           Karten, Infografiken, Szenenbilder             │
│           Ken-Burns, Zoom, Ueberblendungen               │
│                                                         │
│                                                         │
│                                                         │
│                                         ┌─────────────┐ │
│                                         │             │ │
│                                         │   AVATAR    │ │
│                                         │   (~20%)    │ │
│                                         │  lip-sync   │ │
│                                         │  sprechend  │ │
│                                         └─────────────┘ │
└─────────────────────────────────────────────────────────┘
  1920 x 1080 (Full HD)

Avatar-Overlay:
  - Groesse: ~384 x 384 px (20% der Bildhoehe)
  - Position: unten rechts, 40px Padding
  - Hintergrund: halbtransparenter Kreis oder abgerundetes Rechteck
  - Inhalt: Sprechende Person (SadTalker) synchron zum Voiceover
  - Stil: professionell, Brustbild, neutraler Hintergrund

Der Avatar laeuft DURCHGEHEND waehrend des gesamten Videos. Das Referenzbild fuer SadTalker ist ein einmalig generiertes Portraet (FLUX/SDXL). Die Lippenbewegung wird aus dem XTTS-Voiceover-Audio abgeleitet.

Anatomie eines 20-Min-Videos (Referenz)

Element	Menge	Beschreibung
Skript	~3500-5000 Woerter	Monolog, professioneller Ton, analytisch
Szenenbilder	80-120 Stueck	Karten, Infografiken, Symbolbilder, Illustrationen
Hero-Bilder	10-15 Stueck	Hochwertige Key-Visuals fuer Titelszenen/Kapitelwechsel
Text-Overlays	20-40 Stueck	Zahlen, Namen, Fakten als Einblendung
Avatar-Video	20 Min (durchgehend)	SadTalker lip-sync, PiP unten rechts, ~20% Bildschirm
Voiceover	20 Min Audio	XTTS v2, natuerliche deutsche Maennerstimme
Hintergrundmusik	1-2 Tracks	Ambient, dezent, lizenzfrei
Uebergaenge	~80-120	Ken-Burns, Ueberblendungen, Zoom-Ins

Produktions-Pipeline (5 GPUs parallel)

Kernidee: Phase 1 = Cloud-LLM (Skript), Phase 2 = alle 5 lokale GPUs parallel, Phase 3 = Assembly. Skriptqualitaet ist der Flaschenhals — deshalb Cloud-LLM fuer Kreativarbeit, lokale GPUs fuer Massenproduktion.

PHASE 1 — SKRIPT + SZENENPLAN (~15-30 Min, Cloud + lokal)
═════════════════════════════════════════════════════════
Thema + Recherche-Notizen (manuell)
  │
  ▼
GPT-5.4 (OpenAI API) → Skript (~4000 Woerter, 20 Min Lesezeit)
  │                      Persoenlichkeit, Meinung, Storytelling, Stil
  │                      Kosten: ~0.10-0.50 EUR pro Skript
  │
  ▼
Menschliches Review (~20-30 Min) → Korrektur, Feinschliff, Faktencheck
  │
  ▼
Qwen 14B (lokal, vLLM, :8401) → Szenenplan aus fertigem Skript:
             100 Szenen mit je:
             - Bildprompt (EN, fuer FLUX/SDXL)
             - Szenentyp (hero / standard / infografik / karte)
             - Text-Overlay (falls noetig)
             - Geschaetzte Dauer (Sekunden)
  │
  ▼
Skript + Szenenplan als JSON → Orchestrator

Warum hybrid?
- GPT-5.4 fuer Skripte: beste Qualitaet, Persoenlichkeit, deutsche Sprache auf Top-Niveau
- Qwen 14B lokal fuer Szenenplan: strukturierte JSON-Generierung, braucht keine Kreativitaet
- Kein Vendor-Lock: Skript kann auch mit Claude, Gemini o.ae. generiert werden
- Kosten pro Video: ~0.10-0.50 EUR (irrelevant vs. Stromkosten der GPUs)

PHASE 2a — TTS-VOICEOVER (3080 #0, ~15 Min, startet sofort)
═════════════════════════════════════════════════════════════
  Orchestrator schickt Skript-Text an XTTS v2 Worker.
  Output: 20 Min deutsches Voiceover als WAV-Datei.
  Muss VOR SadTalker fertig sein (Avatar braucht Audio als Input).

PHASE 2b — PARALLEL-PRODUKTION (alle 5 GPUs, ~30-40 Min)
══════════════════════════════════════════════════════════

  ┌──────────────────────────────────────────────────────────────────┐
  │                    ORCHESTRATOR (ki-tower CPU)                    │
  │         Verteilt Jobs, pollt Status, sammelt Ergebnisse          │
  └──────┬──────────┬──────────┬──────────┬──────────┬───────────────┘
         │          │          │          │          │
         ▼          ▼          ▼          ▼          ▼
  ┌──────────┐┌──────────┐┌──────────┐┌──────────┐┌──────────┐
  │ 3090     ││ 3080 #0  ││ 3080 #1  ││ 3080 #2  ││ 3080 #3  │
  │ ki-tower ││ Worker   ││ Worker   ││ Worker   ││ Worker   │
  │          ││          ││          ││          ││          │
  │ FLUX.1   ││ SDXL     ││ SDXL     ││ SadTalker││ ESRGAN   │
  │ Hero-    ││ Standard-││ Standard-││ AVATAR   ││ Upscale  │
  │ Bilder   ││ Szenen   ││ Szenen   ││ lip-sync ││ + Whisper│
  │ 15 Stk   ││ ~50 Stk  ││ ~50 Stk  ││ 20 Min   ││ Untertit.│
  │ ~15 Min  ││ ~25 Min  ││ ~25 Min  ││ ~25 Min  ││ ~10 Min  │
  └──────────┘└──────────┘└──────────┘└──────────┘└──────────┘

  Ablauf 3080 #0: XTTS v2 Voiceover (15 Min) → sobald fertig → SDXL Bilder (10 Min)
  Ablauf 3080 #2: Wartet auf Voiceover → SadTalker Avatar (25 Min, GPU-intensivster Job)
  Alle anderen starten sofort parallel.
  Engpass = SadTalker Avatar-Rendering (~25 Min fuer 20 Min Video).

  SadTalker-Details:
  - Input: Referenz-Portraet (einmalig generiert) + Voiceover-Audio (aus Phase 2a)
  - Output: 20 Min Video (384x384 px) mit synchroner Lippenbewegung
  - Verarbeitung in ~30s-Clips, sequentiell auf 3080 #2
  - ~6 GB VRAM (passt auf 10 GB 3080)
  - Laengster Einzeljob → bestimmt Gesamtdauer Phase 2

PHASE 3 — ASSEMBLY + EXPORT (ki-tower, seriell, ~15-20 Min)
════════════════════════════════════════════════════════════
  │
  ▼
FFmpeg: Bilder + Ken-Burns + Zoom + Ueberblendungen → Hintergrund-Video
  │
  ▼
FFmpeg: Avatar-PiP compositen (unten rechts, 384x384, halbtransparenter Rahmen)
  │  ┌─────────────────────────────────────────────┐
  │  │ Hauptbild (Szene/Karte/Infografik)          │
  │  │                                              │
  │  │                                              │
  │  │                              ┌──────────┐   │
  │  │                              │ Avatar   │   │
  │  │                              │ lip-sync │   │
  │  │                              └──────────┘   │
  │  └─────────────────────────────────────────────┘
  │
  ▼
FFmpeg: Audio-Mix (Voiceover + Hintergrundmusik + Lautstaerke-Normalisierung)
  │
  ▼
FFmpeg: Text-Overlays (Fakten, Zahlen, Namen) einbrennen
  │
  ▼
FFmpeg: Untertitel (SRT aus Whisper) einbetten
  │
  ▼
NVENC: H.264/H.265 Encoding → fertiges MP4 (1080p)
  │
  ▼
Export: Thumbnail (FLUX hero-Bild, upscaled) + Titel + Description + Tags

Zeitschaetzung: 20-Minuten-Video mit Avatar

Phase	Dauer	GPUs aktiv	Engpass
1. Skript + Szenenplan	~15 Min	1 (3090)	LLM-Inferenz
2a. TTS-Voiceover	~15 Min	1 (3080 #0)	XTTS v2 Inferenz
2b. Parallel-Produktion	~25 Min	5 (alle)	SadTalker Avatar
3. Assembly + Export	~20 Min	1 (3090 NVENC)	FFmpeg PiP-Compositing
Gesamt	~75 Min

SadTalker ist jetzt der Engpass (statt Bildgenerierung). 20 Min Lip-Sync-Video auf 3080 = ~25 Min Renderzeit. Zum Vergleich: Seriell auf nur 1 GPU = ~5-6 Stunden.

GPU-Auslastung waehrend Phase 2

GPU	Schritt 1	Dauer	Schritt 2 (wenn fertig)	Dauer	Output
3090	FLUX.1-dev Hero-Bilder	~15 Min	idle / Thumbnail-Varianten	~5 Min	15 Key-Visuals
3080 #0	XTTS v2 Voiceover	~15 Min	SDXL Restbilder	~10 Min	20 Min Audio + ~20 Bilder
3080 #1	SDXL Standard-Szenen	~25 Min	—	—	~50 Szenenbilder
3080 #2	(wartet auf Audio)	—	SadTalker Avatar	~25 Min	20 Min Lip-Sync-Video (384x384)
3080 #3	Real-ESRGAN Upscaling	~5 Min	Whisper → SRT	~5 Min	Upscaled Bilder + Untertitel

Ablauf-Kette: TTS muss vor SadTalker fertig sein (Audio → Lip-Sync). Deshalb: 3080 #0 macht zuerst TTS, dann SDXL. 3080 #2 wartet auf Audio, dann SadTalker. Alle anderen GPUs starten sofort.

Konkretes Beispiel: "Irans Hyperschall-Schlag" (24 Min)

So wuerde ein Video im Stil von "Geld & Imperien" durch die Pipeline laufen:

INPUT:
  Thema: "Irans neue Hyperschallrakete — geopolitische und wirtschaftliche Folgen"
  Recherche: 3-4 Quellenlinks, eigene Stichpunkte

PHASE 1 — Skript + Szenenplan:
  ├── GPT-5.4 (Cloud): Skript ~4500 Woerter, 24 Min Lesezeit
  │   "Was ich euch heute zeige, veraendert die Welt..."
  │   Kapitel: Waffentechnik → Strategie → Oel → Europa → Fazit
  │   → Mensch reviewt und korrigiert (~20 Min)
  │
  └── Qwen 14B (lokal): Szenenplan (JSON) aus fertigem Skript: 105 Szenen
      Szene 001: { typ: "hero",   prompt: "dramatic missile launch, night sky, photorealistic",
                   overlay: "Mach 15 — Irans Hyperschallwaffe", dauer: 8s }
      Szene 002: { typ: "karte",  prompt: "middle east map, iran highlighted, military bases marked",
                   overlay: null, dauer: 12s }
      Szene 003: { typ: "standard", prompt: "patriot missile defense system, desert, realistic photo",
                   overlay: "Patriot-System: $3 Mio pro Abfangrakete", dauer: 10s }
      ...
      Szene 105: { typ: "hero",   prompt: "world map with shifting power balance, dramatic lighting",
                   overlay: "Die neue Weltordnung", dauer: 15s }

PHASE 2a — TTS zuerst (3080 #0, 15 Min):
  3080 #0: XTTS v2 → 24 Min deutsches Voiceover (WAV)

PHASE 2b — Alles parallel (alle 5 GPUs, 25 Min):
  3090:    15 Hero-Bilder (FLUX.1-dev) → Titel, Kapitelwechsel, Outro
  3080 #0: (TTS fertig) → 30 Standardbilder (SDXL) → Militaer, Wirtschaft
  3080 #1: 50 Standardbilder (SDXL) → Karten, Infografiken, Symbolbilder
  3080 #2: SadTalker → 24 Min Avatar-Video (384x384, lip-sync aus Voiceover)
  3080 #3: Upscaling aller Bilder auf 1920x1080 + Whisper → Untertitel-SRT

PHASE 3 — Assembly (20 Min):
  FFmpeg: 105 Szenen × Ken-Burns/Zoom → Hintergrund-Videospur
  FFmpeg: Avatar-PiP compositen (unten rechts, 20%, halbtransparenter Rahmen)
  FFmpeg: Audio-Mix (Voiceover + Ambient-Musik)
  FFmpeg: Text-Overlays + Untertitel einbrennen
  NVENC:  H.265 Encoding
  Output: "irans-hyperschall-2026-03.mp4" (1080p, ~1.5 GB)
  Bonus:  Thumbnail + YouTube-Description + Tags

Gesamtzeit: ~75 Minuten fuer ein 24-Minuten-Video mit sprechendem Avatar. Fertig zum Hochladen.

Hardware

ki-tower — Hauptmaschine (Muldenstein, geplant)

Eigenschaft	Wert
CPU	AMD Ryzen 7 7700 (8C/16T)
RAM	64 GB DDR5
GPU	NVIDIA RTX 3090 (24 GB VRAM)
Storage	1 TB NVMe
OS	Debian 12 + Docker + CUDA
Logischer Name	ki-tower
Rolle	Chef. Alle schweren Aufgaben, Orchestrierung, Hauptpfad.

gpu-worker — NVIDIA-Rig (Muldenstein, geplant) — PRIMAERER WORKER

Eigenschaft	Wert
GPUs	4x NVIDIA RTX 3080 (je 10 GB GDDR6X, PCIe 4.0 x16)
CUDA	Voll unterstuetzt, identischer Stack wie ki-tower
OS	Debian 12 + Docker + CUDA
Logischer Name	gpu-worker
Rolle	Produktiver Worker-Pool. CUDA-nativ, kein Workaround noetig.
Vorteil	Selber Code wie auf der 3090 — kein Portierungsaufwand.

gpu-reserve — AMD-Rig (Muldenstein, Reserve)

Eigenschaft	Wert
GPUs	8x AMD RX 6600 XT Dual (je 8 GB GDDR6, PCIe 4.0 x8)
ROCm	Inoffiziell (gfx1032, Workaround noetig)
Logischer Name	gpu-reserve
Rolle	Reserve/Nebenrolle. Nur Whisper + CPU-Batch wenn 3080-Rig ausgelastet.
Status	Zurueckgestellt. Entscheidung nach 3080-Rig-Aufbau. Alternative: verkaufen.

Rollenverteilung — Was laeuft wo

Cloud — Skript-Generierung

Aufgabe	Modell	Kosten	Anmerkung
Skripte	GPT-5.4 (OpenAI API)	~0.10-0.50 EUR/Skript	Persoenlichkeit, Storytelling, Meinung

Skriptqualitaet ist der Flaschenhals. Kein lokales Modell kommt an GPT-5.4 ran fuer kreatives, meinungsstarkes, deutsches Storytelling. Cloud-Kosten sind vernachlaessigbar.

ki-tower (RTX 3090) — Hauptpfad

Aufgabe	Modell	VRAM	Anmerkung
Szenenplan	Qwen 2.5 14B (Q5)	~12 GB	Strukturiertes JSON aus fertigem Skript. Braucht keine Kreativitaet.
Hero-Bilder	FLUX.1-dev	~12 GB	Hochwertige Key-Visuals (Kapitelwechsel, Titel, Outro)
Compositing	FFmpeg	CPU	Ken-Burns + Avatar-PiP + Overlays + Audio-Mix
Encoding	FFmpeg + NVENC	~1 GB	Hardware-beschleunigt
Orchestrator	Python	CPU	Steuert alle Schritte, verteilt Jobs an Worker

3090 macht NUR: Szenenplan (Qwen) + Hero-Bilder (FLUX) + Assembly. Skripte kommen fertig aus der Cloud. TTS + Avatar machen die 3080er.

gpu-worker (4x RTX 3080) — Produktive Worker-Jobs

3080	Primaeraufgabe	VRAM	Sekundaeraufgabe	Anmerkung
#0	XTTS v2 (Voiceover)	~4 GB	→ SDXL Restbilder (~7 GB)	TTS zuerst, dann Bilder
#1	SDXL (Standard-Szenen)	~7 GB	—	Bildgenerierung durchgehend
#2	SadTalker (Avatar)	~6 GB	—	Lip-Sync, laengster Job, wartet auf Audio
#3	Real-ESRGAN + Whisper	~3 GB	Thumbnail-Varianten	Upscaling + Untertitel

Feste Zuordnung pro Video-Produktion. Kein dynamisches Scheduling. Kernvorteil: Identischer CUDA-Stack wie ki-tower.

gpu-reserve (8x RX 6600 XT) — Reserve/Nebenrolle

Aufgabe	VRAM	Karten	Anmerkung
Whisper (whisper.cpp)	~1.5 GB	1-2	Einziger gut getesteter AMD-Usecase
CPU-Batch-Jobs	—	—	Piper TTS, FFmpeg, Text-Vorverarbeitung

Realistisch nutzbar: 1-2 Karten fuer Whisper, Rest bringt kaum Mehrwert. Empfehlung: Erst aufbauen wenn 3080-Rig voll ausgelastet. Alternative: verkaufen.

NICHT auf das AMD-Rig

Aufgabe	Warum nicht
SDXL / Bildgenerierung	ROCm inoffiziell, CUDA-Version laeuft auf 3080 besser
XTTS v2	PyTorch + ROCm ungetestet, auf 3080 CUDA-nativ
SadTalker	CUDA-only
Qwen / LLMs	PyTorch + ROCm + Textgen = Frust auf inoffizieller HW
Irgendwas Produktionskritisches	Workaround-basierte HW darf Produktion nicht blockieren

Hardware-Priorisierung: 3080 vs. 6600 XT

Klare Rangfolge:

Rang	Hardware	Rolle	Begruendung
1	RTX 3090 (ki-tower)	Chef	24 GB VRAM, schwere Modelle, Orchestrierung
2	4x RTX 3080 (gpu-worker)	Produktiver Worker	CUDA-nativ = selber Code wie ki-tower. 10 GB VRAM pro Karte reicht fuer SDXL, XTTS, SadTalker, Whisper. Kein Portierungsaufwand.
3	8x RX 6600 XT (gpu-reserve)	Reserve / ggf. verkaufen	ROCm inoffiziell. Jeder Usecase, den die 6600 XT kann, kann die 3080 besser + einfacher. Einziger Vorteil: Kartenanzahl fuer massiv-paralleles Whisper. Realistisch nicht gebraucht.

Warum 4x 3080 > 8x 6600 XT:

Gleicher Software-Stack wie ki-tower (CUDA). Code einmal schreiben, ueberall deployen.
10 GB VRAM vs. 8 GB VRAM. Klingt wenig, macht bei SDXL/SadTalker den Unterschied.
PyTorch + CUDA ist getestet, stabil, dokumentiert. ROCm auf Navi 23 ist Kampf.
Weniger Karten = weniger Strom, weniger Kuehlung, weniger moegliche Fehlerquellen.
4 parallele CUDA-Worker decken den gesamten Bedarf ab.

Empfehlung AMD-Rig: Nicht aktiv aufbauen. Falls 3080-Rig irgendwann an Kapazitaetsgrenzen stoesst: 1-Karten-Test mit Whisper. Wenn selbst das nicht lohnt: verkaufen und in NVMe-Storage oder RAM investieren.

Produktions-Datenbank + Orchestrierung

Zentrale Steuerung: eine SQLite-Datei (production.db) auf ki-tower. Alles passiert hier: Kanaele, Videos, Szenen, Jobs, Assets, Status.

Datenbank-Schema

-- Kanaele (je einer pro YouTube-Kanal)
CREATE TABLE channels (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,           -- "Geld & Imperien Stil"
    slug        TEXT UNIQUE NOT NULL,    -- "kanal-a"
    avatar_path TEXT NOT NULL,           -- "/data/channels/kanal-a/avatar.png"
    voice_path  TEXT NOT NULL,           -- "/data/channels/kanal-a/voice-sample.wav"
    style       TEXT NOT NULL,           -- "pip_20" oder "fullscreen"
    prompt_template TEXT,                -- System-Prompt fuer GPT-5.4 Skripte (Ton, Stil, Persoenlichkeit)
    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- Videos (ein Eintrag pro Video)
CREATE TABLE videos (
    id          INTEGER PRIMARY KEY,
    channel_id  INTEGER REFERENCES channels(id),
    title       TEXT NOT NULL,           -- "Irans Hyperschall-Schlag"
    topic       TEXT,                    -- Thema + Recherche-Notizen
    status      TEXT DEFAULT 'draft',    -- draft → script → scenes → producing → assembly → review → published
    script      TEXT,                    -- Fertiges Skript (aus GPT-5.4 + Review)
    scene_plan  TEXT,                    -- JSON: Szenenplan (aus Qwen 14B)
    voiceover_path TEXT,                 -- Pfad zur fertigen WAV
    avatar_path TEXT,                    -- Pfad zum fertigen Avatar-Video
    subtitle_path TEXT,                  -- Pfad zur SRT-Datei
    final_path  TEXT,                    -- Pfad zum fertigen MP4
    thumbnail_path TEXT,                 -- Pfad zum Thumbnail
    yt_title    TEXT,                    -- YouTube-Titel
    yt_description TEXT,                 -- YouTube-Description
    yt_tags     TEXT,                    -- YouTube-Tags (JSON array)
    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP,
    published_at DATETIME
);

-- Szenen (aus dem Szenenplan, je eine Zeile pro Szene)
CREATE TABLE scenes (
    id          INTEGER PRIMARY KEY,
    video_id    INTEGER REFERENCES videos(id),
    scene_nr    INTEGER NOT NULL,
    scene_type  TEXT NOT NULL,           -- "hero", "standard", "karte", "infografik"
    prompt      TEXT NOT NULL,           -- Bildprompt (EN)
    overlay     TEXT,                    -- Text-Overlay (oder NULL)
    duration_s  REAL NOT NULL,           -- Geschaetzte Dauer in Sekunden
    image_path  TEXT,                    -- Pfad zum generierten Bild (nach Produktion)
    upscaled    BOOLEAN DEFAULT 0,
    status      TEXT DEFAULT 'pending'   -- pending → generating → done → failed
);

-- GPU-Jobs (jede Aufgabe die ein Worker erledigt)
CREATE TABLE jobs (
    id          INTEGER PRIMARY KEY,
    video_id    INTEGER REFERENCES videos(id),
    job_type    TEXT NOT NULL,           -- "tts", "sdxl", "flux", "sadtalker", "whisper", "esrgan", "assembly"
    gpu         TEXT,                    -- "3090", "3080_0", "3080_1", "3080_2", "3080_3"
    status      TEXT DEFAULT 'queued',   -- queued → running → done → failed → retry
    input_data  TEXT,                    -- JSON: was der Worker braucht
    output_path TEXT,                    -- Pfad zum Ergebnis
    error       TEXT,                    -- Fehlermeldung falls failed
    queued_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
    started_at  DATETIME,
    finished_at DATETIME
);

Verzeichnisstruktur

/data/ki-video/
├── production.db                    # SQLite — zentrale Steuerung
│
├── channels/                        # Pro Kanal
│   ├── kanal-a/
│   │   ├── avatar.png               # Referenz-Portraet (FLUX-generiert)
│   │   ├── voice-sample.wav         # XTTS Voice-Cloning Referenz (~30s)
│   │   ├── style.json               # { "avatar": "pip_20", "position": "bottom_right" }
│   │   └── prompt.md                # GPT-5.4 System-Prompt (Persoenlichkeit, Ton, Stil)
│   └── kanal-b/
│       ├── avatar.png               # Anderes Gesicht
│       ├── voice-sample.wav         # Andere Stimme
│       ├── style.json               # { "avatar": "fullscreen" }
│       └── prompt.md                # Anderer Stil/Persoenlichkeit
│
├── videos/                          # Pro Video ein Ordner
│   ├── 2026-03-16-iran-hyperschall/
│   │   ├── script.md                # Fertiges Skript
│   │   ├── scenes.json              # Szenenplan
│   │   ├── images/
│   │   │   ├── hero-001.png
│   │   │   ├── scene-002.png
│   │   │   ├── scene-003.png
│   │   │   └── ...                  # 80-120 Bilder
│   │   ├── audio/
│   │   │   ├── voiceover.wav        # XTTS v2 Output
│   │   │   └── music.mp3            # Hintergrundmusik
│   │   ├── avatar/
│   │   │   ├── clip-001.mp4         # SadTalker 30s-Clips
│   │   │   ├── clip-002.mp4
│   │   │   └── full.mp4             # Zusammengefuegt
│   │   ├── subtitles.srt            # Whisper → SRT
│   │   ├── thumbnail.png            # FLUX hero + Text
│   │   └── final.mp4                # FERTIGES VIDEO
│   └── 2026-03-18-oelpreis-analyse/
│       └── ...
│
└── templates/
    ├── ffmpeg-pip20.sh              # FFmpeg-Preset: 20% Avatar unten rechts
    ├── ffmpeg-fullscreen.sh         # FFmpeg-Preset: 100% Avatar
    ├── ffmpeg-kenburns.sh           # Ken-Burns-Effekt Presets
    └── music/                       # Lizenzfreie Hintergrundmusik
        ├── ambient-01.mp3
        └── ambient-02.mp3

Produktions-Ablauf (Statusmaschine)

                    ┌──────────────────────────────────────────────────┐
                    │                                                  │
  ┌─────────┐      │  ┌──────────┐    ┌──────────┐    ┌───────────┐  │
  │  draft   │──────┼─►│  script  │───►│  scenes  │───►│ producing │  │
  │          │      │  │          │    │          │    │           │  │
  │ Thema    │      │  │ GPT-5.4  │    │ Qwen 14B │    │ 5 GPUs    │  │
  │ anlegen  │      │  │ + Review │    │ Szenen-  │    │ parallel  │  │
  └─────────┘      │  └──────────┘    │ plan     │    └─────┬─────┘  │
                    │                  └──────────┘          │        │
                    │                                        ▼        │
                    │  ┌───────────┐    ┌──────────┐   ┌──────────┐  │
                    │  │ published │◄───│  review  │◄──│ assembly │  │
                    │  │           │    │          │    │          │  │
                    │  │ YouTube   │    │ Mensch   │    │ FFmpeg   │  │
                    │  │ Upload    │    │ schaut   │    │ PiP/Full │  │
                    │  └───────────┘    └──────────┘   └──────────┘  │
                    │                                                  │
                    └──────────────────────────────────────────────────┘

Status-Uebergaenge:
  draft     → script     : Mensch gibt Thema ein, startet GPT-5.4 Skript
  script    → scenes     : Mensch reviewt Skript, bestaetigt, Qwen generiert Szenenplan
  scenes    → producing  : Orchestrator erstellt Jobs fuer alle 5 GPUs
  producing → assembly   : Alle GPU-Jobs fertig (TTS + Avatar + Bilder + Untertitel)
  assembly  → review     : FFmpeg Assembly fertig, Video liegt als MP4 vor
  review    → published  : Mensch schaut Video, gibt frei, Upload

Orchestrator-Logik (Python, laeuft auf ki-tower)

Alle 10 Sekunden:
  1. Checke videos WHERE status = 'scenes'
     → Erstelle GPU-Jobs:
       - 1x TTS-Job (3080 #0)
       - N x SDXL-Jobs (3080 #0 nach TTS, #1)
       - M x FLUX-Jobs (3090, nur hero-Szenen)
       - 1x Whisper-Job (3080 #3, nach TTS)
       - 1x ESRGAN-Job (3080 #3, nach Bilder)
       - 1x SadTalker-Job (3080 #2, nach TTS)

  2. Checke jobs WHERE status = 'queued'
     → Pruefe ob Abhaengigkeiten erfuellt:
       - SadTalker wartet auf TTS (voiceover.wav muss existieren)
       - Whisper wartet auf TTS
       - ESRGAN wartet auf Bilder
     → Sende an Worker via HTTP REST

  3. Checke jobs WHERE status = 'running'
     → Polle Worker-Status
     → Bei done: speichere output_path, update status
     → Bei failed: retry (max 3x), dann menschliche Aufmerksamkeit

  4. Checke videos WHERE status = 'producing'
     AND alle zugehoerigen jobs.status = 'done'
     → Starte Assembly-Job (FFmpeg)
     → Status → 'assembly'

  5. Checke videos WHERE status = 'assembly'
     AND assembly-job.status = 'done'
     → Status → 'review'
     → Benachrichtigung an Telegram (Hausmeister-Bot!)

CLI fuer den Alltag

# Neues Video anlegen
./produce.py new --channel kanal-a --topic "Irans Hyperschall-Schlag"

# Status aller Videos
./produce.py status
#  ID | Kanal   | Thema                    | Status     | Fortschritt
#  42 | kanal-a | Irans Hyperschall-Schlag | producing  | 3/5 Jobs done
#  43 | kanal-b | Oelpreis-Analyse 2026    | script     | Review pending

# Skript bestaetigen und Produktion starten
./produce.py approve-script 42

# Fertiges Video reviewen und freigeben
./produce.py publish 42 --yt-upload

# GPU-Auslastung
./produce.py gpus
#  GPU      | Status  | Job           | Video | Progress
#  3090     | busy    | flux-hero     | #42   | 8/15 images
#  3080 #0  | busy    | sdxl-batch    | #42   | 23/50 images
#  3080 #1  | busy    | sdxl-batch    | #42   | 31/50 images
#  3080 #2  | busy    | sadtalker     | #42   | 12:30/24:00
#  3080 #3  | idle    | —             | —     | waiting for images

Worker-Architektur

ki-tower (3090, Chef)                    gpu-worker (4x 3080, Worker)       gpu-reserve (RX 6600 XT)
┌─────────────────────────┐              ┌──────────────────────────────┐   ┌──────────────────┐
│ Orchestrator (Python)    │              │ Debian 12 + Docker + CUDA   │   │ Reserve/Whisper  │
│ ├── production.db        │   Tailscale  │                              │
│ ├── /api/submit-job      │◄────────────►│ GPU #0: xtts+sdxl      :8501 │   │ Whisper :8601   │
│ ├── /api/job-status      │              │ GPU #1: sdxl-worker    :8502 │   │ CPU-Batch :8602 │
│ └── /api/get-result      │   Tailscale  │ GPU #2: sadtalker      :8503 │   │ (nur bei Bedarf)│
│                          │              │ GPU #3: esrgan+whisper :8504 │   └──────────────────┘
│ Qwen 14B  (vLLM)  :8401 │              │                              │
│ FLUX.1    (ComfyUI):8402 │              │ 10 GB VRAM pro Karte         │
│ FFmpeg    (lokal)        │              │ CUDA-nativ, kein Workaround  │
└─────────────────────────┘              └──────────────────────────────┘

VRAM-Budget (ki-tower, sequentiell)

Schritt 1: Skript       → Qwen 14B      → ~12 GB VRAM
Schritt 2: Bilder       → FLUX.1-dev    → ~12 GB VRAM
Schritt 3: TTS          → Piper (CPU)   → 0 GB VRAM
Schritt 4: Compositing  → FFmpeg (CPU)  → 0 GB VRAM
Schritt 5: Encoding     → NVENC         → ~1 GB VRAM

Mit Qwen 14B statt 32B: kein VRAM-Flush zwischen Schritt 1 und 2 noetig.

Geschaetzte Produktionszeit:

v1 (nur ki-tower, seriell, ohne Avatar): ~2-3 Stunden pro 10-Min-Video
v1.5 (5 GPUs parallel, mit Avatar): ~75 Min pro 20-Min-Video
Langfristig mit Optimierung: ~60 Min pro 20-Min-Video

Nicht-Ziele

Kein Forschungsprojekt
Keine Bastelwiese ohne Ergebnis
Keine Dauerabhaengigkeit von Cloud-Abos
Keine Architektur die nur auf dem Papier funktioniert
Keine ueberkomplizierte Proxmox-/VM-Orgie auf dem Rig
Kein Schoenreden von AMD-ROCm-Limitierungen

v1 — Minimal Viable Pipeline (nur ki-tower)

v1 beweist: die Pipeline funktioniert auf einer Maschine. Schritte manuell anstossen.

v1 Pipeline (alles auf ki-tower, seriell):

Thema (manuell)
  │
  ▼
Qwen 14B → Skript + Szenenplan (vLLM, :8401)
  │
  ▼
FLUX.1-dev → 30-50 Bilder (ComfyUI, :8402)      ← seriell, ~30-45 Min
  │
  ▼
Piper TTS → Voiceover (CPU, :8504)                ← parallel moeglich
  │
  ▼
FFmpeg → Ken-Burns + Audio + Overlays → fertiges MP4

Was v1 NICHT hat:

Kein 3080 Worker-Rig (alles seriell auf 3090)
Keinen Avatar
Keine XTTS v2 (Piper reicht fuer v1)
Keine automatische Orchestrierung
Geschaetzte Produktionszeit: ~2-3 Stunden pro 10-Min-Video

Erfolgskriterium v1: Ein 10-Minuten-Video komplett lokal produziert.

v1.5 — 5-GPU-Parallelisierung + Avatar (ki-tower + 3080-Rig)

v1.5 ist der grosse Sprung: 5 GPUs parallel + sprechender Avatar.

v1.5 Pipeline (5 GPUs parallel, mit Avatar):

Thema (manuell)
  │
  ▼
Qwen 14B → Skript + Szenenplan JSON (ki-tower)
  │
  ▼
Orchestrator Phase 2a (TTS zuerst):
  └── 3080 #0: XTTS v2 → 20 Min deutsches Voiceover (WAV)
  │
  ▼
Orchestrator Phase 2b (alle 5 GPUs parallel):
  ├── 3090:    FLUX.1-dev → Hero-Bilder
  ├── 3080 #0: (TTS fertig) → SDXL Restbilder
  ├── 3080 #1: SDXL → Standard-Szenen
  ├── 3080 #2: SadTalker → 20 Min Avatar-Video (lip-sync, 384x384)
  └── 3080 #3: Real-ESRGAN + Whisper → Upscaling + Untertitel
  │
  ▼
FFmpeg → Assembly:
  ├── Hintergrund: Bilder + Ken-Burns + Zoom
  ├── Avatar-PiP: unten rechts, ~20% Bildschirm, halbtransparenter Rahmen
  ├── Audio-Mix: Voiceover + Hintergrundmusik
  ├── Text-Overlays + Untertitel
  └── NVENC Export → MP4 + Thumbnail + YouTube-Metadaten

Was v1.5 bringt:

Sprechender Avatar als PiP durchgehend im Video (~20% Bildschirm)
XTTS v2 statt Piper (natuerlichere Stimme, Voice-Cloning)
Produktionszeit: ~75 Min statt ~5-6 Stunden fuer 20-Min-Video
Automatische Untertitel
Orchestrator verteilt und sammelt automatisch

Erfolgskriterium v1.5: 20-Min-Video mit Avatar in unter 90 Minuten produziert.

Avatar-Referenzbild (einmalig)

Das Portraet fuer SadTalker wird EINMAL generiert und dann fuer alle Videos wiederverwendet. So entsteht ein konsistenter "Sprecher" / "Moderator" fuer den Kanal.

Generierung (einmalig, auf 3090 mit FLUX.1-dev):
  Prompt: "professional male news anchor, german, mid-30s, neutral expression,
           chest up portrait, clean studio background, photorealistic, 8k"
  Output: referenz-avatar.png (512x512)
  Nachbearbeitung: ggf. manuelles Feintuning in GIMP/Photoshop

SadTalker nutzt dann:
  - referenz-avatar.png (festes Bild)
  - voiceover.wav (pro Video neu)
  → Output: avatar-video.mp4 (384x384, 25fps, lip-sync)

v2 — Erweiterungen (nach funktionierender v1.5)

Feature	Abhaengigkeit
Avatar-Varianten	Verschiedene Gesichtsausdruecke/Posen je Szene
Mehrere Sprecher	Zweiter Avatar fuer Interview-/Dialog-Format
Qwen 32B statt 14B	Nur wenn 14B-Skripte nachweislich zu schwach
Batch-Produktion	Mehrere Videos in Queue, automatisch nacheinander
YouTube-Upload-API	Automatischer Upload mit Metadaten

v3+ — Spaeter

Feature	Anmerkung
YouTube-Upload-Automation	Manueller Upload = 2 Klicks. Lohnt erst bei >3 Videos/Woche
Multi-User / geklonte Instanzen	Erst ein funktionierendes Produkt haben
Prompt-Templates Bibliothek	Waechst organisch mit der Produktion
Research-Hub-Integration	Themenvorschlaege automatisch aus RSS/News

Umsetzungsreihenfolge

PHASE 1 — ki-tower Grundinstallation (Woche 1-2)
├── Debian 12 + NVIDIA-Treiber + CUDA 12 + Docker
├── vLLM + Qwen 2.5 14B → erster Skript-Test
└── Ergebnis: "Ich kann lokal ein Skript generieren"

PHASE 2 — Bildgenerierung (Woche 3-4)
├── ComfyUI + FLUX.1-dev in Docker
├── Workflow: Skript-Szene → Bildprompt → Bild
└── Ergebnis: "Ich kann passende Bilder zu einem Skript erzeugen"

PHASE 3 — TTS + Assembly (Woche 5)
├── Piper TTS in Docker (CPU)
├── FFmpeg-Pipeline: Bilder + Audio → Video mit Ken-Burns
└── Ergebnis: "Erstes komplettes Video, lokal produziert"

PHASE 4 — Polieren + erstes echtes Video (Woche 6)
├── Prompt-Templates fuer Skripte verfeinern
├── FFmpeg-Presets fuer verschiedene Szenentypen
├── Erstes Video auf YouTube hochladen
└── Ergebnis: "v1 steht und produziert"

PHASE 5 — 3080-Rig Aufbau + v1.5 mit Avatar (Woche 7-10)
├── Debian 12 + NVIDIA-Treiber + CUDA + Docker (selber Stack wie ki-tower)
├── 4 Worker: XTTS+SDXL, SDXL, SadTalker, ESRGAN+Whisper
├── Tailscale + Job-API anbinden
├── SadTalker Avatar einrichten:
│   ├── Referenz-Portraet generieren (FLUX auf 3090)
│   ├── SadTalker Docker-Container auf 3080 #2
│   ├── Lip-Sync Pipeline: Audio → 30s-Clips → zusammenfuegen
│   └── Test: 5-Min-Testvideo mit Avatar-PiP
├── XTTS v2 statt Piper (bessere Stimme, Voice-Cloning)
├── FFmpeg PiP-Compositing: Avatar unten rechts, ~20% Bildschirm
├── Python-Orchestrator: TTS → SadTalker → Bilder → Assembly
└── Ergebnis: "20-Min-Video mit Avatar in unter 90 Min, 5 GPUs parallel"

PHASE 6 — v2 Features (nach stabiler v1.5-Produktion)
├── Avatar-Varianten: verschiedene Ausdruecke/Posen je Kapitel
├── Automatische Thumbnail-Generierung (FLUX hero + Text-Overlay)
├── YouTube-Metadaten-Generator (Titel, Description, Tags aus Skript)
├── Batch-Produktion: mehrere Videos in Queue
└── Ergebnis: "Semi-automatische Videoproduktion mit Worker-Pool"

PHASE 7 — AMD-Rig Entscheidung (optional, spaeter)
├── Bewertung ob 3080-Rig Kapazitaet reicht
├── Falls nicht: 1-Karten-Test mit RX 6600 XT + Whisper
├── Falls ja: AMD-Rig verkaufen, Erloese in Storage investieren
└── Ergebnis: "Klare Entscheidung ueber AMD-Hardware"

Entscheidungen (getroffen)

Frage	Entscheidung	Begruendung
OS ki-tower	Debian 12	Einfacher fuer GPU, Docker, kein Hypervisor-Overhead
OS gpu-worker	Debian 12	Identisch mit ki-tower, CUDA-nativ, kein Sonderweg
Worker-Rig	4x RTX 3080	CUDA-nativ > 8x RX 6600 XT mit ROCm-Workarounds
Skript-LLM	GPT-5.4 (Cloud)	Beste Qualitaet fuer Kreativarbeit. ~0.10-0.50 EUR/Skript.
Szenenplan-LLM	Qwen 14B (lokal)	Strukturiertes JSON aus Skript, braucht keine Kreativitaet.
LLM-Server (lokal)	vLLM	Schneller als llama.cpp bei Batch, Model-Unloading
Bildgenerierung	ComfyUI + FLUX.1-dev	Flexibel, Workflow-basiert, gute Qualitaet
TTS v1	Piper TTS (CPU)	Kein GPU-Verbrauch, sofort einsatzbereit
TTS v2	XTTS v2 (3090 oder 3080)	Voice-Cloning, natuerlichere Stimme. 4 GB VRAM, passt auf 3080.
Avatar	SadTalker, ab v1.5	PiP ~20% unten rechts, durchgehend im Video. Kernbestandteil.
Job-Queue	SQLite	Ein User, kein Redis/RabbitMQ noetig
Netzwerk	Tailscale	Verbindet ki-tower + gpu-worker, fertig

Risiken

#	Risiko	Wahrscheinlichkeit	Impact	Mitigation
1	ROCm auf RX 6600 XT instabil	Hoch	Niedrig	Betrifft nur Reserve-Rig. 3080-Worker ist CUDA-nativ.
2	Piper TTS deutsch zu robotisch	Mittel	Mittel	v1-only-Problem. XTTS v2 ab v1.5 loest das. OpenAI TTS als Bruecke (~0.50€/Video).
3	VRAM-Tetris auf 3090	Mittel	Mittel	14B statt 32B. Sequentiell. vLLM Model-Unloading.
4	Pipeline wird zu komplex vor v1	Hoch	Hoch	v1 brutal einfach. Bash-Scripts, keine Frameworks.
5	SadTalker Qualitaet/Artefakte	Mittel	Hoch	Avatar ist Kernbestandteil. Wenn Lip-Sync schlecht: LivePortrait oder Wav2Lip als Alternative testen. Fallback: Avatar nur bei Kapitelwechseln (5-10% Screentime statt durchgehend).
6	SadTalker Renderzeit 20+ Min	Mittel	Mittel	30s-Clips parallel auf 2 GPUs verteilen wenn noetig. Oder Resolution reduzieren (256x256).
7	Stromkosten Rig vs. Nutzen	Mittel	Niedrig	3080-Rig nur bei Batch-Jobs einschalten. AMD-Rig im Zweifel verkaufen.

Kosten-Schaetzung

Posten	Einmalig	Monatlich
ki-tower Hardware	vorhanden	—
gpu-worker Hardware	vorhanden	—
Strom ki-tower (24/7)	—	~30-40 EUR
Strom gpu-worker (bei Bedarf)	—	~10-30 EUR (nicht 24/7)
GPT-5.4 API (Skripte)	—	~3-15 EUR (6-24 Skripte/Monat)
Cloud-APIs (Fallback TTS)	—	~5-10 EUR
Gesamt	0 EUR	~50-95 EUR

Zum Vergleich: Vollstaendig cloud-basierte Videoproduktion (Runway, ElevenLabs, GPT-4) = 100-300 EUR/Monat. Die GPT-5.4-Kosten fuer Skripte sind der beste ROI im ganzen Projekt: ~0.50 EUR fuer ein Skript, das ein lokales 14B-Modell qualitativ nie erreichen wuerde.

40 KiB Raw Blame History Unescape Escape