Beste lokale Vision-Modelle 2026: Gemma 4, Qwen3-VL, LLaVA & Ollama Multimodal-Setup

Schnellübersicht

• Was VLMs leisten: Bild- + Texteingabe → Textausgabe. Keine Bildgeneratoren – diese Modelle *verstehen* Bilder.
• Ollama-Unterstützung: Gemma 4, Qwen3.8, Qwen3.5, Qwen3-VL, Llama 3.2 Vision, MiniCPM-V, LLaVA und Moondream sind in der offiziellen Ollama-Bibliothek; InternVL, PaliGemma 2 und SmolVLM benötigen Community-Builds.
• Kleinste nutzbare Modelle: Moondream 2 (1,8B, 1,7 GB Download), Qwen3-VL 2B (1,9 GB) und Qwen3.5 0.8B (1,2–1,3 GB).
• Größte praktische lokale Modelle: Qwen3.5 122B (81 GB) auf einem Mac mit 128 GB und Llama 3.2 Vision 90B (55 GB) auf einem Mac mit 96 GB+ (Apple M-Series) oder Multi-GPU; Qwen3-VL 235B braucht 143 GB.
• Bild-Eingabeformat: JPEG, PNG, WebP. Maximale Auflösung variiert je Modell (typisch 1024×1024 bis 4096×4096).
• Audio und Video: Gemma 4 E2B, E4B und 12B akzeptieren auch Audio; alle Gemma-4-Größen und Qwen3.8 verarbeiten Video als Einzelbilder.
• OCR-Stärke: Qwen3.8 27B ≈ Qwen3-VL 8B ≈ Qwen3.5 9B > Gemma 4 > MiniCPM-V > LLaVA 1.6 13B > LLaVA 1.6 7B > Moondream 2.
• Multimodal ist langsamer: Vision-Modelle fügen einen Vision-Encoder zum LLM hinzu – ~30–60 % langsamere Token-Generierung als ein reines Textmodell gleicher Parameterzahl.

Was sind Vision-Language-Modelle (VLMs)?

• Unterschied zu Bildgeneratoren: Stable Diffusion, FLUX und DALL-E 3 sind Text-zu-Bild-Generatoren. VLMs sind Bild-zu-Text-Modelle – sie beschreiben, analysieren und beantworten Fragen zu Bildern.
• Unterschied zu reinen OCR-Tools: Klassische OCR (Tesseract, PaddleOCR) extrahiert Text per Mustererkennung. VLMs verstehen Kontext – sie können den Inhalt einer Tabelle erklären, Fragen zu einem Diagramm beantworten oder Objekte identifizieren.
• Warum lokal betreiben: Private Dokumente (Krankenakten, juristische Scans, Finanzberichte), proprietäre Screenshots oder Workflows, bei denen das Senden von Bildern an Cloud-APIs Compliance- oder Vertraulichkeitsbedenken aufwirft.
• Was sie nicht können: Bilder generieren, Code aus Screenshots ausführen oder auf das Internet zugreifen. VLMs erzeugen ausschließlich Textausgaben basierend auf dem, was im Bild sichtbar ist.

Verfügbare lokale Vision-Modelle — Vergleichstabelle

Beispielhafter Vergleich: Rechnungsextraktion

Multi-Bild-Unterstützung

• MiniCPM-V akzeptiert bis zu 4 Bilder pro Prompt; Qwen3-VL verarbeitet bis zu 8. LLaVA und Moondream akzeptieren nur einzelne Bilder pro Anfrage.
• Wann Multi-Bild wichtig ist: Alle Seiten eines mehrseitigen PDFs für vollständige Extraktion senden. Zwei Produktfotos nebeneinander vergleichen. Vorher/Nachher-Screenshots in einem Prompt analysieren.

Setup mit Ollama — Schritt für Schritt

