Bitdoze-Logo

PeakCut in Docker: Self-Hosted KI-Video-Clipper (BYOK)

PeakCut mit Docker Compose selbst hosten: lange Videos und Livestreams lokal transkribieren und mit eigenem KI-Key in 9:16-Clips schneiden.

Dragos

5 Min. Lesezeit

PeakCut Self-Hosted KI-Video-Clipper in Docker Titelgrafik

Wer YouTube-Tutorials, Podcasts oder Twitch-/Kick-Streams veröffentlicht, kennt die monatliche Rechnung klassischer Clip-Dienste. Tools wie OpusClip oder Vizard verlangen Abos, deckeln Videominuten, setzen Wasserzeichen in günstigen Tarifen und wollen erst Gigabyte an Rohmaterial in ihrer Cloud sehen, bevor man weiß, ob die Schnitte taugen.

PeakCut (MIT-Lizenz, über 1.400 GitHub-Sterne in der ersten Woche im November 2026) dreht das Modell um: Der Schnitt läuft auf deinem Rechner oder Linux-Server, die Spracherkennung passiert lokal mit sherpa-onnx (Parakeet), und nur das Text-Transkript geht an deinen eigenen KI-Key (Gemini, OpenAI, Claude, Groq, OpenRouter, xAI oder lokales Ollama), um gute Momente und Hooks auszuwählen.

Wie PeakCut unter der Haube arbeitet

PeakCut besteht aus einem Python-FastAPI-Backend, schlichten HTML/CSS/JS-Seiten ohne Build-Schritt, ffmpeg und yt-dlp:

  1. Audio verlässt deine Hardware nicht. Die Transkription läuft lokal über sherpa-onnx und das Parakeet-Modell (~480 MB einmaliger Download) oder nutzt bei PEAKCUT_YT_TRANSCRIPT=1 das vorhandene YouTube-Transkript.
  2. Nur Text geht ans LLM. Ein schnelles Modell liest das Transkript (laut Doku etwa vier Anfragen pro Videostunde) und liefert JSON-Zeitstempel, Hooks und Titel. Ganz ohne KI-Key schneidet PeakCut immer noch nach Lautstärke-Peaks.
  3. ffmpeg rendert 9:16-Hochformat-Clips mit Wort-für-Wort-Untertiteln in drei Stilen. Bei Livestreams nimmt es in einen Ringpuffer auf und schneidet Highlights noch während des Streams anhand von Lautstärke, Chat-Aktivität und Transkript.
  4. Eingebaute Lastgrenzen. Der Server misst sekündlich CPU, freien RAM und Speicherplatz (PEAKCUT_BUSY_CPU=82, PEAKCUT_MIN_FREE_RAM_GB=1.5) und reiht Jobs pro Nutzer ein, damit ein geteilter VPS nicht überläuft.

Self-Hosted PeakCut vs. SaaS-Clipper

Bereich PeakCut (Self-Hosted) SaaS (OpusClip, Vizard usw.)
Softwarekosten Kostenlos (MIT) ~15–40 $+/Monat je nach Minutenkontingent
Kosten pro Videostunde Bruchteile eines Cents an Text-Tokens (oder 0 $ mit Ollama) Im Minutenlimit enthalten
Rohvideo-Datenschutz Bleibt lokal; lokale sherpa-onnx-ASR Upload in Hersteller-Cloud
Livestream-Clipping Ringpuffer + Lautstärke/Chat/Transkript Selten oder nur in teuren Tarifen
Design & B-Roll 3 saubere Untertitel-Stile; kein Stock-B-Roll Dutzende animierte Templates & Auto-B-Roll
Auto-Posting YouTube, Instagram, TikTok (eigene OAuth-Apps nötig) Ein-Klick-OAuth durch den Anbieter
Hardware Moderner Laptop oder 2–4-vCPU-VPS (GPU optional für ASR) Keine (Browser)

Der Kompromiss ist klar: Wer auffällige animierte Vorlagen, Stock-B-Roll und null OAuth-Einrichtung will, bleibt bei einem bezahlten SaaS. Wer lange Technik-Streams, Vorträge oder Coding-Videos ohne Minuten-Deckel in saubere Shorts verwandeln will, fährt mit PeakCut deutlich günstiger. (Wenn du Videos stattdessen per Code von Grund auf erzeugen willst, lies unser HyperFrames Studio Review oder den Python Video-Intro-Editor.)

PeakCut installieren: Docker-Server vs. lokal

Docker Compose (VPS / Homelab)

Das offizielle docker-compose.yml startet postgres:16-alpine, die FastAPI-App auf 127.0.0.1:8765 und optional Caddy (COMPOSE_PROFILES=own-https) für automatisches HTTPS.

Repository klonen und .env anlegen:

bash
git clone https://github.com/haziqahmedqasmi/PeakCut.git ~/peakcut
cd ~/peakcut
cp .env.example .env

.env mit Domain, Postgres-Passwort, KI-Anbieter und Ressourcen-Grenzen ausfüllen:

PEAKCUT_DOMAIN=peakcut.example.com
POSTGRES_PASSWORD=langes-zufaelliges-passwort

# Eigener KI-Key (alternativ leer lassen und in Settings -> AI eintragen)
PEAKCUT_AI_PROVIDER=gemini
PEAKCUT_AI_MODELS=gemini-2.5-flash
PEAKCUT_AI_KEY=dein-api-key

# Pflicht auf jedem erreichbaren Server, sonst nutzen Fremde deinen API-Key
PEAKCUT_ACCOUNTS=1

# Aktiv lassen, wenn PeakCut Port 80/443 selbst verwaltet (hinter Traefik/Nginx entfernen)
COMPOSE_PROFILES=own-https

