Vision et multimodal avec Ollama : Gemma 4 et Llama 3.2 Vision en local

Analyser une image en local en 2026 n'est plus de la science-fiction : avec Gemma 4 (Google, avril 2026) ou Llama 3.2 Vision (Meta), votre GPU consumer ou votre Mac M4 décrit, classifie et extrait des informations d'images sans envoyer un seul pixel sur le cloud. Pour des cas sensibles (santé, défense, vie privée), c'est un changement de paradigme — et c'est ce qu'on va construire ensemble.

Ce que vous allez apprendre

• Choisir entre Gemma 4 et Llama 3.2 Vision selon votre matériel
• Décrire une image localement en français
• Extraire un JSON structuré d'une image (combiner Vision + Structured Outputs)
• Faire de l'OCR local : extraire le texte d'une capture d'écran
• Les vraies limites des modèles vision Ollama en 2026

Quels modèles vision en 2026 ?

Modèle	Tag Ollama	Taille	VRAM	Spécificités
Gemma 4	gemma4	9.6 Go	~10 Go	Vision + tool calling natifs (avril 2026), Apache 2.0, 256 K context
Llama 3.2 Vision 11B	llama3.2-vision	7.8 Go	~8 Go	Multimodal Meta, anglais principalement
Llama 3.2 Vision 90B	llama3.2-vision:90b	~55 Go	~64 Go	Réservé aux GPU pro (H100, A100)
Qwen 2.5-VL	qwen2.5-vl	~5 Go	~6 Go	Multimodal Alibaba, multilingue
LLaVA	llava:7b	~4.7 Go	~5 Go	Classique, alternative légère

Glissez pour voir

Mon choix par défaut : gemma4 — c'est le premier modèle qui combine vision et tool calling natifs, et qui parle un français impeccable. Sur un GPU 12 Go, il rentre confortablement.

Prérequis et installation

1. Vérifier la version d'Ollama (le full support Gemma 4 demande 0.22.1 minimum) :

   ollama --version
   # Si < 0.22, mettre à jour :
   curl -fsSL https://ollama.com/install.sh | sh

2. Pull le modèle :

   ollama pull gemma4              # 9.6 Go, recommandé
   # ou
   ollama pull llama3.2-vision     # 7.8 Go, alternative

3. Installer les dépendances Python :

   pyproject.toml

   [project]
   dependencies = [
       "ollama==0.6.2",
       "pydantic[email]==2.13.4",
       "pillow==11.3.0",
   ]

   uv sync

Premier appel : décrire une image

Le code minimal pour qu'un LLM Ollama décrive une image que vous lui passez :

01-describe.py

from pathlib import Path
from ollama import Client

MODEL = "gemma4"
HOST = "http://localhost:11434"
IMAGE = Path("sample.png")  # Une image PNG ou JPEG, n'importe laquelle

client = Client(host=HOST)
response = client.chat(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": "Décris cette image en 3-4 phrases.",
            "images": [str(IMAGE)],   # 👈 ICI : chemin vers l'image
        }
    ],
    options={"temperature": 0.2},
)
print(response["message"]["content"])

Sortie réelle testée sur H100 avec gemma4 (image : un carré rouge et un cercle bleu sur fond blanc) :

Cette image présente une composition très simple et géométrique, composée de deux
formes distinctes placées côte à côte sur un fond blanc. À gauche, on trouve un
carré de couleur rouge vif, qui occupe une grande partie de l'espace. À droite,
il y a un cercle de couleur bleu profond, contrastant fortement avec le carré
rouge. L'ensemble est donc une juxtaposition classique de deux formes géométriques
fondamentales – le carré et le cercle – utilisant des couleurs primaires vives.

Comment Ollama reçoit l'image

Vous pouvez passer :

• Un chemin local (str(Path)) — le plus simple
• Du contenu binaire base64-encodé — utile si l'image vient d'une requête HTTP

Formats acceptés : PNG, JPEG. Pas de SVG (graphique vectoriel non rastérisé).

Vision + Structured Outputs : la combinaison qui change tout