• Schritt 1 — Ollama installieren: Download von ollama.com für macOS, Linux oder Windows. Installation unter 2 Minuten.
• Schritt 2 — Modell herunterladen: ollama pull gemma4:e4b (6,6–9,5 GB Download) für 8-GB-Karten, ollama pull qwen3-vl:8b (6,2 GB) für OCR oder ollama pull moondream (1,8B, 1,7 GB) für VRAM-beschränkte Systeme.
• Schritt 3 — Über CLI nutzen: ollama run gemma4:e4b "Was ist auf diesem Bild? /pfad/zum/foto.jpg" — den Bildpfad im Prompt angeben; ollama run hat kein --image-Flag.
• Schritt 4 — HTTP-API nutzen: POST an http://localhost:11434/api/generate mit dem Bild als Base64-String im images-Array. Mit einem JSON-Schema im Feld format erhalten Sie strukturierte Ausgaben.
• Schritt 5 — Python-Beispiel: requests-Bibliothek mit Base64-Kodierung verwenden – siehe Code-Block unten.

import base64
import requests

def ask_vision_model(image_path: str, prompt: str, model: str = "gemma4:e4b") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

# Beispielaufruf
result = ask_vision_model("rechnung.png", "Extrahiere alle Positionen und Gesamtbeträge aus dieser Rechnung.")
print(result)

Anwendungsfall 1: Dokument-OCR und -Extraktion

• Was gut funktioniert: Gescannte Rechnungen, PDF-Screenshots, handgeschriebene Druckschrift, Tabellen mit klaren Linien, Visitenkarten.
• Was weniger gut funktioniert: Kursivhandschrift, Scans unter 150 DPI, stark komprimierte JPEGs, überlappender Text.
• Beste Modelle für OCR: Qwen3-VL 8B und Qwen3.5 9B (6–8-GB-Klasse), Qwen3.8 27B (18 GB, laut Modell-Card 91,1 bei OmniDocBench 1.5), Gemma 4 für gemischte Dokumenttypen.
• Prompt-Engineering für OCR: „Extrahiere den gesamten Text aus diesem Dokument genau wie geschrieben." Oder: „Gib den Inhalt dieser Rechnung als JSON zurück mit Feldern: Anbieter, Datum, Positionen[], Gesamt."
• Vs. klassische OCR: VLMs sind langsamer, aber semantisch mächtiger. Tesseract für reine Textextraktion aus sauberen Dokumenten; VLMs für strukturierte Datenextraktion.

Anwendungsfall 2: Bild-Q&A und -Beschreibung

• Szenenbeschreibung: „Was ist auf diesem Foto?" – Objekte, Personen, Aktivitäten, Umgebung, Stimmung.
• Produktkatalogisierung: Produktfotos mit einem Template verarbeiten: „Beschreibe Farbe, Form, Material, Zustand." Nützlich für E-Commerce-Inventar ohne Cloud-APIs.
• Barrierefreiheit: Alt-Texte für Bilder im großen Maßstab generieren.
• Beste Modelle: Gemma 4 12B oder 26B A4B für allgemeine Foto-Q&A. Qwen3.5 4B oder LLaVA 1.6 7B für Massenverarbeitung, wenn Geschwindigkeit wichtiger ist als Genauigkeit.
• Geschwindigkeitshinweis: Die Geschwindigkeit hängt von Modell, GPU und Länge der Beschreibung ab – vor einem Batch mit Tausenden Bildern eine Stichprobe von 20 Bildern auf der eigenen Hardware testen.

Anwendungsfall 3: Screenshot- und UI-Analyse

• Entwickler-Workflows: Screenshots von Fehlermeldungen an das Modell weiterleiten: „Was ist falsch und wie würde man es beheben?"
• Bug-Report-Generierung: Automatische Erstellung von Bug-Beschreibungen aus Screenshots.
• Dashboard-Monitoring: Screenshots auf Anomalien analysieren – „Gibt es Metriken auf Warnstufe in diesem Grafana-Screenshot?"
• Accessibility-Testing: Screenshots vor und nach UI-Änderungen vergleichen.
• Beste Modelle: InternVL 2.5 8B (Community-Build, stark bei UI), Gemma 4 und Qwen3-VL (offizielle Ollama-Unterstützung, Tool Calling für Agenten-Workflows).

Anwendungsfall 4: Diagramm- und Grafikanalyse

