Merge pull request #39 from maribakulj/claude/fix-manifest-analysis-performance-BIMKl

backend/app/api/v1/models_api.py

@@ -45,6 +45,7 @@ class ModelSelectRequest(BaseModel):
     model_id: str = Field(..., min_length=1, max_length=256)
     provider_type: str = Field(..., min_length=1, max_length=64)
     display_name: str = Field("", max_length=256)
+    supports_vision: bool = Field(True)
 
 
 class ModelConfigResponse(BaseModel):
@@ -54,6 +55,7 @@ class ModelConfigResponse(BaseModel):
     provider_type: str
     selected_model_id: str
     selected_model_display_name: str
+    supports_vision: bool
     updated_at: datetime
 
 
@@ -133,6 +135,7 @@ async def set_corpus_model(
             provider_type=body.provider_type,
             selected_model_id=body.model_id,
             selected_model_display_name=display_name,
+            supports_vision=body.supports_vision,
             updated_at=datetime.now(timezone.utc),
         )
         db.add(config)
@@ -140,6 +143,7 @@ async def set_corpus_model(
         config.provider_type = body.provider_type
         config.selected_model_id = body.model_id
         config.selected_model_display_name = display_name
+        config.supports_vision = body.supports_vision
         config.updated_at = datetime.now(timezone.utc)
 
     await db.commit()

backend/app/models/database.py

@@ -32,10 +32,13 @@ engine = create_async_engine(
 
 # Activer les clés étrangères SQLite (désactivées par défaut).
 # Nécessaire pour que ondelete="CASCADE" / "SET NULL" fonctionne.
+# Note : on n'appelle PAS cursor.close() car avec aiosqlite le curseur
+# retourne une coroutine pour close(), ce qui provoque un RuntimeWarning
+# « coroutine 'Cursor.close' was never awaited ». Le curseur PRAGMA est
+# éphémère et libéré automatiquement.
 @event.listens_for(engine.sync_engine, "connect")
 def _set_sqlite_pragma(dbapi_conn, _connection_record):
-    cursor = dbapi_conn.execute("PRAGMA foreign_keys=ON")
-    cursor.close()
+    dbapi_conn.execute("PRAGMA foreign_keys=ON")
 
 async_session_factory = async_sessionmaker(
     engine,

backend/app/models/model_config_db.py

@@ -8,7 +8,7 @@ La clé API n'est JAMAIS stockée ici (R06) — elle reste dans l'environnement.
 from datetime import datetime
 
 # 2. third-party
-from sqlalchemy import DateTime, ForeignKey, String
+from sqlalchemy import Boolean, DateTime, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 # 3. local
@@ -26,4 +26,5 @@ class ModelConfigDB(Base):
     provider_type: Mapped[str] = mapped_column(String, nullable=False)
     selected_model_id: Mapped[str] = mapped_column(String, nullable=False)
     selected_model_display_name: Mapped[str] = mapped_column(String, nullable=False)
+    supports_vision: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
     updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)

backend/app/services/ai/analyzer.py

@@ -121,6 +121,7 @@ def run_primary_analysis(
         image_bytes=jpeg_bytes,
         prompt=prompt_text,
         model_id=model_config.selected_model_id,
+        supports_vision=model_config.supports_vision,
     )
 
     # ── 4. Écriture ai_raw.json TOUJOURS EN PREMIER (R05) ─────────────────

backend/app/services/ai/base.py

@@ -42,13 +42,21 @@ class AIProvider(ABC):
         ...
 
     @abstractmethod
-    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
+    def generate_content(
+        self,
+        image_bytes: bytes,
+        prompt: str,
+        model_id: str,
+        supports_vision: bool = True,
+    ) -> str:
         """Envoie une image + prompt à l'IA et retourne le texte brut de la réponse.
 
         Args:
             image_bytes: contenu JPEG de l'image dérivée.
             prompt: texte du prompt rendu depuis le template.
             model_id: identifiant technique du modèle à utiliser.
+            supports_vision: True si le modèle accepte les images (déterminé
+                par l'API du provider lors du listing, stocké en BDD).
 
         Returns:
             Texte brut retourné par l'API (avant parsing).

backend/app/services/ai/provider_google_ai.py

@@ -55,7 +55,7 @@ class GoogleAIProvider(AIProvider):
         )
         return result
 
-    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
+    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str, supports_vision: bool = True) -> str:
         if not self.is_configured():
             raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
         client = genai.Client(api_key=os.environ[_ENV_KEY])

backend/app/services/ai/provider_mistral.py

@@ -72,18 +72,22 @@ def _is_ocr_model(model_id: str) -> bool:
     return "ocr" in model_id.lower()
 
 
+
 def _model_supports_vision(model_id: str, model_obj: object = None) -> bool:
     """Détecte si un modèle Mistral supporte les entrées image.
 
-    Utilise capabilities.vision si disponible (objet SDK v1.x),
-    sinon se rabat sur la présence de 'pixtral', 'vision' ou 'ocr' dans l'ID.
+    Source de vérité unique : capabilities.vision retourné par l'API Mistral.
+    Aucune liste hardcodée de noms de modèles — l'API fait autorité.
+    Si capabilities n'est pas disponible (SDK ancien), retourne False
+    par sécurité (le modèle sera utilisé en mode texte seul).
     """
     if model_obj is not None:
         caps = getattr(model_obj, "capabilities", None)
         if caps is not None:
             return bool(getattr(caps, "vision", False))
-    mid = model_id.lower()
-    return "pixtral" in mid or "vision" in mid or "ocr" in mid
+    # Sans objet modèle (fallback statique), on ne peut pas deviner :
+    # retourner False pour éviter d'envoyer une image à un modèle texte seul.
+    return False
 
 
 class MistralProvider(AIProvider):
@@ -180,18 +184,25 @@ class MistralProvider(AIProvider):
         )
         return list(_MISTRAL_FALLBACK_MODELS)
 
-    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
+    def generate_content(
+        self,
+        image_bytes: bytes,
+        prompt: str,
+        model_id: str,
+        supports_vision: bool = True,
+    ) -> str:
         """Envoie image + prompt à Mistral et retourne le texte brut.
 
         Trois chemins selon le modèle :
           1. OCR (mistral-ocr-latest) :
                client.ocr.process() → markdown de toutes les pages concaténées.
-               L'endpoint OCR retourne du texte structuré, pas des messages chat.
-          2. Vision (Pixtral) :
+          2. Vision (supports_vision=True) :
                client.chat.complete() avec content multimodal (image base64 + texte).
-          3. Texte seul (Mistral Large, Small, Codestral) :
+          3. Texte seul (supports_vision=False) :
                client.chat.complete() avec prompt texte uniquement.
-               L'image n'est pas transmise (avertissement loggé).
+
+        Le flag supports_vision est déterminé dynamiquement par l'API Mistral
+        lors du listing des modèles (capabilities.vision), puis stocké en BDD.
         """
         if not self.is_configured():
             raise RuntimeError(
@@ -222,8 +233,8 @@ class MistralProvider(AIProvider):
                 getattr(page, "markdown", "") for page in pages
             )
 
-        # ── Chemin 2 : Vision multimodale (Pixtral) ──────────────────────────
-        if _model_supports_vision(model_id):
+        # ── Chemin 2 : Vision multimodale ────────────────────────────────────
+        if supports_vision:
             content: object = [
                 {"type": "image_url", "image_url": {"url": data_url}},
                 {"type": "text", "text": prompt},

backend/app/services/ai/provider_vertex_key.py

@@ -57,5 +57,5 @@ class VertexAPIKeyProvider(AIProvider):
     def list_models(self) -> list[ModelInfo]:
         raise RuntimeError(_UNAVAILABLE_MSG)
 
-    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
+    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str, supports_vision: bool = True) -> str:
         raise RuntimeError(_UNAVAILABLE_MSG)

backend/app/services/ai/provider_vertex_sa.py

@@ -85,7 +85,7 @@ class VertexServiceAccountProvider(AIProvider):
         )
         return result
 
-    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str) -> str:
+    def generate_content(self, image_bytes: bytes, prompt: str, model_id: str, supports_vision: bool = True) -> str:
         if not self.is_configured():
             raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
         client = self._build_client()

backend/app/services/ingest/iiif_fetcher.py

@@ -1,15 +1,21 @@
 """
 Téléchargement d'images depuis des URLs IIIF via httpx.
+
+Inclut un rate-limiter global et un retry avec backoff exponentiel
+pour respecter les limites des serveurs IIIF patrimoniaux (Gallica, etc.).
 """
 # 1. stdlib
 import logging
+import re
+import threading
+import time
 
 # 2. third-party
 import httpx
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_TIMEOUT = 30.0  # secondes (connect 10s + read 30s)
+_DEFAULT_TIMEOUT = 60.0  # secondes (connect 15s + read 60s)
 
 _HEADERS = {
     "User-Agent": (
@@ -19,10 +25,119 @@ _HEADERS = {
     "Accept": "image/jpeg,image/png,image/*,*/*",
 }
 
+# ── Rate-limiter global ────────────────────────────────────────────────────
+# Gallica and similar IIIF servers enforce strict rate limits.
+# We enforce a minimum delay between consecutive requests.
+_MIN_REQUEST_INTERVAL = 1.0  # secondes entre deux requêtes
+_rate_lock = threading.Lock()
+_last_request_time = 0.0
+
+# ── Retry configuration ───────────────────────────────────────────────────
+_MAX_RETRIES = 4
+_INITIAL_BACKOFF = 2.0  # secondes, doublé à chaque retry
+
+
+def _wait_rate_limit() -> None:
+    """Attend si nécessaire pour respecter le débit maximal vers les serveurs IIIF."""
+    global _last_request_time
+    with _rate_lock:
+        now = time.monotonic()
+        elapsed = now - _last_request_time
+        if elapsed < _MIN_REQUEST_INTERVAL:
+            time.sleep(_MIN_REQUEST_INTERVAL - elapsed)
+        _last_request_time = time.monotonic()
+
+
+def _fetch_with_retry(url: str, timeout: float) -> httpx.Response:
+    """GET avec retry et backoff exponentiel sur 429 / 5xx.
+
+    Respecte le header Retry-After si présent dans la réponse 429.
+    """
+    backoff = _INITIAL_BACKOFF
+    last_exc: Exception | None = None
+
+    for attempt in range(_MAX_RETRIES + 1):
+        _wait_rate_limit()
+        try:
+            response = httpx.get(
+                url,
+                headers=_HEADERS,
+                follow_redirects=True,
+                timeout=httpx.Timeout(timeout, connect=15.0),
+            )
+            if response.status_code == 429 or response.status_code >= 500:
+                # Respect Retry-After header if present
+                retry_after = response.headers.get("Retry-After")
+                if retry_after:
+                    try:
+                        wait_time = float(retry_after)
+                    except ValueError:
+                        wait_time = backoff
+                else:
+                    wait_time = backoff
+
+                if attempt < _MAX_RETRIES:
+                    logger.warning(
+                        "HTTP %d — retry %d/%d dans %.1fs",
+                        response.status_code,
+                        attempt + 1,
+                        _MAX_RETRIES,
+                        wait_time,
+                        extra={"url": url},
+                    )
+                    time.sleep(wait_time)
+                    backoff *= 2
+                    continue
+                # Last attempt: raise
+                response.raise_for_status()
+
+            response.raise_for_status()
+            return response
+
+        except httpx.TimeoutException as exc:
+            last_exc = exc
+            if attempt < _MAX_RETRIES:
+                logger.warning(
+                    "Timeout — retry %d/%d dans %.1fs",
+                    attempt + 1,
+                    _MAX_RETRIES,
+                    backoff,
+                    extra={"url": url},
+                )
+                time.sleep(backoff)
+                backoff *= 2
+                continue
+            raise
+
+    # Should not reach here, but just in case
+    raise last_exc or RuntimeError(f"Échec après {_MAX_RETRIES} retries : {url}")
+
+
+def _rewrite_full_to_reduced(url: str, max_px: int = 1500) -> str:
+    """Réécrit une URL IIIF /full/full/ ou /full/max/ en /full/!{max_px},{max_px}/.
+
+    Cela demande au serveur IIIF de redimensionner côté serveur au lieu de
+    retourner l'image en pleine résolution. Beaucoup plus rapide et respectueux
+    des quotas serveur.
+
+    Si l'URL n'est pas une URL IIIF standard, elle est retournée inchangée.
+    """
+    # Match IIIF Image API pattern: .../full/(full|max)/0/(default|native).(jpg|png|...)
+    pattern = r"(/full/)(full|max)(/0/)"
+    replacement = rf"\g<1>!{max_px},{max_px}\3"
+    new_url = re.sub(pattern, replacement, url)
+    if new_url != url:
+        logger.info("URL IIIF réécrite: full → !%d,%d", max_px, max_px, extra={"original": url})
+    return new_url
+
 
 def fetch_iiif_image(url: str, timeout: float = _DEFAULT_TIMEOUT) -> bytes:
     """Télécharge une image depuis une URL IIIF complète.
 
+    Si l'URL demande la pleine résolution (/full/full/ ou /full/max/),
+    elle est automatiquement réécrite pour demander un d��rivé 1500px max
+    côté serveur, ce qui est plus rapide et évite le rate-limiting.
+
     Args:
         url: URL complète de l'image (ex. https://.../full/max/0/default.jpg).
         timeout: délai maximal en secondes (défaut : 60 s).
@@ -35,14 +150,9 @@ def fetch_iiif_image(url: str, timeout: float = _DEFAULT_TIMEOUT) -> bytes:
         httpx.TimeoutException: si la requête dépasse le délai.
         httpx.RequestError: pour toute autre erreur réseau.
     """
+    url = _rewrite_full_to_reduced(url)
     logger.info("Fetching IIIF image", extra={"url": url})
-    response = httpx.get(
-        url,
-        headers=_HEADERS,
-        follow_redirects=True,
-        timeout=httpx.Timeout(timeout, connect=10.0),
-    )
-    response.raise_for_status()
+    response = _fetch_with_retry(url, timeout)
     logger.info(
         "IIIF image fetched",
         extra={"url": url, "size_bytes": len(response.content)},
@@ -71,13 +181,7 @@ def fetch_iiif_derivative(
     # Pattern IIIF Image API : !w,h = "best fit" (le serveur choisit)
     derivative_url = f"{service_url.rstrip('/')}/full/!{max_px},{max_px}/0/default.jpg"
     logger.info("Fetching IIIF derivative", extra={"url": derivative_url, "max_px": max_px})
-    response = httpx.get(
-        derivative_url,
-        headers=_HEADERS,
-        follow_redirects=True,
-        timeout=httpx.Timeout(timeout, connect=10.0),
-    )
-    response.raise_for_status()
+    response = _fetch_with_retry(derivative_url, timeout)
     logger.info(
         "IIIF derivative fetched",
         extra={"url": derivative_url, "size_bytes": len(response.content)},

backend/app/services/job_runner.py

@@ -126,7 +126,7 @@ async def _run_job_impl(job_id: str, db: AsyncSession) -> None:
             selected_model_id=model_db.selected_model_id,
             selected_model_display_name=model_db.selected_model_display_name,
             provider=ProviderType(model_db.provider_type),
-            supports_vision=True,
+            supports_vision=model_db.supports_vision,
             last_fetched_at=model_db.updated_at,
             available_models=[],
         )

backend/tests/test_image_pipeline.py

@@ -261,8 +261,11 @@ def test_fetch_iiif_image_success():
     """Retourne les bytes de l'image si la requête réussit."""
     fake_bytes = _make_jpeg_bytes(100, 100)
 
-    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get:
+    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get, \
+         patch("app.services.ingest.iiif_fetcher.time.sleep"), \
+         patch("app.services.ingest.iiif_fetcher.time.monotonic", return_value=0.0):
         mock_response = MagicMock()
+        mock_response.status_code = 200
         mock_response.content = fake_bytes
         mock_response.raise_for_status.return_value = None
         mock_get.return_value = mock_response
@@ -272,15 +275,18 @@ def test_fetch_iiif_image_success():
     assert result == fake_bytes
     _, kwargs = mock_get.call_args
     assert kwargs["follow_redirects"] is True
-    # Timeout is now an httpx.Timeout object (connect=10s, read=30s)
-    assert kwargs["timeout"].connect == 10.0
-    assert kwargs["timeout"].read == 30.0
+    # Timeout is an httpx.Timeout object (connect=15s, read=60s)
+    assert kwargs["timeout"].connect == 15.0
+    assert kwargs["timeout"].read == 60.0
 
 
 def test_fetch_iiif_image_http_error():
-    """Propage HTTPStatusError si le serveur répond 404."""
-    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get:
+    """Propage HTTPStatusError si le serveur répond 404 (pas de retry sur 4xx hors 429)."""
+    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get, \
+         patch("app.services.ingest.iiif_fetcher.time.sleep"), \
+         patch("app.services.ingest.iiif_fetcher.time.monotonic", return_value=0.0):
         mock_response = MagicMock()
+        mock_response.status_code = 404
         mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
             "404 Not Found",
             request=MagicMock(),
@@ -293,8 +299,10 @@ def test_fetch_iiif_image_http_error():
 
 
 def test_fetch_iiif_image_timeout():
-    """Propage TimeoutException si la requête dépasse le délai."""
-    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get:
+    """Propage TimeoutException après épuisement des retries."""
+    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get, \
+         patch("app.services.ingest.iiif_fetcher.time.sleep"), \
+         patch("app.services.ingest.iiif_fetcher.time.monotonic", return_value=0.0):
         mock_get.side_effect = httpx.TimeoutException("timed out")
 
         with pytest.raises(httpx.TimeoutException):
@@ -305,8 +313,11 @@ def test_fetch_iiif_image_custom_timeout():
     """Le timeout personnalisé est bien transmis à httpx.get."""
     fake_bytes = _make_jpeg_bytes(50, 50)
 
-    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get:
+    with patch("app.services.ingest.iiif_fetcher.httpx.get") as mock_get, \
+         patch("app.services.ingest.iiif_fetcher.time.sleep"), \
+         patch("app.services.ingest.iiif_fetcher.time.monotonic", return_value=0.0):
         mock_response = MagicMock()
+        mock_response.status_code = 200
         mock_response.content = fake_bytes
         mock_response.raise_for_status.return_value = None
         mock_get.return_value = mock_response
@@ -314,9 +325,9 @@ def test_fetch_iiif_image_custom_timeout():
         fetch_iiif_image("https://example.com/img.jpg", timeout=120.0)
 
     _, kwargs = mock_get.call_args
-    # Custom timeout wraps in httpx.Timeout(120.0, connect=10.0)
+    # Custom timeout wraps in httpx.Timeout(120.0, connect=15.0)
     assert kwargs["timeout"].read == 120.0
-    assert kwargs["timeout"].connect == 10.0
+    assert kwargs["timeout"].connect == 15.0
 
 
 # ---------------------------------------------------------------------------

backend/tests/test_provider_mistral.py

@@ -88,33 +88,36 @@ def _make_fake_mistralai(models: list[_FakeModel] | None = None) -> _types.Modul
 
 
 # ---------------------------------------------------------------------------
-# _model_supports_vision() — helper pur
+# _model_supports_vision() — détection dynamique via l'API
 # ---------------------------------------------------------------------------
 
-def test_vision_detection_pixtral_by_name():
-    assert _model_supports_vision("pixtral-large-latest") is True
-    assert _model_supports_vision("pixtral-12b-2409") is True
-
-
-def test_vision_detection_text_models_by_name():
-    assert _model_supports_vision("mistral-large-latest") is False
+def test_vision_detection_without_model_obj_returns_false():
+    """Sans objet modèle (pas de capabilities), retourne False par sécurité."""
+    assert _model_supports_vision("pixtral-large-latest") is False
     assert _model_supports_vision("mistral-small-latest") is False
     assert _model_supports_vision("codestral-latest") is False
 
 
-def test_vision_detection_uses_capabilities_when_available():
+def test_vision_detection_uses_capabilities_from_api():
+    """La source de vérité est capabilities.vision retourné par l'API Mistral."""
     m_vision = _FakeModel("some-model", vision=True)
     m_text = _FakeModel("some-model", vision=False)
     assert _model_supports_vision("some-model", m_vision) is True
     assert _model_supports_vision("some-model", m_text) is False
 
 
-def test_vision_detection_capabilities_override_name():
-    """capabilities.vision=False surpasse un nom contenant 'pixtral'."""
+def test_vision_detection_capabilities_false_on_any_model():
+    """capabilities.vision=False → pas de vision, quel que soit le nom."""
     m = _FakeModel("pixtral-test", vision=False)
     assert _model_supports_vision("pixtral-test", m) is False
 
 
+def test_vision_detection_capabilities_true_on_any_model():
+    """capabilities.vision=True → vision activée, quel que soit le nom."""
+    m = _FakeModel("mistral-small-latest", vision=True)
+    assert _model_supports_vision("mistral-small-latest", m) is True
+
+
 # ---------------------------------------------------------------------------
 # is_configured()
 # ---------------------------------------------------------------------------
@@ -263,25 +266,27 @@ def test_list_models_fallback_backward_compat():
 # ---------------------------------------------------------------------------
 
 def test_generate_content_vision_model_returns_text(monkeypatch):
-    """Modèle vision (Pixtral) : envoie l'image et retourne la réponse."""
+    """Modèle vision : envoie l'image et retourne la réponse."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
     fake = _make_fake_mistralai()
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
     result = MistralProvider().generate_content(
-        b"fake-jpeg", "Analyse ce folio.", "pixtral-large-latest"
+        b"fake-jpeg", "Analyse ce folio.", "pixtral-large-latest",
+        supports_vision=True,
     )
     assert result == "Voici le JSON de la page."
 
 
 def test_generate_content_text_model_returns_text(monkeypatch):
-    """Modèle texte (Mistral Large) : envoie seulement le prompt, retourne la réponse."""
+    """Modèle texte (supports_vision=False) : envoie seulement le prompt."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
     fake = _make_fake_mistralai()
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
     result = MistralProvider().generate_content(
-        b"fake-jpeg", "Analyse ce folio.", "mistral-large-latest"
+        b"fake-jpeg", "Analyse ce folio.", "mistral-large-latest",
+        supports_vision=False,
     )
     assert result == "Voici le JSON de la page."
 
@@ -305,7 +310,7 @@ def test_generate_content_vision_sends_image_url(monkeypatch):
     fake.Mistral = _FakeMistral
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
-    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest")
+    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest", supports_vision=True)
 
     assert len(captured) == 1
     content = captured[0]["content"]
@@ -316,7 +321,7 @@ def test_generate_content_vision_sends_image_url(monkeypatch):
 
 
 def test_generate_content_text_sends_string_content(monkeypatch):
-    """Modèle texte : le message content est une chaîne (pas d'image)."""
+    """Modèle texte (supports_vision=False) : le message content est une chaîne (pas d'image)."""
     monkeypatch.setenv("MISTRAL_API_KEY", "test-key")
     captured: list[dict] = []
 
@@ -334,7 +339,7 @@ def test_generate_content_text_sends_string_content(monkeypatch):
     fake.Mistral = _FakeMistral
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
-    MistralProvider().generate_content(b"jpeg", "mon prompt", "mistral-large-latest")
+    MistralProvider().generate_content(b"jpeg", "mon prompt", "mistral-large-latest", supports_vision=False)
 
     assert len(captured) == 1
     assert captured[0]["content"] == "mon prompt"
@@ -479,7 +484,7 @@ def test_generate_content_ocr_model_not_called_for_vision(monkeypatch):
     fake.Mistral = _FakeMistral
     monkeypatch.setitem(sys.modules, "mistralai", fake)
 
-    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest")
+    MistralProvider().generate_content(b"jpeg", "prompt", "pixtral-large-latest", supports_vision=True)
     assert len(ocr_called) == 0
 
 

frontend/src/lib/api.ts

@@ -280,11 +280,13 @@ export const selectModel = (
   modelId: string,
   displayName: string,
   providerType: string,
+  supportsVision: boolean = true,
 ): Promise<CorpusModelConfig> =>
   put(`/api/v1/corpora/${corpusId}/model`, {
     model_id: modelId,
     display_name: displayName,
     provider_type: providerType,
+    supports_vision: supportsVision,
   })
 
 export const deleteCorpus = (id: string): Promise<void> =>
@@ -295,6 +297,7 @@ export interface CorpusModelConfig {
   selected_model_id: string
   selected_model_display_name: string
   provider_type: string
+  supports_vision: boolean
   updated_at: string
 }
 

frontend/src/pages/Admin.tsx

@@ -190,7 +190,7 @@ function ModelPanel({ corpusId, onSaved }: ModelPanelProps) {
     setSavingModel(true)
     const model = models.find((m) => m.model_id === selectedModelId)
     try {
-      await selectModel(corpusId, selectedModelId, model?.display_name ?? selectedModelId, selectedProvider)
+      await selectModel(corpusId, selectedModelId, model?.display_name ?? selectedModelId, selectedProvider, model?.supports_vision ?? true)
       const updated = await getCorpusModel(corpusId)
       setCurrentModel(updated)
       setSaveSuccess(`Modele "${model?.display_name ?? selectedModelId}" associe.`)