ShortGPT Local: Social-Media-Videos per KI — in Minuten, nicht Stunden

💰 Warum KI-Videogenerierung Ihre Content-Strategie transformiert

Ein professionelles 60-Sekunden-Video kostet bei einer Agentur 500–2.000 € — und braucht 1–2 Wochen. ShortGPT Local produziert das gleiche Ergebnis in Minuten, für Cent-Beträge an Stromkosten. Der Hebel liegt nicht in der Technik, sondern in der Geschwindigkeit des Content-Outputs.

⚙️ Der automatisierte Video-Workflow

Fünf Schritte vom Text-Script zum fertigen Social-Media-Video.

💻 Code-Einblicke

Ein Blick unter die Haube — so erzeugt ShortGPT automatisch Social-Media-Videos:

🏗️ Architektur

🎬 12-Schritt Content-Pipeline

class ContentShortEngine(AbstractContentEngine):
    def __init__(self, short_type, background_video_name,
                 background_music_name, voiceModule, short_id="",
                 num_images=None, watermark=None, language=Language.ENGLISH):
        super().__init__(short_id, short_type, language, voiceModule)
        if not short_id:
            if num_images:
                self._db_num_images = num_images
            if watermark:
                self._db_watermark = watermark
            self._db_background_video_name = background_video_name
            self._db_background_music_name = background_music_name

        self.stepDict = {
            1:  self._generateScript,
            2:  self._generateTempAudio,
            3:  self._speedUpAudio,
            4:  self._timeCaptions,
            5:  self._generateImageSearchTerms,
            6:  self._generateImageUrls,
            7:  self._chooseBackgroundMusic,
            8:  self._chooseBackgroundVideo,
            9:  self._prepareBackgroundAssets,
            10: self._prepareCustomAssets,
            11: self._editAndRenderShort,
            12: self._addYoutubeMetadata
        }

🔊 TTS & Audio-Beschleunigung

def _generateTempAudio(self):
    if not self._db_script:
        raise NotImplementedError("generateScript must set self._db_script.")
    script = self._db_script
    if self._db_language != Language.ENGLISH.value:
        self._db_translated_script = gpt_translate.translateContent(
            script, self._db_language)
        script = self._db_translated_script
    self._db_temp_audio_path = self.voiceModule.generate_voice(
        script, self.dynamicAssetDir + "temp_audio_path.wav")

def _speedUpAudio(self):
    self.verifyParameters(tempAudioPath=self._db_temp_audio_path)
    self._db_audio_path = audio_utils.speedUpAudio(
        self._db_temp_audio_path,
        self.dynamicAssetDir + "audio_voice.wav")

📝 Whisper-Transkription & Captions

def _timeCaptions(self):
    self.verifyParameters(audioPath=self._db_audio_path)
    whisper_analysis = audio_utils.audioToText(self._db_audio_path)
    self._db_timed_captions = captions.getCaptionsWithTime(
        whisper_analysis)

🖼️ KI-generierte Bild-Suchbegriffe

def getImageQueryPairs(captions, n=15, maxTime=2):
    chat, _ = gpt_utils.load_local_yaml_prompt(
        'prompt_templates/editing_generate_images.yaml')
    prompt = chat.replace('<>', f"{captions}")                  .replace("<>", f"{n}")
    res = gpt_utils.gpt3Turbo_completion(chat_prompt=prompt)
    imagesCouples = ('{'+res).replace('{','').replace('}','')                              .replace('\n', '').split(',')
    pairs = []
    t0, end_audio = 0, captions[-1][0][1]
    for a in imagesCouples:
        try:
            query = a[a.find("'")+1:a.rfind("'")]
            time = float(a.split(":")[0].replace(' ',''))
            if time > t0 and time < end_audio:
                pairs.append((time, query + " image"))
                t0 = time
        except:
            print('problem extracting image queries from', a)
    return pairs

🎥 MoviePy-basiertes Rendering

def _editAndRenderShort(self):
    outputPath = self.dynamicAssetDir + "rendered_video.mp4"
    if not os.path.exists(outputPath):
        videoEditor = EditingEngine()
        # Voiceover hinzufügen
        videoEditor.addEditingStep(
            EditingStep.ADD_VOICEOVER_AUDIO,
            {'url': self._db_audio_path})
        # Hintergrundmusik (11% Lautstärke)
        videoEditor.addEditingStep(
            EditingStep.ADD_BACKGROUND_MUSIC,
            {'url': self._db_background_music_url,
             'loop_background_music': self._db_voiceover_duration,
             'volume_percentage': 0.11})
        # 1920x1080 Crop
        videoEditor.addEditingStep(
            EditingStep.CROP_1920x1080,
            {'url': self._db_background_trimmed})
        # Captions & Watermark
        if self._db_watermark:
            videoEditor.addEditingStep(
                EditingStep.ADD_WATERMARK,
                {'text': self._db_watermark})
        for timing, text in self._db_timed_captions:
            videoEditor.addEditingStep(
                EditingStep.ADD_CAPTION_SHORT,
                {'text': text.upper(),
                 'set_time_start': timing[0],
                 'set_time_end': timing[1]})
        videoEditor.renderVideo(outputPath)
    self._db_video_path = outputPath

📺 YouTube-Metadaten automatisch

def _addYoutubeMetadata(self):
    title, desc, tags = gpt_yt.generate_title_description_dict(
        self._db_script)
    now = datetime.datetime.now()
    date_str = now.strftime("%Y-%m-%d_%H-%M-%S")
    newFileName = f"videos/{date_str} - " +         re.sub(r"[^a-zA-Z0-9 '\n\.]", '', title)
    shutil.move(self._db_video_path, newFileName + ".mp4")
    with open(newFileName + ".txt", "w", encoding="utf-8") as f:
        f.write(f"---YouTube title---\n{title}\n                 ---YouTube description---\n{desc}\n                 ---YouTube Tags---\n{tags}")
    self._db_video_path = newFileName + ".mp4"
    self._db_ready_to_upload = True

🚀 Gebaut mit Vibecoding — in 5–7 Tagen statt 8–13 Wochen

🗣️ Der System-Prompt hinter diesem Projekt

Du bist ein Python-Experte für automatisierte Videoproduktion.

Aufgabe: Erstelle ein Tool zur automatischen Generierung von Kurzvideos 
(Shorts, Reels, TikTok) aus Text-Scripts oder Bildmaterial.

Pipeline:
1. Text-Script parsen → Storyboard (Szenen-Einteilung)
2. Bilder generieren (Stable Diffusion) oder aus Input extrahieren
3. Voiceover via TTS (edge-tts, deutsch: de-DE-KatjaNeural)
4. Untertitel synchronisiert generieren
5. Finales Video mit MoviePy + FFmpeg rendern

Technische Anforderungen:
- Python 3.10+, MoviePy für Video-Komposition
- Stable Diffusion (lokal via diffusers) für Bildgenerierung
- edge-tts für deutsche Sprachausgabe
- Pillow für Bildbearbeitung
- Whisper optional für automatische Untertitel-Generierung

Video-Spezifikation:
- 9:16 Format (1080×1920) für Shorts/Reels/TikTok
- 30 fps, konfigurierbare Dauer (15–60 Sek.)
- Hintergrundmusik und Übergangseffekte
- Branding-Overlay (Logo, Wasserzeichen)

🎯 Strategische Erkenntnisse aus diesem Projekt

Content Creation ist der perfekte Anwendungsfall für KI-Automatisierung — hohe Kosten, repetitive Muster, messbarer Output.