LLM multimodal vision en local : analyser des images avec Ollama

#Pourquoi un LLM vision en local ?

Envoyer une facture client, un screenshot médical ou un document RH chez OpenAI pose un problème de confidentialité que les directions juridiques refusent de plus en plus. Un LLM vision local répond à ces cas concrets : OCR de pièces comptables, description automatique d'un catalogue produit, modération d'images, accessibilité (alt-text), extraction de données depuis des PDF scannés.

La différence avec un OCR classique (Tesseract, PaddleOCR) : un LLM vision comprend la sémantique. Il sait dire "le numéro de TVA est FR12345678901" alors qu'un OCR vous rend une soupe de caractères que vous devez ensuite parser. Sur des documents structurés, la fiabilité dépasse 95 % en mode "extraction JSON".

Ce que vision veut dire ici

Un LLM "multimodal vision" accepte des images en entrée en plus du texte. Il ne génère pas d'images (pour ça, voir Stable Diffusion). Vous lui donnez une image + une question, il répond en texte.

#Les modèles vision disponibles dans Ollama

Ollama supporte nativement plusieurs familles vision depuis la version 0.4 (octobre 2024), et la génération 2026 a rebattu les cartes : la vision est désormais intégrée au tag standard de Qwen 3.5 et Gemma 4, plus besoin d'une variante -vl séparée. Voici les options pertinentes en 2026, classées par taille et qualité d'OCR français.

qwen3.5:9b: Le meilleur compromis qualité/VRAM en 2026. Excellente OCR FR, comprend les tableaux et formulaires, contexte 256k tokens, licence Apache 2.0. ~6,6 Go de poids en Q4.
qwen3.5:4b: Version légère pour 4-6 Go de VRAM ou Mac M1/M2 16 Go. Même famille multimodale Qwen 3.5, OCR FR correcte, descriptions un peu moins riches. ~3,4 Go.
qwen3.8:27b: Pour RTX 3090/4090/5090 (24 Go) : qualité proche de GPT-4o sur l'analyse de documents complexes. Vision, contexte 262k, Apache 2.0. ~18 Go de poids en Q4.
gemma4:12b: L'alternative Google (Gemma 4, avril 2026), multimodale et passée en Apache 2.0. Très bonne en description générale, un peu moins tranchante en OCR pure. ~7,6 Go.
gemma4:26b: Gemma 4 26B-A4B, MoE multimodal. Le palier haut de gamme pour usage pro intensif : ~19 Go de poids, tourne sur 24 Go de VRAM ou un Mac Studio à mémoire unifiée.
gemma4:e2b-it-qat: Gemma 4 E2B quantisé QAT (~4,3 Go). Option compacte pour petite VRAM ou edge, sous licence Apache 2.0.
qwen3.5:2b: Qwen 3.5 2B multimodal (~1,9 Go, contexte 256k). Pour Raspberry Pi 5 ou descriptions rapides en masse. Pas d'OCR sérieuse sur documents complexes.
llava:7b / llava:13b: L'ancêtre historique de 2023. À ne plus déployer : la qualité est très largement dépassée par Qwen 3.5 et Gemma 4 en 2026.

→

Recommandation par défaut

Si vous avez 8 Go de VRAM ou plus, commencez par qwen3.5:9b. C'est le meilleur rapport qualité/poids pour du français en 2026, la vision est incluse dans le tag standard, et la communauté Ollama documente bien ses cas d'usage.

#Prérequis matériels

La VRAM nécessaire pour un LLM vision est légèrement supérieure à son équivalent texte, à cause du vision encoder (souvent un ViT) qui reste chargé en mémoire en plus du modèle de langage.

8 Go VRAM (RTX 3060 12GB, 4060, M1/M2 16GB): qwen3.5:4b confortable, ou qwen3.5:9b (6,6 Go) qui tient tout juste en Q4.
12 Go VRAM (RTX 3060 12GB, 4070, 5070): qwen3.5:9b confortable, gemma4:12b en Q4_K_M.
16 Go VRAM (RTX 4070 Ti Super, 4080, 5070 Ti): Tout ce qui précède + contexte 32k tokens, ou qwen3.5:9b-q8_0 pour la qualité max de la tranche.
24 Go VRAM (RTX 3090, 4090, 5090): qwen3.8:27b (~18 Go) ou gemma4:26b, qualité proche cloud.
Mac M-series 24-48 Go unifié: qwen3.5:9b ou qwen3.8:27b grâce à la mémoire unifiée. Préférez M3/M4 pour la bande passante.

