Lokale multimodale KI-Pipeline 2026: Sprache, Vision und Text-Modelle offline kombinieren

Kurzfakten

• VRAM für den vollständigen Stack: ~15 GB (Whisper 3 GB + LLaVA 7B 6 GB + Llama 3.3 8B 6 GB). Piper läuft auf der CPU.
• Vereinfachter Stack (Llama 3.2 Vision 11B): ~8 GB VRAM — verarbeitet sowohl Vision als auch Textreasoning in einem Modell.
• Sprach-Latenz (Whisper small, RTX 4070): ~200–500 ms STT. 500–1500 ms LLM erster Token. 100 ms Piper TTS.
• Bildverarbeitungs-Latenz (LLaVA 7B, RTX 4070): ~2–5 Sekunden pro Bild je nach Auflösung und Prompt.
• Kein Echtzeit-Video: VLMs verarbeiten einzelne Frames, keine kontinuierlichen Videostreams. Für Video: Frames bei 1 FPS extrahieren und einzeln verarbeiten.
• Gleiche Ollama-Instanz für VLM + LLM: Ollama kann Llama 3.2 Vision sowohl als Vision- als auch als Text-Modell bereitstellen und so VRAM sparen.
• Alle Komponenten MIT- oder Apache-2.0-lizenziert (whisper.cpp MIT, LLaVA MIT, Llama 3.3 8B Llama 3 Community License, Piper MIT).

Was ist eine multimodale KI-Pipeline?

• Cloud-Ansatz (GPT-5.5): Ein riesiges Modell, das simultan auf allen Modalitäten trainiert wurde. Modalitätsübergreifendes Reasoning wird beim Training gelernt — das Modell kann die Beziehung zwischen Bildinhalt und Sprachabfragen nativ verstehen.
• Lokaler Ansatz (dieser Leitfaden): Separate spezialisierte Modelle für jede Modalität, verbunden durch einen Orchestrator. Modularer und günstiger im Betrieb, erzeugt aber „Nähte" — Vision-Modell-Ausgabe wird zu Text serialisiert, bevor sie an das LLM übergeben wird.
• Warum lokal aufbauen: Datenschutz (medizinische Bilder, proprietäre Dokumente, vertrauliche Screenshots), Kosten (null API-Gebühren pro Abfrage), Offline-Fähigkeit (kein Internet nach dem Modell-Download erforderlich), Anpassbarkeit (jede Komponente tauschbar).
• Modularer Vorteil: Sie können jede einzelne Komponente unabhängig aktualisieren. Wenn ein besseres lokales STT-Modell erscheint, ersetzen Sie nur die STT-Schicht.

Kosten: Lokale Pipeline vs. Cloud-APIs (monatlich)

Architekturübersicht

• Eingabetypen: Mikrofon-Audio (Sprache), Kamera- oder Dateibild (Vision), Tastatur-Text (Text).
• Router-Logik: Eingabetyp an der Grenze erkennen. Audio → STT-Modell. Bild → VLM. Text → direkt zum LLM. Wenn Audio und Bild gemeinsam eintreffen, parallel verarbeiten und kombinieren.
• Modell-Registry: Jeder Eingabetyp wird einer Handler-Funktion zugeordnet, die das entsprechende Modell aufruft und eine Textbeschreibung/Transkript zurückgibt.
• Orchestrator: Sammelt alle Modellausgaben, kombiniert sie zu einem einzelnen Prompt für das Text-LLM, erhält die LLM-Antwort und leitet sie zur Sprachausgabe an TTS oder als Text auf den Bildschirm weiter.
• Ausgabetypen: Sprachantwort (Piper TTS), Text auf dem Bildschirm oder strukturierte Daten (JSON) zur Integration mit anderen Systemen.
• Parallele Verarbeitung: STT und VLM können simultan verarbeiten — eine Audio-Abfrage zu einem Bild kann beides parallel verarbeiten, wodurch die Gesamtlatenz um 40–60 % gegenüber sequenzieller Verarbeitung reduziert wird.

Der Component-Stack

Hardware-Tiers für Multimodal

Use Case 1: Sprachgesteuerter Dokumenten-Analysator

• Beispiel: Fotografieren Sie eine Rechnung und fragen Sie: „Wie hoch ist der fällige Gesamtbetrag und was ist die Zahlungsfrist?"
• Pipeline: Whisper transkribiert die Frage → Bild wird an LLaVA oder Llama 3.2 Vision gesendet → VLM extrahiert Rechnungstext und Struktur → LLM kombiniert Frage + VLM-Ausgabe → Piper liest die Antwort laut vor.
• Prompt: „Hier ist ein Bild: [VLM-Beschreibung]. Der Benutzer fragt: [Transkript]. Beantworten Sie die Frage basierend auf dem Bildinhalt."
• Bestes VLM: MiniCPM-V 2.6 oder Llama 3.2 Vision 11B für Rechnungs-/Dokument-OCR-Genauigkeit.
• Datenschutzwert: Medizinische Unterlagen, rechtliche Dokumente, Finanzauszüge — vollständig lokal verarbeitet, ohne dass Daten das Gerät verlassen.