L'intérêt majeur en 2026 : combiner vision et sortie structurée. Au lieu de récupérer du texte libre que vous devez parser, vous récupérez directement un objet Pydantic typé depuis l'analyse d'une image.

Cas d'usage : automatiser l'analyse de photos produits pour un catalogue e-commerce, ou modérer des contenus uploadés par des utilisateurs.

02-structured.py

from pathlib import Path
from typing import Literal
from ollama import Client
from pydantic import BaseModel, Field

MODEL = "gemma4"
HOST = "http://localhost:11434"
IMAGE = Path("sample.png")

class AnalyseImage(BaseModel):
    """Analyse structurée d'une image."""
    type_image: Literal["photo", "schema", "capture_ecran", "illustration", "autre"]
    objets_principaux: list[str] = Field(description="3-5 objets visibles, en français.")
    couleurs_dominantes: list[str] = Field(description="2-4 couleurs majoritaires.")
    contient_texte: bool
    texte_extrait: str | None = Field(default=None, description="Texte visible si présent.")
    description_courte: str = Field(description="1 phrase de résumé.")

client = Client(host=HOST)
response = client.chat(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": "Analyse cette image et remplis le JSON demandé.",
            "images": [str(IMAGE)],
        }
    ],
    format=AnalyseImage.model_json_schema(),     # 👈 Structured Output
    options={"temperature": 0},
)
analyse = AnalyseImage.model_validate_json(response["message"]["content"])
print(analyse.model_dump_json(indent=2))

Sortie réelle obtenue :

{
  "type_image": "illustration",
  "objets_principaux": ["carré rouge", "cercle bleu"],
  "couleurs_dominantes": ["rouge", "bleu", "blanc"],
  "contient_texte": false,
  "texte_extrait": null,
  "description_courte": "L'image présente deux formes géométriques simples..."
}

L'intérêt énorme

Vous récupérez un objet Python typé (analyse.objets_principaux est une list[str]), prêt à être inséré dans une base de données, envoyé à une API, ou affiché dans une interface. Plus de regex sur du texte libre, plus de parsing fragile. Le LLM est forcé de respecter votre schéma.

OCR local : extraire du texte d'une capture

L'OCR (Optical Character Recognition, reconnaissance optique de caractères) consiste à extraire le texte présent dans une image. Les modèles vision Ollama font ça plutôt bien sur des captures d'écran lisibles, mais moins bien que des outils dédiés (Tesseract, docTR) sur du texte dense ou manuscrit.

03-ocr.py

from pathlib import Path
from ollama import Client

client = Client(host="http://localhost:11434")
response = client.chat(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": (
                "Extrait UNIQUEMENT le texte visible dans cette image. "
                "Ne décris rien d'autre. Conserve la mise en forme (sauts de ligne, listes)."
            ),
            "images": [str(Path("sample.png"))],
        }
    ],
    options={"temperature": 0},
)
print(response["message"]["content"])

Sortie réelle obtenue sur H100 avec gemma4 (image contenant le texte « Lab Ollama Vision 2026 - dev H100 ») :

Lab Ollama Vision 2026 - dev H100

Texte exact, sans hallucination, sans description ajoutée. Le prompt « UNIQUEMENT le texte » est essentiel.

Quand préférer Tesseract ou docTR

Pour de l'OCR critique (factures, formulaires administratifs, scans denses), n'utilisez pas Gemma 4 / Llama Vision. Préférez des OCR dédiés :

• Tesseract (open source, classique)
• docTR (HuggingFace, transformer)
• PaddleOCR (très bon sur le multilingue)

Gemma 4 vision est un LLM qui voit du texte, pas un OCR optimisé. Il a tendance à résumer ou paraphraser s'il trouve un mot peu lisible, là où Tesseract échouera proprement avec un blanc.

Pièges et limites en 2026

Le modèle hallucine sur les détails fins

Sur un schéma technique avec 20 composants, Gemma 4 risque d'inventer un composant supplémentaire ou de mal nommer un détail. Pour ces cas, fragmentez votre image en sous-zones, ou utilisez un modèle plus gros (Llama 3.2 Vision 90B sur GPU H100).

Pas de raisonnement multi-étape complexe