# Schutzgrenzen auf einem geteilten Server
PEAKCUT_MEM_LIMIT=4g
PEAKCUT_CPUS=2
PEAKCUT_CPU_SHARES=512
PEAKCUT_OOM_SCORE_ADJ=900
PEAKCUT_DB_MEM_LIMIT=256m

Bauen und starten:

bash
docker compose up -d --build

Registriere deinen Account im Browser und vergib Admin-Rechte über die CLI (im Web-UI geht das bewusst nicht):

bash
docker compose exec app python -m studio.admin grant [email protected]

Läuft bereits Traefik auf dem Server, lass COMPOSE_PROFILES=own-https weg und nutze das mitgelieferte Override (COMPOSE_FILE=docker-compose.yml:deploy/docker-compose.traefik.yml).

Lokal auf Mac / Linux / Windows

Am eigenen Rechner brauchst du weder Postgres noch Accounts: SQLite speichert alles in ./data. Installiere Python 3.10+ und ffmpeg (brew install ffmpeg, sudo apt install ffmpeg oder winget install Gyan.FFmpeg).

bash
git clone https://github.com/haziqahmedqasmi/PeakCut.git ~/peakcut
cd ~/peakcut
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python -m studio.server

Unter Windows in einen kurzen Pfad wie C:\peakcut klonen, damit das Sprachmodell nicht an der 260-Zeichen-Grenze scheitert. Beim ersten Start lädt PeakCut einmalig das ~480-MB-Parakeet-Modell. Öffne http://127.0.0.1:8765, richte unter Settings -> AI deinen Anbieter (oder ollama für 100 % lokal) ein und teste deinen ersten Link.

Modellwahl und 100 % lokaler Betrieb mit Ollama

Für die Clip-Auswahl brauchst du kein teures Reasoning-Modell, sondern ein schnelles Modell mit sauberer JSON-Ausgabe:

  • Günstigste API-Wahl: Gemini Flash (PEAKCUT_AI_PROVIDER=gemini) oder Groq (llama-3.3-70b-versatile). Eine Videostunde braucht rund vier Anfragen und kostet Bruchteile eines Cents; kommaseparierte IDs in PEAKCUT_AI_MODELS dienen als Fallback.
  • 100 % lokal ohne API-Rechnung: PEAKCUT_AI_PROVIDER=ollama mit einem lokalen Modell (etwa llama3.1 oder qwen3). Auf der Seite AI usage siehst du direkt, wie stabil das Modell JSON liefert.
  • Transkription auf GPU-Rechner auslagern: Für gelegentliche Videos reicht CPU-ASR; bei täglichen Lang-VODs nimmt ein zweiter Rechner mit NVIDIA-GPU per deploy/gpu/docker-compose.yml, PEAKCUT_ASR_URL und PEAKCUT_ASR_TOKEN die Hauptlast ab.

PeakCut nie ohne PEAKCUT_ACCOUNTS=1 öffentlich betreiben

Lokal ist der Login standardmäßig aus. Auf jedem erreichbaren Server muss PEAKCUT_ACCOUNTS=1 aktiv bleiben (im offiziellen Docker Compose bereits voreingestellt) und der Key per PEAKCUT_AI_KEY_FILE=/secrets/ai.txt eingebunden werden.

Praxistipps für kleine VPS

  • Rohvideos fressen Speicherplatz. Mounte /data auf eine große Platte und begrenze Nutzer auf geteilten Instanzen über PEAKCUT_MAX_USER_GB.
  • Cloudflare-Upload-Limit beachten. Hinter Cloudflares Orange-Cloud-Proxy belässt du PEAKCUT_UPLOAD_PART_MB=40 (unter dem 100-MB-Limit) und setzt PEAKCUT_CLIENT_IP_HEADER=CF-Connecting-IP.
  • Auto-Posting braucht einmaliges OAuth-Setup. Clips erzeugen und als MP4 laden klappt in fünf Minuten; direktes Posten auf YouTube, Instagram und TikTok verlangt eigene OAuth-Apps laut DEPLOY.md.
  • Einfache Updates. Mit git pull && docker compose up -d –build aktualisierst du PeakCut, ohne .env oder Clips anzufassen (Update-Check abschaltbar per PEAKCUT_UPDATE_CHECK=0).

Fazit

PeakCut zählt zu den saubersten neuen Self-Hosted-KI-Tools auf GitHub: MIT-lizenziert, vernünftige CPU-/RAM-Bremsen, lokale Transkription und kein Account-Zwang. Teste es zuerst lokal per Python an einem 30-Minuten-Video mit Gemini Flash oder Ollama, prüfe Schnittqualität und Untertitel und ziehe erst danach den Docker-Compose-Stack auf deinen Homeserver.

Häufige Fragen (FAQ)

Braucht PeakCut zwingend eine GPU?

Nein. Die Transkription läuft über sherpa-onnx (Parakeet) auf der CPU und das Rendering über normales ffmpeg. Eine GPU ist optional für schwere Batch-Workloads via PEAKCUT_ASR_URL.

Läuft PeakCut komplett ohne KI-API-Key?

Ja. Ohne Key schneidet es Clips anhand von Lautstärke-Peaks, dann allerdings ohne KI-Titel und inhaltliche Auswahl. Alternativ liefert Ollama lokal 0-Euro-Betrieb.

Wie viel kosten die API-Tokens für eine Stunde Video?

Da Audio lokal transkribiert wird, zahlst du nur Text-Tokens für das Transkript. Eine Videostunde entspricht ungefähr vier LLM-Anfragen — unter einem Cent mit Gemini Flash oder Groq, oder 0 € mit Ollama.

Hat diese Anleitung bei dir funktioniert?

Brauchst du Hilfe bei Astro, VPS oder einer Self-hosted-App? Services ansehen →