Use Case 2: Visueller Q&A-Assistent

• Anwendungen: Lagerbestandsverwaltung, Feldinspektionen, Barrierefreiheit für sehbeeinträchtigte Benutzer.
• Implementierung: Kamera-Frame aufnehmen (OpenCV), als JPEG speichern, zusammen mit dem Whisper-Transkript an das VLM übergeben.
• Beste Modelle: LLaVA 1.6 7B oder Llama 3.2 Vision 11B für allgemeines Objekt-/Szenenverständnis.
• Latenz: 3–6 Sekunden für Bildaufnahme + VLM-Verarbeitung + LLM + TTS auf RTX 4070.

Use Case 3: Meeting-Transkription + Folienanalyse

• STT: Führen Sie faster-whisper im Streaming-Modus während des Meetings aus.
• Vision: Jedes Mal, wenn eine neue Folie erscheint, nehmen Sie einen Screenshot auf und übergeben ihn an LLaVA zur Beschreibung.
• Kombination: Am Ende des Meetings übergeben Sie Transkript + Folienbeschreibungen an Llama 3.3 8B für Zusammenfassung und Aktionspunkte.
• Ausgabe: Sprachgelesene Zusammenfassung (Piper TTS) + lokal gespeicherte Textdatei.
• DSGVO-Wert: Die gesamte Meeting-Verarbeitung ist lokal. Kein Audio, Transkript oder Folien werden an einen Cloud-Dienst gesendet.

Use Case 4: Lokales Zugänglichkeitstool

• Screenreader: Screenshot alle 2 Sekunden aufnehmen → LLaVA beschreibt den Bildschirminhalt → Piper liest ihn laut vor.
• Sprachnavigation: Whisper transkribiert Sprachbefehle → LLM interpretiert die Absicht → Tastatur-/Mausaktionen via pyautogui ausführen.
• Datenschutzvorteil: Benutzer mit Behinderungen nutzen Zugänglichkeitstools oft in sensiblen Kontexten. Ein lokales Tool stellt sicher, dass kein Bildschirminhalt an Dritte übertragen wird.
• Modellwahl für Zugänglichkeit: Moondream 2 für schnelle Bildschirmbeschreibungen (2 GB VRAM). LLaVA 7B für reichhaltigere Beschreibungen (6 GB VRAM).

Use Case 5: Lokale Sicherheitskameraanalyse

• Frame-Aufnahme: OpenCV verwenden, um alle 5–10 Sekunden einen Frame von einer IP-Kamera via RTSP aufzunehmen.
• Bewegungserkennung: Differenz zwischen aufeinanderfolgenden Frames berechnen. Frames unterhalb des Bewegungsschwellenwerts überspringen.
• VLM-Analyse: Bei erkannter Bewegung den Frame an das VLM senden: „Beschreiben Sie, was passiert. Ist eine Person anwesend?"
• Alert-Ausgabe: Wenn eine Person erkannt wird, eine lokale Desktop-Benachrichtigung und eine Piper-TTS-Ansage auslösen.
• Datenschutzvorteil: Ring und Nest senden Video an AWS- bzw. Google-Server. Dieses Setup hält alle Aufnahmen auf Ihrer Hardware.
• Bestes VLM für Geschwindigkeit: Moondream 2 (~1 Sekunde pro Frame, ~2 GB VRAM) oder LLaVA 7B (~3 Sekunden, ~6 GB VRAM).

Den Python-Orchestrator aufbauen

#!/usr/bin/env python3
"""Local multimodal orchestrator: voice + vision + text, all offline."""

import asyncio
import base64
import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests

OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
VISION_MODEL = "llava:7b"
TEXT_MODEL = "llama3.1:8b"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SAMPLE_RATE = 16000

async def transcribe_audio(audio: np.ndarray) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        loop = asyncio.get_event_loop()
        result = await loop.run_in_executor(None, lambda: subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        ))
    return result.stdout.strip()

async def describe_image(image_path: str) -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL,
        json={"model": VISION_MODEL, "prompt": "Describe the content of this image in detail.", "images": [image_b64], "stream": False},
    ))
    return response.json()["response"]

async def reason(transcript: str, image_description: str | None = None) -> str:
    if image_description:
        prompt = f"The user asked (via voice): {transcript}\n\nThe image shows: {image_description}\n\nAnswer based on the image. Be concise."
    else:
        prompt = transcript
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL, json={"model": TEXT_MODEL, "prompt": prompt, "stream": False},
    ))
    return response.json()["response"]

