676 lines
29 KiB
Markdown
676 lines
29 KiB
Markdown
# 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.
|