• Was gut funktioniert: Achsenbeschriftungen lesen, Trends erkennen, relative Balkenhöhen vergleichen, Tabellenwerte auslesen.
• Was unzuverlässig ist: Präzise numerische Extraktion aus kontinuierlichen Diagrammen, Kreisdiagramm-Prozentsätze ohne Beschriftungen.
• Prompt-Strategie: „Beschreibe den Trend" funktioniert besser als „Was ist der exakte Wert?"
• Beste Modelle: InternVL 2.5 (starkes Diagrammverständnis), Gemma 4 und Qwen3-VL (gut bei klar beschrifteten Diagrammen).
• Einschränkungshinweis: Kein lokales VLM extrahiert 2026 zuverlässig präzise Zahlen aus komplexen Diagrammen.

Anwendungsfall 5: Video-Frame-Analyse

• Frame-Extraktion: ffmpeg -i video.mp4 -vf fps=1 frames/frame_%04d.jpg
• Frame-für-Frame-Analyse: Jeden Frame mit konsistentem Prompt durch das Vision-Modell schicken.
• Übergreifende Zusammenfassung: Alle Frame-Beschreibungen an ein Text-LLM übergeben.
• Anwendungsfälle: Sicherheitskamera-Review, Vorlesungsaufzeichnungsanalyse, Qualitätskontrolle in der Fertigung.
• Beste Modelle: Gemma 4 oder Qwen3.8 für Qualität (beide akzeptieren Video nativ als Einzelbilder), Qwen3.5 4B oder LLaVA 1.6 7B für Geschwindigkeit (höherer Frame-Durchsatz).
• Geschwindigkeitsrealität: Bei 1 Frame/Sekunde Extraktion und ~1–3 Sekunden pro Frame dauert die Verarbeitung eines 10-minütigen Videos (600 Frames) je nach Modell und GPU etwa 10–30 Minuten.

import base64
import subprocess
import os
import requests

def extract_frames(video_path: str, output_dir: str, fps: int = 1) -> list[str]:
    os.makedirs(output_dir, exist_ok=True)
    subprocess.run([
        "ffmpeg", "-i", video_path,
        "-vf", f"fps={fps}",
        f"{output_dir}/frame_%04d.jpg",
        "-y"
    ], check=True)
    return sorted([
        os.path.join(output_dir, f)
        for f in os.listdir(output_dir)
        if f.endswith(".jpg")
    ])

def analyze_frame(image_path: str, model: str = "gemma4:e4b") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": "Describe what is happening in this frame in one sentence.",
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

frames = extract_frames("vorlesung.mp4", "frames/", fps=1)
descriptions = [analyze_frame(f) for f in frames]
print("\n".join(f"[{i+1}s] {d}" for i, d in enumerate(descriptions)))

VRAM und Leistungs-Realitätscheck

Lokale Vision-Modelle vs. GPT-5.5 Vision

• Strukturierte Dokumente (Rechnungen, Formulare): Redaktionelle Einschätzung, kein gemessener Benchmark: Starke lokale Modelle kommen bei sauberen, gut formatierten Dokumenten nah an GPT-5.5 Vision heran – für den Produktionseinsatz ausreichend, sobald Sie die Ausgabe validieren.
• Komplexe Szenen, mehrdeutige Bilder: Lokale Modelle liegen bei Bildern mit ungewöhnlichem Kontext, schwierigem Licht oder mehrdeutigem Inhalt spürbar hinter GPT-5.5 Vision (redaktionelle Einschätzung, nicht gemessen).
• Handschrifterkennung: Lokale Modelle deutlich schwächer, besonders bei Kursivschrift.
• Diagrammdatenextraktion: Auf beiden unzuverlässig, aber GPT-5.5 bei präzisen Zahlenwerten genauer.
• Kosten: GPT-5.5 Vision bei 0,01–0,03 $ pro Bild vs. 0 $ lokal. 10.000 Bilder/Monat = 100–300 $ gespart.
• Datenschutz: Lokale Modelle verarbeiten Bilder standardmäßig auf dem Gerät – Bilder werden nicht an eine Cloud-API gesendet, solange Sie keine Cloud-Funktionen oder vernetzten Tools aktivieren.
• Geschwindigkeit: Lokale Modelle erzeugen auf einer RTX 4070 je nach Größe etwa 8–35 Token/Sek. (Richtwerte, siehe Tabelle oben); die Cloud-Geschwindigkeit schwankt je nach Anbieter und Auslastung, lokal gibt es dafür keine Netzwerklatenz.