Ollama doit être en version 0.4 minimum pour les modèles vision modernes. Vérifiez avec ollama --version. Si vous êtes en dessous, mettez à jour avant d'aller plus loin.

#1. Installer un modèle vision

L'installation est identique à un modèle texte : ollama pull télécharge les poids et le vision encoder en une seule commande.

Terminal — installer Qwen 3.5 9B

ollama pull qwen3.5:9b

Le téléchargement fait environ 6,6 Go (poids LM en Q4 + encoder ViT). Comptez 2-3 minutes sur fibre. Vérifiez ensuite que le modèle est listé :

Terminal

ollama list

# NAME            ID            SIZE      MODIFIED
# qwen3.5:9b      abc123...     6.6 GB    2 minutes ago

La vision est dans le tag standard

Bonne nouvelle depuis Qwen 3.5 et Gemma 4 : la vision est intégrée au tag par défaut (qwen3.5:9b, gemma4:12b). Fini le piège de l'ancienne génération où il fallait un tag -vl distinct (qwen2.5vl vs qwen2.5). Vérifiez juste que vous avez bien pullé un modèle multimodal récent et non un vieux modèle texte.

#2. Premier test en CLI

Ollama accepte les images directement dans la CLI depuis la version 0.4 : passez le chemin du fichier après votre prompt.

Décrire une image en français

ollama run qwen3.5:9b "Décris cette image en 3 phrases en français." ./photo.jpg

Le modèle charge l'image, l'encode via ViT, et répond en streaming. Sur une RTX 4070, comptez 2-4 secondes pour une description courte, 8-12 secondes pour une analyse détaillée.

Sortie typique

L'image montre un chat tigré assis sur un rebord de fenêtre en bois clair.
Le pelage présente des rayures grises et noires caractéristiques d'un tabby.
À l'arrière-plan, on devine un jardin flou avec de la végétation verte.

→

Plusieurs images d'un coup

Vous pouvez passer plusieurs chemins : ollama run qwen3.5:9b "Compare ces deux images" photo1.jpg photo2.jpg. Utile pour du diff visuel ou de la dédup.

#3. API Python avec image base64

Pour intégrer un LLM vision dans une app, Ollama expose son endpoint REST sur http://localhost:11434. L'image se passe soit en chemin (binding Python), soit en base64 (HTTP brut).

Méthode recommandée : la bibliothèque officielle ollama-python. Elle gère l'encodage base64 pour vous et accepte un chemin directement.

Installation

pip install ollama pillow

vision_local.py — appel simple

import ollama

response = ollama.chat(
    model='qwen3.5:9b',
    messages=[{
        'role': 'user',
        'content': 'Quel est le texte visible sur cette image ? Réponds en français.',
        'images': ['./screenshot.png'],
    }],
)

print(response['message']['content'])

Si vous préférez gérer le base64 vous-même (image en mémoire, blob S3, upload via FastAPI), voici la version explicite :

Avec base64 explicite

import base64
import requests

with open('facture.png', 'rb') as f:
    img_b64 = base64.b64encode(f.read()).decode('utf-8')

response = requests.post(
    'http://localhost:11434/api/chat',
    json={
        'model': 'qwen3.5:9b',
        'messages': [{
            'role': 'user',
            'content': 'Décris cette image.',
            'images': [img_b64],
        }],
        'stream': False,
    },
    timeout=120,
)

print(response.json()['message']['content'])

Format base64 attendu

Ollama accepte le base64 brut, sans préfixe data:image/png;base64,. Si vous récupérez l'image depuis un navigateur, pensez à stripper ce préfixe avant l'appel.

#4. Cas pratique : OCR d'une facture FR

L'extraction structurée depuis un document scanné est le cas d'usage business le plus demandé. Le pattern qui marche le mieux : demander une sortie JSON avec un schéma explicite dans le prompt.

ocr_facture.py

import ollama
import json

SYSTEM = '''Tu es un assistant d'extraction de données comptables.
Tu réponds UNIQUEMENT en JSON valide, sans markdown, sans commentaire.'''

PROMPT = '''Extrais les informations de cette facture française au format JSON :
{
  "fournisseur": str,
  "siret": str ou null,
  "numero_facture": str,
  "date": "YYYY-MM-DD",
  "montant_ht": float,
  "tva": float,
  "montant_ttc": float,
  "lignes": [{"description": str, "quantite": float, "prix_unitaire": float}]
}'''

response = ollama.chat(
    model='qwen3.5:9b',
    messages=[
        {'role': 'system', 'content': SYSTEM},
        {'role': 'user', 'content': PROMPT, 'images': ['./facture.png']},
    ],
    format='json',
    options={'temperature': 0.1},
)