Les modèles vision Ollama 2026 ne sont pas encore au niveau de Gemini 2.5 Pro ou GPT-4o sur du raisonnement complexe à partir d'une image (« combien d'étapes y a-t-il dans ce diagramme et quelle est la dépendance entre 3 et 5 ? »). Pour ça, restez sur des APIs cloud — ou attendez les prochaines versions locales.

Performance variable selon la taille de l'image

Plus l'image est grande, plus le LLM consomme de tokens visuels (un peu comme du texte). Une photo 4K prend beaucoup plus de VRAM qu'une vignette 512×512. Pour gagner en vitesse, redimensionnez vos images avant l'appel (Pillow le fait en 3 lignes).

Cas d'usage : analyse de photos produits

Combinaison Vision + Structured Outputs pour automatiser le catalogage e-commerce :

class FicheProduit(BaseModel):
    categorie: Literal["vetement", "electronique", "alimentation", "mobilier", "autre"]
    couleurs: list[str]
    materiaux_apparents: list[str]
    style: Literal["moderne", "vintage", "industriel", "minimaliste", "classique"]
    qualite_photo: Literal["pro", "amateur", "floue"]
    description_seo: str = Field(description="Description optimisée SEO en 150 caractères.")

# Boucle sur 1000 photos produits
for photo in dossier_photos.glob("*.jpg"):
    response = client.chat(model="gemma4", messages=[...], format=FicheProduit.model_json_schema(), ...)
    fiche = FicheProduit.model_validate_json(response["message"]["content"])
    db.insert(fiche.model_dump())

Sur H100, c'est ~2-3 secondes par photo, 100 % en local, 0 € d'API.

FAQ

Q : Mon GPU a 8 Go de VRAM, est-ce assez pour Gemma 4 ? R : Limite. Gemma 4 demande ~10 Go quantifié Q4. Soit vous prenez Llama 3.2 Vision 11B (~8 Go) qui rentre, soit vous passez à un GPU 12 Go+ pour Gemma 4. Sur Apple Silicon M3/M4 avec 16 Go unified, Gemma 4 marche très bien.

Q : Peut-on passer plusieurs images dans le même appel ? R : Oui, images est une liste. Vous pouvez en passer 2-3 pour que le modèle compare ou raisonne dessus. Au-delà de 4-5, la qualité se dégrade.

Q : Gemma 4 parle-t-il bien français sur l'analyse d'images ? R : Oui, excellent. Mes tests sur des photos et des schémas en français donnent des descriptions riches et idiomatiques. Llama 3.2 Vision est moins bon en français — préférez Gemma 4 pour un usage francophone.

Q : Comment passer une image qui vient d'une requête HTTP (FastAPI) ? R : Pas besoin de la sauvegarder sur disque. Convertissez en base64 :

import base64
img_b64 = base64.b64encode(file_bytes).decode()
client.chat(model="gemma4", messages=[{"role": "user", "content": "...", "images": [img_b64]}])

Q : Le modèle décrit l'image en anglais alors que je demande en français. R : Forcer explicitement dans le prompt : « Réponds en français ». Avec un temperature: 0, le modèle suit cette instruction de manière fiable.

À retenir

• Gemma 4 est le modèle vision Ollama de référence en 2026 : Apache 2.0, français impeccable, vision + tool calling natifs.
• Llama 3.2 Vision reste une bonne alternative plus légère (8 Go VRAM).
• Vision + Structured Outputs = catalogage automatique d'images en JSON typé, sans cloud.
• L'OCR Ollama est correct sur captures lisibles, mais préférez Tesseract/docTR pour de l'OCR critique.
• Redimensionner les images avant l'appel pour gagner en vitesse — pas besoin de 4K pour analyser une photo produit.

Prochaines étapes

Sorties structurées Ollama Le complément naturel : JSON garanti à partir de n'importe quelle source (texte ou image).

Tool Calling avec Ollama Donner des outils Python au LLM. Gemma 4 combine vision et tool calling natifs.

Choisir son modèle Ollama 2026 Cheat sheet complet par usage (chat, code, vision, RAG, agents).

Retour à la formation Ollama Vue d'ensemble : installation, modèles, Python, agents.

×

📖 Voir la documentation →