LLaVA im Detail

• Architektur: CLIP ViT-L/14 Vision-Encoder + Llama-2 oder Mistral Text-Decoder, verbunden durch eine lineare Projektionsschicht.
• LLaVA 1.5 vs. 1.6: Version 1.6 (Anfang 2024) fügte dynamisches Patching für höhere Auflösungen hinzu und verbesserte OCR und Diagrammauswertung deutlich.
• Training: Instruction-tuning auf LLaVA-Instruct-150K – visuellen Konversationen aus Bildbeschriftungen und Objekterkennungsannotationen.
• Stärken: Breites Allgemeinwissen, gut dokumentiert, große Community, umfangreiche Ollama-Integration.
• Schwächen: Schwächere OCR als Qwen3-VL und MiniCPM-V, schwächere UI-Analyse als InternVL 2.5, insgesamt von Gemma 4 und der Qwen3-Familie übertroffen.
• Warum weiterhin empfohlen: Größte Community, meiste Tutorials, meiste Beispiel-Prompts aller lokalen VLMs.
• Vollständiger Test: LLaVA im Test (2026) — PromptQuorums dedizierter Test, einschließlich der Apache-2.0-plus-Basismodell-Lizenznuance und echter Ollama-Befehle.

Qwen3-VL, Qwen3.5 und Qwen3.8 — Beste multilinguale OCR-Leistung

• Architektur: Dynamische Auflösung bis 4096×4096 – deutlich höher als LLaVA 1.6 (672×672) oder Llama 3.2 Vision (1120×1120).
• Mehrsprachige OCR: Beste Klasse für Chinesisch, Japanisch, Koreanisch und Englisch. Umfangreiche mehrsprachige Dokumentkorpora im Training.
• Welche Größe: Qwen3-VL 8B ist ein Download von 6,2 GB und passt auf 8-GB-Karten; Qwen3.5 9B hat 6,6–7,6 GB; Qwen3.8 27B hat 18 GB und braucht eine 24-GB-Karte; Qwen3-VL 32B hat 21 GB. Qwen3-VL hat auf Ollama keine 72B-Variante.
• Qwen3-VL 4B: Download von 3,3 GB (256K Kontext) – die Mitte zwischen den Builds 2B (1,9 GB) und 8B (6,2 GB) für Karten mit etwa 4–6 GB VRAM.
• Ollama-Installation: ollama pull qwen3-vl:8b, ollama pull qwen3.5:9b oder ollama pull qwen3.8 — alle in der Ollama-Modellbibliothek.
• Multi-Bild: Bis zu 8 Bilder pro Anfrage – höchste Kapazität im Vergleich.
• Modellseiten: Qwen3-VL auf Ollama, Qwen3.8-27B auf Hugging Face

Auswahl des richtigen Vision-Modells

• Unter 4 GB VRAM: Qwen3.5 2B (2,7–3,1 GB), Qwen3-VL 2B (1,9 GB) oder Moondream 2 (1,7 GB) sind die praktischen Optionen. PaliGemma 2 (3B) und SmolVLM (2,2B) sind Alternativen als Community-Builds. Keines ist für dichten Text-OCR geeignet.
• 6–8 GB VRAM: Gemma 4 E4B für allgemeine Foto-Q&A, Qwen3-VL 8B oder Qwen3.5 9B für Dokument-OCR und mehrsprachigen Text, LLaVA 1.6 7B, wenn Community-Unterstützung wichtig ist.
• 12–16 GB VRAM: Gemma 4 12B (7,7–8,0 GB Download) ist die klare Empfehlung – starke Vision-Werte für seine Größe, mit Audio-Eingabe und 256K-Kontextfenster. LLaVA 1.6 13B und InternVL 2.5 8B (UI- und Code-Screenshots) passen ebenfalls.
• 24 GB VRAM: Gemma 4 26B A4B (16–19 GB), Gemma 4 31B (19–20 GB), Qwen3.8 27B (18 GB) oder Qwen3-VL 32B (21 GB) – die lokale Option, die der Vision-Qualität von Cloud-Modellen am nächsten kommt.
• 96+ GB Unified Memory (Apple M-Max/Ultra, Multi-GPU): Qwen3.5 122B (81 GB, braucht einen Mac mit 128 GB) oder Llama 3.2 Vision 90B (55 GB) für die größten lokalen Modelle; beide erfordern Hardware mit viel Speicher und sind pro Token langsamer als die Modelle der 24-GB-Klasse.
• Zahlen immer prüfen: Aus Diagrammen extrahierte Zahlenwerte immer gegen Quelldaten gegenchecken.

