# KI-Video — Lokale Produktionspipeline **Stand: 16.03.2026** ## Ziel Lokale, produktiv nutzbare Pipeline fuer YouTube-Videos im Commentary-/Erklaerstil. Thema rein → fertiges Video raus. Kein Forschungsprojekt, kein Proof-of-Concept. ## Videoformat Referenz-Stil: **"Geld & Imperien"** / **"Money & People"** (YouTube) - https://youtu.be/4XfhrrbklbM (24 Min, Geld & Imperien) - https://youtu.be/MIkAOwJYaP0 (19 Min, Money & People) | Eigenschaft | v1 | |---|---| | **Typ** | Commentary, Erklaervideo, Analyse | | **Laenge** | 10-30 Minuten | | **Visuell** | Mixed Media: KI-Bilder + Stock-Fotos + echte Karten + Daten-Charts + Text-Overlays + Ken-Burns | | **Stimme** | XTTS v2, natuerliche deutsche Maennerstimme, Voice-Cloning | | **Untertitel** | Automatisch (faster-whisper → SRT) | | **Avatar** | **Nein.** Erst ab v1.5 als optionaler PiP-Test. | | **Kein** | Face-Cam, Realfilm, Vollbild-Avatar, Piper TTS | Das fertige Video besteht aus: Mixed Media (KI-Bilder + Stock-Fotos + Karten + Charts) mit Ken-Burns-Effekten + Voiceover + Hintergrundmusik + Text-Overlays + eingebrannte Untertitel. Entscheidend: KI-Bilder nur dort wo sie stark sind (Symbolik, Stimmung, Thumbnails). Reale Fotos, Karten und Diagramme dort wo Fakten gezeigt werden. ### Anatomie eines 20-Min-Videos | Element | Menge | Quelle | |---|---|---| | **Skript** | ~3500-5000 Woerter | GPT-5.4 (Cloud) + menschliches Review | | **Szenenplan** | ~100 Szenen (JSON) | Qwen 14B (lokal) | | **Hero-Bilder** | 10-15 Stueck | FLUX.1-dev (3090), fuer Thumbnails + Kapitelwechsel | | **Konzept-Bilder** | 30-40 Stueck | SDXL (3080), symbolisch/abstrakt wo KI stark ist | | **Stock-Fotos** | 20-30 Stueck | Pexels/Pixabay API (CPU), reale Orte/Personen/Ereignisse | | **Karten** | 5-10 Stueck | MapLibre/OSM (CPU), echte Geografie statt KI-Karten | | **Daten-Charts** | 5-10 Stueck | matplotlib (CPU), Oelpreis/BIP/Inflation aus echten Daten | | **Voiceover** | 20 Min WAV | XTTS v2 (3080) | | **Untertitel** | SRT-Datei | faster-whisper (3080) | | **Hintergrundmusik** | 1-2 Tracks | Lizenzfrei, manuell gewaehlt | | **Text-Overlays** | 20-40 Stueck | FFmpeg (aus Szenenplan) | Bildmix-Logik: Der Szenenplan bestimmt pro Szene den Typ. Nicht alles KI-generiert. KI fuer Stimmung/Symbolik, Stock fuer Realitaet, Karten fuer Geografie, Charts fuer Daten. ## v1 — Produktions-Pipeline ### Prinzip ``` GPT-5.4 (Cloud) → Qwen 14B (lokal) → 5 GPUs parallel → FFmpeg → MP4 Skript Szenenplan Bilder + Voice Assembly ``` Kein Avatar. Kein dynamisches Scheduling. Kein Service-Mesh. 5 GPUs feste Zuordnung + CPU-Module (Stock/Chart/Map), SQLite als Zustand, Python als Orchestrator. ### Pipeline-Schritte ``` PHASE 1 — SKRIPT + SZENENPLAN (~30 Min, Cloud + lokal + Mensch) ═══════════════════════════════════════════════════════════════ Thema + Recherche-Notizen (manuell) │ ▼ GPT-5.4 (OpenAI API) → Skript (~4000 Woerter) │ Kosten: ~0.10-0.50 EUR ▼ Mensch reviewt, korrigiert, gibt frei (~20 Min) │ ▼ Qwen 14B (vLLM, :8401) → Szenenplan (JSON): 100 Szenen mit je: - Szenentyp: hero | concept | stock | map | chart | person - Bildprompt (EN, fuer hero/concept) ODER Suchbegriff (fuer stock/person) ODER Geodaten (fuer map) ODER Datenquelle+Range (fuer chart) - Text-Overlay (oder null) - Dauer in Sekunden │ ▼ Orchestrator uebernimmt PHASE 2 — PARALLEL-PRODUKTION (GPUs + CPU, ~15-20 Min) ══════════════════════════════════════════════════════ ┌──────────────────────────────────────────────────────────┐ │ ORCHESTRATOR (ki-tower, Python) │ │ Verteilt Jobs, pollt Status, sammelt Ergebnisse │ └──────┬──────────┬──────────┬──────────┬──────────────────┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌──────────┐┌──────────┐┌──────────┐┌──────────────────────┐ │ 3090 ││ 3080 #0 ││ 3080 #1 ││ 3080 #2 + #3 │ │ ki-tower ││ Worker ││ Worker ││ Worker │ │ ││ ││ ││ │ │ FLUX.1 ││ XTTS v2 ││ SDXL ││ SDXL │ Whisper │ │ Hero- ││ Voice ││ Konzept- ││ Konzept-│ + ESRGAN │ │ Bilder ││ → SDXL ││ Bilder ││ Bilder │ Untertit. │ │ 10-15 St ││ → Rest ││ ~20 Stk ││ ~20 Stk │ + Upscale │ │ ~10 Min ││ ~15 Min ││ ~10 Min ││ ~10 Min │ ~5 Min │ └──────────┘└──────────┘└──────────┘└──────────────────────┘ ┌──────────────────────────────────────────────────────────┐ │ CPU-PARALLEL (ki-tower, laueft gleichzeitig mit GPUs) │ │ │ │ Stock-Fetcher → Pexels/Pixabay API → 20-30 Fotos ~30s │ │ Chart-Gen → matplotlib/plotly → 5-10 Charts ~10s │ │ Map-Renderer → MapLibre/OSM → 5-10 Karten ~30s │ │ Person-Fetcher → Wikimedia Commons → Portraits ~10s │ │ │ │ Gesamt CPU-Media: <60 Sekunden (parallel zu GPU-Jobs) │ └──────────────────────────────────────────────────────────┘ Alle GPUs + CPU starten SOFORT. Keine Abhaengigkeitskette. 3080 #0: XTTS v2 Voiceover (~15 Min), danach SDXL Restbilder. 3080 #3: Whisper (braucht Audio, wartet auf #0) + ESRGAN parallel. CPU-Module brauchen <60 Sek und sind fertig bevor die erste GPU-Szene steht. Engpass = XTTS v2 Voiceover (~15 Min). Bildgenerierung ist jetzt schneller weil nur noch ~50 KI-Bilder statt ~100 (Rest = Stock/Karten/Charts). PHASE 3 — ASSEMBLY (ki-tower, ~10-15 Min) ══════════════════════════════════════════ FFmpeg: Bilder + Ken-Burns + Zoom + Ueberblendungen → Videospur FFmpeg: Audio-Mix (Voiceover + Hintergrundmusik) FFmpeg: Text-Overlays einbrennen FFmpeg: Untertitel (SRT) einbetten NVENC: H.265 Encoding → fertiges MP4 (1080p) Export: Thumbnail (FLUX hero-Bild) + Titel + Description + Tags ``` ### Zeitschaetzung: 20-Min-Video (ohne Avatar) | Phase | Dauer | GPUs/CPU | Engpass | |---|---|---|---| | 1. Skript + Szenenplan | ~30 Min | 1 (3090) + Cloud | Mensch (Review) | | 2. Parallel-Produktion | ~15 Min | 5 GPUs + CPU | XTTS v2 Voiceover | | 3. Assembly | ~10 Min | 1 (3090 NVENC) | FFmpeg Compositing | | **Gesamt (Maschine)** | **~25 Min** | | | | **Gesamt (inkl. Mensch)** | **~55 Min** | | | Mixed Media verschiebt den Engpass: Statt ~100 KI-Bilder auf GPU nur noch ~50. CPU-Module (Stock/Karten/Charts) liefern den Rest in <60 Sekunden. Neuer Engpass = XTTS v2 (~15 Min fuer 20 Min Audio), nicht mehr Bildgenerierung. ### GPU-Zuordnung v1 | GPU | Aufgabe | VRAM | Dauer | Output | |---|---|---|---|---| | **3090** | Qwen 14B (Szenenplan) → FLUX.1-dev (Hero-Bilder) | 12 GB | ~10 Min | 10-15 hochwertige Key-Visuals | | **3080 #0** | XTTS v2 (Voiceover) → SDXL (Restbilder) | 4→7 GB | ~15 Min | 20 Min Audio + ~10 Bilder | | **3080 #1** | SDXL (Konzept-Szenen) | 7 GB | ~10 Min | ~20 Bilder | | **3080 #2** | SDXL (Konzept-Szenen) | 7 GB | ~10 Min | ~20 Bilder | | **3080 #3** | faster-whisper (Untertitel) + Real-ESRGAN (Upscaling) | 3 GB | ~5 Min | SRT + upscaled Thumbnails | | **CPU** | Stock-Fetcher + Chart-Gen + Map-Renderer + Person-Fetcher | 0 | <1 Min | 30-50 Medien-Dateien | KI-Bilder: **~50 Stueck in ~10-15 Minuten** (3x SDXL + 1x FLUX). CPU-Medien: **~50 Stueck in <60 Sekunden** (Stock/Karten/Charts, parallel). 3080 #3 ist nach ~5 Min fertig und idle — kann bei Bedarf auch SDXL uebernehmen. ## Hardware ### ki-tower (RTX 3090, 24 GB) | 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 | | Rolle | Chef: Szenenplan (Qwen), Hero-Bilder (FLUX), Assembly (FFmpeg), Orchestrator | ### gpu-worker (4x RTX 3080, je 10 GB) | Eigenschaft | Wert | |---|---| | GPUs | 4x NVIDIA RTX 3080 (je 10 GB GDDR6X) | | OS | Debian 12 + Docker + CUDA (identisch mit ki-tower) | | Rolle | Worker: XTTS v2, SDXL-Batch, Whisper, ESRGAN | | Vorteil | Selber CUDA-Stack — Code einmal schreiben, ueberall deployen | ### gpu-reserve (8x RX 6600 XT) — NICHT in v1 Zurueckgestellt. Kein Aufbau, keine Planung, keine Ressourcen. Entscheidung nach 3 Monaten produktiver v1: behalten oder verkaufen. ## Rollenverteilung ### Cloud: GPT-5.4 → Skripte Skriptqualitaet ist der Flaschenhals. Kein lokales Modell liefert Persoenlichkeit, Meinung und natuerliches deutsches Storytelling auf diesem Niveau. Kosten: ~0.10-0.50 EUR/Skript. Irrelevant vs. Stromkosten. ### ki-tower (3090): Szenenplan + Hero-Bilder + Assembly | Dienst | Tool | Port | VRAM | |---|---|---|---| | Szenenplan-LLM | Qwen 2.5 14B (vLLM) | :8401 | ~12 GB | | Hero-Bilder | FLUX.1-dev (ComfyUI) | :8402 | ~12 GB | | Assembly | FFmpeg + NVENC | — | ~1 GB | | Orchestrator | Python | — | CPU | Schritte laufen sequentiell auf der 3090. Erst Qwen (Szenenplan), dann FLUX (Bilder), dann FFmpeg (Assembly). Kein VRAM-Flush noetig (14B = 12 GB, FLUX = 12 GB). ### gpu-worker (3080): Voice + Bilder + Untertitel | GPU | Dienst | Tool | Port | VRAM | |---|---|---|---|---| | #0 | TTS → Bilder | XTTS v2 → SDXL | :8501 | 4 → 7 GB | | #1 | Bilder | SDXL | :8502 | 7 GB | | #2 | Bilder | SDXL | :8503 | 7 GB | | #3 | Untertitel + Upscaling | faster-whisper + Real-ESRGAN | :8504 | 3 GB | 1 Container pro GPU. HTTP-API pro Worker. Orchestrator auf ki-tower pollt Status. Tailscale verbindet ki-tower und gpu-worker. ## Produktions-Datenbank Zentrale Steuerung: **`production.db`** (SQLite) auf ki-tower. ### Schema ```sql CREATE TABLE channels ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, slug TEXT UNIQUE NOT NULL, voice_path TEXT NOT NULL, -- XTTS Voice-Cloning Referenz prompt_template TEXT, -- GPT-5.4 System-Prompt (Persoenlichkeit) created_at DATETIME DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE videos ( id INTEGER PRIMARY KEY, channel_id INTEGER REFERENCES channels(id), title TEXT NOT NULL, topic TEXT, status TEXT DEFAULT 'draft', -- draft→script→scenes→producing→assembly→review→published script TEXT, scene_plan TEXT, -- JSON voiceover_path TEXT, subtitle_path TEXT, final_path TEXT, thumbnail_path TEXT, yt_title TEXT, yt_description TEXT, yt_tags TEXT, created_at DATETIME DEFAULT CURRENT_TIMESTAMP, published_at DATETIME ); CREATE TABLE scenes ( id INTEGER PRIMARY KEY, video_id INTEGER REFERENCES videos(id), scene_nr INTEGER NOT NULL, scene_type TEXT NOT NULL, -- hero | concept | stock | map | chart | person prompt TEXT, -- Bildprompt (hero/concept) oder null query TEXT, -- Suchbegriff (stock/person) oder null data_source TEXT, -- Datenquelle (chart) oder Geodaten (map) oder null overlay TEXT, duration_s REAL NOT NULL, image_path TEXT, status TEXT DEFAULT 'pending' -- pending→generating→done→failed ); CREATE TABLE jobs ( id INTEGER PRIMARY KEY, video_id INTEGER REFERENCES videos(id), job_type TEXT NOT NULL, -- tts | sdxl | flux | whisper | esrgan | assembly -- | stock_fetch | chart_gen | map_render | person_fetch gpu TEXT, status TEXT DEFAULT 'queued', -- queued→running→done→failed input_data TEXT, output_path TEXT, error TEXT, queued_at DATETIME DEFAULT CURRENT_TIMESTAMP, started_at DATETIME, finished_at DATETIME ); ``` ### Verzeichnisstruktur ``` /data/ki-video/ ├── production.db ├── channels/ │ └── kanal-a/ │ ├── voice-sample.wav # XTTS Referenz (~30s) │ └── prompt.md # GPT-5.4 Persoenlichkeits-Prompt ├── videos/ │ └── 2026-03-16-iran-hyperschall/ │ ├── script.md │ ├── scenes.json │ ├── images/ │ │ ├── hero/ # FLUX Hero-Bilder (10-15) │ │ ├── concept/ # SDXL Konzept-Bilder (30-40) │ │ ├── stock/ # Pexels/Pixabay Fotos (20-30) │ │ ├── map/ # MapLibre/OSM Karten (5-10) │ │ ├── chart/ # matplotlib Charts (5-10) │ │ └── person/ # Wikimedia Portraits │ ├── audio/ │ │ ├── voiceover.wav │ │ └── music.mp3 │ ├── subtitles.srt │ ├── thumbnail.png │ └── final.mp4 └── templates/ ├── ffmpeg-kenburns.sh └── music/ ``` ### Statusmaschine ``` draft → script → scenes → producing → assembly → review → published draft : Thema angelegt script : GPT-5.4 Skript + menschliches Review scenes : Qwen generiert Szenenplan producing : 5 GPUs arbeiten parallel (Bilder + Voice + Untertitel) assembly : FFmpeg baut Video zusammen review : Mensch schaut fertiges Video published : YouTube-Upload ``` ### Orchestrator (Python, ki-tower) ``` Alle 10 Sekunden: 1. videos WHERE status = 'scenes' → Jobs erstellen nach Szenentyp: hero/concept → GPU-Jobs (FLUX/SDXL) stock/person → CPU-Jobs (stock_fetch/person_fetch) map → CPU-Jobs (map_render) chart → CPU-Jobs (chart_gen) + 1x TTS, 1x Whisper, 1x ESRGAN 2. jobs WHERE status = 'queued' → GPU-Jobs: Abhaengigkeiten pruefen → An Worker senden (HTTP REST) → CPU-Jobs: Sofort lokal ausfuehren (Stock/Chart/Map-Module) 3. jobs WHERE status = 'running' → GPU-Worker pollen, Status updaten → CPU-Jobs sind synchron, Status sofort done/failed 4. Alle Jobs eines Videos done? → Assembly-Job starten (FFmpeg) 5. Assembly done? → Status → 'review' → Telegram-Benachrichtigung (Hausmeister-Bot) ``` ### CLI ```bash ./produce.py new --channel kanal-a --topic "Oelpreis-Krise 2026" ./produce.py status ./produce.py approve-script 42 ./produce.py publish 42 ./produce.py gpus ``` ## Worker-Architektur ``` ki-tower (3090) gpu-worker (4x 3080) ┌─────────────────────────┐ ┌──────────────────────────────┐ │ Orchestrator (Python) │ │ Debian 12 + Docker + CUDA │ │ ├── production.db │ Tailscale │ │ │ ├── /api/submit-job │◄────────────►│ #0: xtts+sdxl :8501 │ │ ├── /api/job-status │ │ #1: sdxl :8502 │ │ └── /api/get-result │ │ #2: sdxl :8503 │ │ │ │ #3: whisper+esrgan :8504 │ │ Qwen 14B (vLLM) :8401 │ │ │ │ FLUX.1 (ComfyUI):8402 │ │ 10 GB VRAM pro Karte │ │ FFmpeg (lokal) │ │ CUDA-nativ │ └─────────────────────────┘ └──────────────────────────────┘ ``` ## Media-Module (CPU, ki-tower) Vier Python-Module die der Orchestrator lokal ausfuehrt. Kein GPU, kein externer Service. Laufen parallel zu GPU-Jobs, brauchen <60 Sekunden fuer alle Szenen zusammen. ### Stock-Fetcher (~50 Zeilen) ```python # Pexels API (kostenlos, 200 Requests/Std) def fetch_stock(query: str, output_path: str) -> str: resp = requests.get("https://api.pexels.com/v1/search", params={"query": query, "per_page": 3, "orientation": "landscape"}, headers={"Authorization": PEXELS_KEY}) url = resp.json()["photos"][0]["src"]["large2x"] # 1920px download(url, output_path) return output_path ``` - **Fallback**: Pixabay API (ebenfalls kostenlos) wenn Pexels kein Ergebnis - **Bildgroesse**: 1920x1280 (wird per ffmpeg auf 1920x1080 zugeschnitten) - **Lizenz**: Pexels-Lizenz erlaubt kommerzielle Nutzung ohne Attribution ### Chart-Generator (~80 Zeilen) ```python # matplotlib + yfinance/FRED fuer echte Wirtschaftsdaten def generate_chart(data_source: str, date_range: str, title: str, output_path: str) -> str: data = fetch_data(data_source, date_range) fig, ax = plt.subplots(figsize=(19.2, 10.8), dpi=100) ax.plot(data.index, data.values, color="#e63946", linewidth=2.5) ax.set_title(title, fontsize=32, fontweight="bold", color="white") fig.patch.set_facecolor("#1a1a2e") ax.set_facecolor("#1a1a2e") fig.savefig(output_path, dpi=100, bbox_inches="tight") return output_path ``` - **Datenquellen**: yfinance (Aktien, Oel, Gold), FRED API (BIP, Inflation), World Bank - **Stil**: Dunkler Hintergrund, passend zum Video-Look (konfigurierbar pro Kanal) - **Output**: 1920x1080 PNG, direkt als Szene verwendbar ### Map-Renderer (~60 Zeilen) ```python # Statische Karte via Mapbox Static API (kostenlos bis 50k/Monat) def render_map(center: list, zoom: int, markers: list, style: str, output_path: str) -> str: marker_str = ",".join([f"pin-s+e63946({m['lon']},{m['lat']})" for m in markers]) url = (f"https://api.mapbox.com/styles/v1/mapbox/{style}/static/" f"{marker_str}/{center[0]},{center[1]},{zoom}/1920x1080@2x" f"?access_token={MAPBOX_TOKEN}") download(url, output_path) return output_path ``` - **Stile**: `dark-v11` (Standard), `satellite-v9` (Satellit), `light-v11` (hell) - **Marker**: Rote Pins mit Labels fuer Staedte, Militaerbasen, Routen - **Alternative**: OpenStreetMap + Leaflet-Screenshot (komplett kostenlos, etwas aufwaendiger) ### Person-Fetcher (~40 Zeilen) ```python # Wikimedia Commons API fuer Portraits realer Personen def fetch_person(name: str, output_path: str) -> str: resp = requests.get("https://en.wikipedia.org/api/rest_v1/page/summary/" + name.replace(" ", "_")) image_url = resp.json().get("originalimage", {}).get("source") if image_url: download(image_url, output_path) return output_path ``` - **Quelle**: Wikipedia/Wikimedia (CC-lizenziert, Attribution noetig) - **Fallback**: Pexels-Suche nach Name wenn kein Wikipedia-Bild - **Hinweis**: Nur fuer oeffentliche Personen (Politiker, CEOs). Keine Privatpersonen. ### Szenentyp-Routing im Orchestrator ```python SCENE_HANDLERS = { "hero": lambda s: submit_gpu_job("flux", s), # 3090 "concept": lambda s: submit_gpu_job("sdxl", s), # 3080 #1/#2 "stock": lambda s: fetch_stock(s["query"], ...), # CPU, <2 Sek "map": lambda s: render_map(s["data_source"],...),# CPU, <3 Sek "chart": lambda s: generate_chart(s["data_source"],...), # CPU, <1 Sek "person": lambda s: fetch_person(s["query"], ...), # CPU, <2 Sek } ``` ## Konkretes Beispiel: "Irans Hyperschall-Schlag" (24 Min) ``` INPUT: Thema: "Irans Hyperschallrakete — geopolitische Folgen" Recherche: 3-4 Quellenlinks PHASE 1 (~30 Min): GPT-5.4 → Skript (4500 Woerter) Mensch reviewt (~20 Min) Qwen 14B → Szenenplan: 105 Szenen (JSON), davon: 12x hero — dramatische Key-Visuals, Thumbnail 35x concept — symbolische Szenen (Rakete, Explosion, Diplomatie) 25x stock — echte Fotos (Khamenei, Pentagon, Oeltanker, Staedte) 8x map — Strait of Hormuz, Flugbahnen, Militaerbasen 5x chart — Oelpreis, Ruestungsausgaben, Handelsvolumen 20x person — Politiker, Militaerfuehrer, Analysten PHASE 2 (~15 Min, 5 GPUs + CPU parallel): GPU: 3090: 12 Hero-Bilder (FLUX.1-dev) ~10 Min 3080 #0: XTTS v2 → 24 Min Voiceover → danach 10 SDXL ~15 Min 3080 #1: 18 Konzept-Bilder (SDXL) ~10 Min 3080 #2: 17 Konzept-Bilder (SDXL) ~10 Min 3080 #3: Whisper → Untertitel-SRT + ESRGAN ~5 Min CPU (parallel, <60 Sek): Stock-Fetcher: 25 Fotos von Pexels Person-Fetcher: 20 Portraits von Wikipedia Map-Renderer: 8 Karten von Mapbox Chart-Generator: 5 Charts (Oelpreis via yfinance, etc.) PHASE 3 (~10 Min): FFmpeg: 105 Szenen × Ken-Burns → Videospur FFmpeg: Audio-Mix (Voiceover + Ambient-Musik) FFmpeg: Text-Overlays + Untertitel NVENC: H.265 → final.mp4 (1080p) Gesamtzeit Maschine: ~25 Min Gesamtzeit inkl. Mensch: ~55 Min Bildmix im fertigen Video: ~45% KI-generiert (hero + concept) → Stimmung, Symbolik ~25% Stock-Fotos → Realitaet, Glaubwuerdigkeit ~20% Portraits → Personen, Gesichter ~8% Karten → Geografie, Routen ~5% Charts → Daten, Fakten ``` ## Nicht-Ziele (v1) - Kein Avatar (kommt spaeter als Test) - Kein Vollbild-Avatar - Kein Piper TTS (zu robotisch, XTTS v2 direkt) - Kein AMD-Rig - Kein Multi-Kanal (erst ein Kanal stabil betreiben) - Keine YouTube-Upload-Automation - Keine Batch-Produktion (ein Video nach dem anderen) - Kein Kubernetes, kein Service-Mesh, kein Proxmox - Keine eigene Bild-Datenbank (Stock wird live per API geholt) - Kein CLIP-Scoring (kommt spaeter fuer automatische Bildauswahl) ## Umsetzungsreihenfolge ``` PHASE 1 — ki-tower Grundinstallation (Woche 1-2) ├── Debian 12 + NVIDIA 550+ Treiber + CUDA 12.x + Docker ├── vLLM + Qwen 2.5 14B → Szenenplan-Test ├── GPT-5.4 API anbinden → erster Skript-Test └── Ergebnis: "Skript + Szenenplan funktionieren" PHASE 2 — Bildgenerierung + Media-Module (Woche 3-4) ├── ComfyUI + FLUX.1-dev in Docker → Hero-Bilder testen ├── SDXL in Docker (gleicher ComfyUI oder A1111) ├── Media-Module: Stock-Fetcher, Chart-Gen, Map-Renderer, Person-Fetcher ├── Pexels API-Key + Mapbox Token einrichten (beides kostenlos) ├── Szenentyp-Routing: hero/concept → GPU, stock/map/chart/person → CPU └── Ergebnis: "Mixed Media (50 KI + 50 Stock/Charts/Karten) in <15 Min" PHASE 3 — 3080-Rig parallel aufbauen (Woche 3-5) ├── Debian 12 + CUDA + Docker (identischer Stack) ├── SDXL-Worker auf #1, #2 (sofort produktiv) ├── Tailscale + Worker-API anbinden └── Ergebnis: "3 SDXL-Worker generieren Bilder parallel" PHASE 4 — Voice + Untertitel (Woche 5-6) ├── XTTS v2 auf 3080 #0 → Voice-Cloning mit eigener Referenz testen ├── Deutsche Stimme tunen (Sprechstil, Tempo, Betonung) ├── faster-whisper auf 3080 #3 → SRT-Untertitel └── Ergebnis: "Natuerliches deutsches Voiceover + Untertitel" PHASE 5 — FFmpeg Assembly + erstes Video (Woche 6-7) ├── Ken-Burns-Presets (Schwenk, Zoom, statisch je Szenentyp) ├── Audio-Mix (Voiceover + Musik, Lautstaerke-Normalisierung) ├── Text-Overlay-Pipeline (aus Szenenplan-JSON) ├── Untertitel einbetten ├── Thumbnail-Generierung (FLUX hero-Bild) ├── NVENC Encoding └── Ergebnis: "Erstes komplettes 10-Min-Video" PHASE 6 — Orchestrator + Produktionsbetrieb (Woche 7-8) ├── Python-Orchestrator: production.db + Job-Verteilung ├── CLI (produce.py) ├── Telegram-Benachrichtigung bei fertigem Video ├── Erstes Video auf YouTube hochladen └── Ergebnis: "v1 laeuft produktiv" PHASE 7 — Stabilisierung + Tempo (Woche 9-10) ├── Prompt-Templates fuer Skripte verfeinern ├── FFmpeg-Presets fuer verschiedene Szenentypen ├── XTTS-Stimme weiter tunen ├── 3-5 Videos produzieren und Workflow optimieren └── Ergebnis: "v1 ist stabil, 2-3 Videos/Woche moeglich" ``` ## Spaeter (v1.5+) Erst nach mindestens 10 produzierten Videos und stabilem Workflow. ### v1.5 — Avatar-Test (optional) | Feature | Beschreibung | |---|---| | SadTalker PiP (~20%) | Sprechender Avatar unten rechts, 384x384 | | Laeuft auf 3080 #2 | SDXL wird auf #1 und #0 (nach TTS) konzentriert | | Abhaengigkeit | TTS muss vorher fertig sein (Audio → Lip-Sync) | | Risiko | Qualitaet moeglicherweise nicht ausreichend. Alternativen: LivePortrait, MuseTalk | | Entscheidung | Erst testen, dann entscheiden ob es im Kanal bleibt | ``` Avatar-Layout (nur v1.5): ┌─────────────────────────────────────────────┐ │ │ │ HAUPTBILD (Bilder, Karten) │ │ │ │ ┌─────────┐ │ │ │ Avatar │ │ │ │ ~20% │ │ │ └─────────┘ │ └─────────────────────────────────────────────┘ ``` ### v2 — Erweiterungen | Feature | Voraussetzung | |---|---| | Multi-Kanal | v1 stabil, erster Kanal hat >20 Videos | | Avatar-Varianten | SadTalker/LivePortrait qualitativ validiert | | Batch-Produktion | Mehrere Videos in Queue | | YouTube-Upload-API | Manueller Upload nervt (>3 Videos/Woche) | | Vollbild-Avatar | Nur wenn Qualitaet stimmt. Aktuell unrealistisch mit SadTalker. | ### AMD-Rig Nicht in der Planung. Entscheidung nach 3 Monaten v1: - Wenn 3080-Rig Kapazitaetsgrenze erreicht: 1-Karten-Test (Whisper) - Sonst: verkaufen, Erloese in Storage investieren ## Entscheidungen | Frage | Entscheidung | Begruendung | |---|---|---| | Skript-LLM | **GPT-5.4** (Cloud) | Kreativitaet > lokale Inferenz. ~0.50 EUR/Skript. | | Szenenplan-LLM | **Qwen 14B** (lokal) | Strukturiertes JSON, keine Kreativitaet noetig | | Hero-Bilder | **FLUX.1-dev** (3090) | Beste Qualitaet fuer Thumbnails, Titel, Kapitelwechsel | | Konzept-Bilder | **SDXL** (3x 3080) | Symbolik, Stimmung — dort wo KI stark ist | | Reale Medien | **Stock + Karten + Charts** (CPU) | Fakten, Personen, Geografie — dort wo KI schwach ist | | Stimme (v1) | **XTTS v2** (3080 #0) | Voice-Cloning, natuerlich, deutsch. Keine Uebergangsloesung. | | Untertitel | **faster-whisper** (3080 #3) | CUDA-nativ, schnell | | Avatar (v1) | **Nein** | Fragil, Qualitaetsrisiko, unnoetige Komplexitaet | | Assembly | **FFmpeg + NVENC** | Stabil, flexibel, hardware-beschleunigt | | DB | **SQLite** | Ein User, eine Datei. | | Netzwerk | **Tailscale** | ki-tower ↔ gpu-worker, fertig | | OS | **Debian 12** | Beide Maschinen identisch. Docker + CUDA. | | AMD-Rig | **Nicht in v1** | Kein Aufwand, keine Planung | ## Risiken | # | Risiko | Impact | Mitigation | |---|---|---|---| | 1 | **XTTS v2 deutsche Stimme klingt unnatuerlich** | Hoch | Voice-Cloning mit guter Referenz. Fallback: OpenAI TTS als Bruecke (~0.50 EUR/Video). | | 2 | **VRAM-Tetris auf 3090** (Qwen + FLUX) | Mittel | Sequentiell, nicht parallel. vLLM Model-Unloading. 14B statt 32B. | | 3 | **Pipeline wird zu komplex vor erstem Video** | Hoch | Erste 3 Videos manuell (Bash-Scripts). Orchestrator erst in Phase 6. | | 4 | **SDXL-Bilder stilistisch inkonsistent** | Niedrig | Weniger KI-Bilder (~50 statt ~100). Feste Style-Presets + Negativprompts. | | 5 | **FFmpeg-Assembly hat Artefakte** | Mittel | Ken-Burns-Presets manuell testen. Ueberblendungen standardisieren. | | 6 | **Stock-API liefert unpassende Bilder** | Niedrig | 3 Ergebnisse abrufen, bestes per CLIP-Score auswaehlen. Fallback: SDXL-Concept. | | 7 | **Pexels/Mapbox API-Limits** | Niedrig | Pexels: 200 Req/Std (reicht fuer ~6 Videos/Std). Mapbox: 50k/Monat. Weit ueber Bedarf. | ## Kosten | Posten | Monatlich | |---|---| | Strom ki-tower (24/7) | ~30-40 EUR | | Strom gpu-worker (bei Bedarf) | ~10-30 EUR | | GPT-5.4 API (Skripte) | ~3-15 EUR | | Cloud-TTS Fallback | ~0-10 EUR | | Pexels API | kostenlos | | Mapbox API | kostenlos (bis 50k Req/Monat) | | yfinance/FRED | kostenlos | | **Gesamt** | **~45-85 EUR** | Keine zusaetzlichen Kosten durch Mixed Media. Alle APIs haben kostenlose Tiers die fuer die geplante Produktionsmenge (8-12 Videos/Monat) weit ausreichen.