async def speak(text: str) -> None:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        await asyncio.get_event_loop().run_in_executor(None, lambda: subprocess.run(
            f'echo "{text}" | piper --model {PIPER_VOICE} --output_file {f.name}', shell=True, check=True
        ))
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

async def process_query(audio: np.ndarray, image_path: str | None = None) -> None:
    if image_path:
        transcript, image_desc = await asyncio.gather(transcribe_audio(audio), describe_image(image_path))
    else:
        transcript = await transcribe_audio(audio)
        image_desc = None
    if not transcript or len(transcript) < 3:
        return
    response = await reason(transcript, image_desc)
    await speak(response)

async def main():
    while True:
        audio = sd.rec(int(5 * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
        sd.wait()
        await process_query(audio)

if __name__ == "__main__":
    asyncio.run(main())

Performance-Optimierung

• Paralleles STT + VLM: asyncio.gather(transcribe_audio(), describe_image()) verwenden, um beide simultan auszuführen. Spart 0,3–2 Sekunden.
• Modelle warm halten: Ollama hält Modelle automatisch zwischen Anfragen im VRAM. Nie zwischen Abfragen neu laden.
• LLM → TTS streamen: Satzgrenzen in der LLM-Ausgabe erkennen. Jeden abgeschlossenen Satz an Piper übergeben, während das LLM weiter generiert.
• VRAM-Management: Bei engem VRAM das VLM nach der Bildverarbeitung entladen, bevor das Text-LLM geladen wird. Fügt ~2–3 Sekunden hinzu, ermöglicht aber 8-GB-GPUs den vollständigen Stack.
• Llama 3.2 Vision als kombiniertes VLM + LLM verwenden: Eliminiert Modell-Wechsel-Overhead — ein Modell verarbeitet sowohl Vision als auch Textreasoning.
• TTS erster Audio-Zielwert: Piper generiert erstes Audio innerhalb von 50–100 ms. Satzweise streamen für sub-sekündliche wahrgenommene Latenz.

Einschränkungen und ehrliche Einschätzung

• Modalitätsnähte: Vision-Ausgabe wird zu Text serialisiert, bevor sie an das Text-LLM übergeben wird. Das LLM kann nicht direkt über Bildmerkmale nachdenken — es denkt über eine Textbeschreibung des Bildes nach.
• Kein Echtzeit-Video: Lokale VLMs verarbeiten einzelne Frames, kein kontinuierliches Video. Für Video: Frames bei 0,5–2 FPS extrahieren und sequenziell verarbeiten.
• VLM-Qualitätslücke: Lokale Vision-Modelle (LLaVA 7B, Llama 3.2 Vision 11B) liegen hinter GPT-5.5 Vision bei komplexen Infografiken, handgeschriebenem Text und mehrdeutigen Szenen.
• VRAM-Druck: Drei Modelle simultan auf einer einzelnen GPU zu betreiben erfordert sorgfältiges VRAM-Management. Auf 12-GB-GPUs müssen Modellgrößen sorgfältig gewählt werden.
• Latenz vs. Cloud: Ein Cloud-Multimodal-Aufruf (GPT-5.5) dauert 1–3 Sekunden. Eine lokale Pipeline dauert 3–8 Sekunden auf vergleichbarer Hardware.
• Konsistenz: Lokale Modelle produzieren variablere Ausgabequalität als Cloud-Modelle. Gelegentliche Halluzinationen sind zu erwarten.

Häufig gestellte Fragen

Quellen

• Ollama — Lokale LLM-Orchestration, unterstützt Vision-Modelle und Chat-APIs.
• whisper.cpp auf GitHub — Schnelle CPU-basierte Speech-to-Text, Metal/CUDA-beschleunigt.
• LLaVA auf Hugging Face — Vision-Language-Modell, Open Source.
• Llama 3.2 Vision — Multimodales LLM mit Vision und Text, 11B.
• Piper TTS auf GitHub — Schnelle lokale Text-to-Speech.

Weiterführende Lektüre

• Lokale Spracherkennung 2026: Whisper.cpp vs. faster-whisper — STT-Komponente im Detail.
• Lokale Vision-Modelle 2026: LLaVA, Llama 3.2 Vision und Ollama — Vision-Komponente im Detail.
• Lokales TTS und Voice Cloning 2026 — TTS-Komponente im Detail.
• Vollständig offline: Sprachassistenten selbst entwickeln 2026 — Die reine Sprachversion (einfacher, ohne Vision).
• Hardware-Guide für lokale LLMs 2026 — Hardware-Auswahl für Multi-Modell-Pipelines.