Häufig gestellte Fragen

Quellen

• Gemma 4 Modell-Card auf Hugging Face — Googles Apache-2.0-Lizenz, unterstützte Modalitäten je Größe und MMMU-Pro-Ergebnisse.
• Gemma 4 auf Ollama — Tags, Download-Größen und Kontextfenster.
• Qwen3.8-27B auf Hugging Face — Apache-2.0-Lizenz, 262K Kontext, OmniDocBench-1.5-Ergebnis.
• Qwen3.5 auf Ollama und Qwen3-VL auf Ollama — Größen und Download-Größen.
• Llama 3.2 Vision auf Ollama und Ollama-Issue #16547 — Eintrag und der gemeldete mllama-Ladefehler.
• LLaVA-Projektseite — LLaVA 1.5 und 1.6 Modell-Cards, Architekturdetails und Trainingsdatensatz.
• MiniCPM-V auf Ollama und OpenBMB auf Hugging Face — Modell-Cards und OCR-Benchmarks.
• Moondream auf Ollama und Moondream auf GitHub — Modell-Download und Inferenzskripte.
• InternVL 2.5 auf Hugging Face — OpenGVLab Modell-Card und Benchmark-Werte.
• Ollama-Dokumentation — Vision-Modell-Unterstützung, strukturierte Ausgaben, API-Referenz und Modellbibliothek.
• PaliGemma 2 auf Hugging Face — Googles PaliGemma 2 3B Modell-Card.
• SmolVLM auf Hugging Face — HuggingFace SmolVLM Modell-Card und Inferenzanleitung.
• llama.cpp-Dokumentation zu multimodalen Modellen — unterstützte Vision-Modelle und Nutzung von llama-server.
• vLLM – unterstützte Modelle — multimodale Architekturen, die vLLM bereitstellen kann.
• Gemma-4-Tags auf Ollama — Größen der Builds q4_K_M, q8_0, bf16, QAT und MLX.

Weiterführende Artikel

• Welche Ollama-Modelle unterstützen Vision? — Kurzantwort, welche Modelle der Ollama-Bibliothek Bilder akzeptieren, mit VRAM-Angaben.
• Ollama-Vision-Modelle (2026) — ein fokussierter, praktischer Leitfaden zum Ausführen von Vision-Modellen speziell über Ollama: echte CLI-/API-Syntax und welche Modelle tatsächlich in seiner Bibliothek sind.
• VLMs in Kameras und auf Drohnen 2026 -- Desktop-VLM-Grundlagen stehen hier; fuer eingebettete Kameras und Drohnen siehe diesen Edge-fokussierten Guide.
• Lokale multimodale KI-Pipeline 2026 — Vision-Modelle mit STT und TTS zu einem vollständigen lokalen Stack kombinieren.
• Lokale Sprache-zu-Text 2026: Whisper.cpp vs. faster-whisper — Spracheingabe als Ergänzung zur Vision-Ausgabe.
• Lokale TTS und Stimmklonierung 2026 — Sprachausgabe für VLM-Antworten.
• Ollama installieren — Voraussetzung: Ollama-Setup und -Konfiguration.
• Lokaler LLM Hardware-Leitfaden — VRAM- und RAM-Anforderungen für Vision-Modell-Inferenz.