data = json.loads(response['message']['content'])
print(f"Fournisseur : {data['fournisseur']}")
print(f"Montant TTC : {data['montant_ttc']} €")

Deux astuces qui changent la fiabilité du tout au tout : passer format='json' (Ollama force alors un JSON valide en sortie) et baisser la température à 0.1 pour limiter les hallucinations sur les montants. Sur 100 factures FR variées, Qwen 3.5 9B obtient typiquement 92-96 % d'extraction correcte montant TTC + date + fournisseur.

Toujours valider les montants

Même à 96 %, vous aurez 4 erreurs sur 100 factures. En production, validez systématiquement que montant_ht + tva ≈ montant_ttc et flaggez les écarts pour revue humaine. Un LLM n'est pas un comptable agréé.

#Qwen 3.5 vs Gemma 4 : que choisir ?

Les deux familles dominent la scène open-weight vision en 2026. Notre comparatif terrain sur des cas francophones, entre qwen3.5:9b et gemma4:12b :

OCR français (factures, contrats): Qwen 3.5 gagne clairement. Gemma 4 a tendance à "inventer" des chiffres sur les documents flous. Avantage Qwen +15 % de précision.
Description générale d'image: Match nul. Gemma 4 donne des descriptions plus narratives, Qwen 3.5 plus factuelles. Question de goût.
Compréhension de tableaux: Qwen 3.5 excelle. C'est l'un des rares modèles de sa taille qui sait lire un tableau croisé Excel sans le mélanger.
Captioning multilingue (FR/EN/ES): Qwen 3.5 a été entraîné sur plus de langues. Gemma 4 est un cran meilleur en anglais pur.
Latence sur RTX 4070: Comparables : 2-4 s pour une réponse courte. Gemma 4 12B est 10-15 % plus rapide en première inférence (vision encoder plus léger).
Licence: Les deux sont en Apache 2.0 (usage commercial libre) : Gemma 4 a basculé en Apache 2.0 en avril 2026, alignant Google sur Qwen. Plus aucune restriction MAU à surveiller.

→

Verdict pratique

Pour 90 % des cas d'usage francophones (OCR, extraction, description), Qwen 3.5 9B est le choix par défaut. Gemma 4 12B reste pertinent si vous êtes déjà sur l'écosystème Google/Gemma (fine-tuning, déploiement) ou pour du captioning anglais grand public. Besoin de la meilleure qualité documentaire sur 24 Go ? Passez à qwen3.8:27b.

#Dépannage

"Error: model does not support images": Vous appelez un modèle texte. Vérifiez que vous avez pullé un modèle multimodal récent (qwen3.5, gemma4, ou l'ancien llava). ollama list doit afficher le bon modèle.
Le modèle décrit autre chose que l'image: Le base64 est probablement corrompu ou contient le préfixe data:image. Strippez data:image/png;base64, avant l'appel. Testez d'abord en CLI pour isoler le problème.
VRAM saturée au chargement: Le vision encoder s'ajoute aux poids LM. Passez à une quantization plus agressive (q3_K_M) ou réduisez OLLAMA_NUM_CTX à 4096 dans l'env.
OCR rate les accents français: Précisez explicitement "Réponds en français en préservant les accents" dans le system prompt. Sinon le modèle latinise parfois (e à la place de é).
Temps de réponse > 30 s: Une image 4000x3000 explose le nombre de tokens visuels. Redimensionnez à 1024x1024 max avant envoi : 90 % de la qualité OCR pour 10 % du compute.

Redimensionner avant inférence

from PIL import Image

img = Image.open('facture_4k.png')
img.thumbnail((1024, 1024), Image.LANCZOS)
img.save('facture_resized.png', optimize=True)

#Pour aller plus loin

Vous avez un LLM vision local fonctionnel. Trois directions naturelles pour aller plus loin :

Intégrer dans une app Python complète: Le guide Intégrer Ollama dans une application Python via l'API REST détaille FastAPI, streaming, function calling — applicable tel quel aux modèles vision.
Construire un pipeline d'extraction documentaire: Le guide Compta : extraction de factures montre l'industrialisation complète (queue de jobs, validation, export ERP) à partir d'un LLM vision local.
Choisir le GPU adapté à votre charge: Le guide Choisir son GPU pour l'IA locale couvre les paliers VRAM 12/16/24 Go et leur impact sur les modèles vision 4B/9B/27B.

Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.

Suite logique

Développement · 15 min