feat: corpus triplet, post-correction LLM et modèles dynamiques avec capacités

Corpus triplet (image + .ocr.txt + .gt.txt):
- Document.ocr_text: nouveau champ optionnel pour le texte OCR bruité
- load_corpus_from_directory: détecte automatiquement les .ocr.txt
- Corpus.has_ocr_text / ocr_text_count: propriétés de détection
- Backward-compatible: les corpus sans .ocr.txt fonctionnent comme avant

Pipeline post-correction sans OCR engine:
- _run_llm_step(): extraction du code LLM commun de _run_ocr()
- run_with_ocr_text(): nouvelle méthode qui court-circuite l'OCR engine
et utilise le texte OCR du corpus comme entrée directe
- Supporte text_only (LLM textuel), text_and_image (LLM multimodal),
et zero_shot (VLM, ignore l'OCR)

Runner intelligent:
- _io_doc_worker détecte doc.ocr_text + pipeline et route vers
run_with_ocr_text() automatiquement
- Metadata "ocr_source": "corpus" vs "live" pour traçabilité

Modèles dynamiques avec capacités:
- /api/models/{provider} retourne {id, capabilities: ["text","vision"]}
- Filtrage par ?capability=vision pour l'UI
- Heuristiques par provider: Mistral (TEXT_ONLY_MODELS), OpenAI (gpt-4o),
Anthropic (tous vision), Ollama (familles connues)
- Backward-compatible: model_ids[] en plus de models[]

Web backend post-correction:
- CompetitorConfig.ocr_engine peut être "corpus" ou "" pour post-correction
- _engine_from_competitor: construit pipeline sans OCR engine quand corpus
- Upload ZIP et analyse corpus: acceptent .ocr.txt
- _analyze_corpus_dir: retourne has_ocr_text et ocr_text_count

Tests: 890 passed, 0 failed

https://claude.ai/code/session_01UtY7QGAcj2M7pAyU2nvzvn

picarones/core/corpus.py

@@ -1,10 +1,16 @@
 """Chargement et gestion des corpus de documents.
 
-Format supporté (Sprint 1) : dossier local avec paires image / .gt.txt
+Format supporté :
+  - Paires classiques : image + .gt.txt
+  - Triplets post-correction : image + .gt.txt + .ocr.txt
 
 Convention :
-  mon_document.jpg   ←→   mon_document.gt.txt
-  page_001.png       ←→   page_001.gt.txt
+  mon_document.jpg   ←→   mon_document.gt.txt              (paire)
+  mon_document.jpg   ←→   mon_document.gt.txt + mon_document.ocr.txt  (triplet)
+
+Le fichier ``.ocr.txt`` contient le texte OCR bruité (sortie d'un moteur OCR)
+qui sera utilisé comme entrée pour les benchmarks de post-correction LLM.
+Il est optionnel — un corpus sans ``.ocr.txt`` reste un corpus classique.
 
 Extensions d'images acceptées : .jpg, .jpeg, .png, .tif, .tiff, .bmp, .webp
 """
@@ -24,11 +30,17 @@ IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tif", ".tiff", ".bmp", ".webp"}
 
 @dataclass
 class Document:
-    """Une paire (image, texte de vérité terrain)."""
+    """Un document du corpus : image + vérité terrain + (optionnel) OCR bruité.
+
+    Quand ``ocr_text`` est renseigné (corpus triplet), le benchmark de
+    post-correction LLM peut utiliser ce texte au lieu de lancer un moteur OCR.
+    """
 
     image_path: Path
     ground_truth: str
     doc_id: str = ""
+    ocr_text: Optional[str] = None
+    """Texte OCR bruité pré-calculé (``None`` pour les corpus classiques sans ``.ocr.txt``)."""
     metadata: dict = field(default_factory=dict)
 
     def __post_init__(self) -> None:
@@ -54,6 +66,16 @@ class Corpus:
     def __repr__(self) -> str:
         return f"Corpus(name={self.name!r}, documents={len(self.documents)})"
 
+    @property
+    def has_ocr_text(self) -> bool:
+        """True si au moins un document possède un texte OCR pré-calculé."""
+        return any(doc.ocr_text is not None for doc in self.documents)
+
+    @property
+    def ocr_text_count(self) -> int:
+        """Nombre de documents avec un texte OCR pré-calculé."""
+        return sum(1 for doc in self.documents if doc.ocr_text is not None)
+
     @property
     def stats(self) -> dict:
         gt_lengths = [len(doc.ground_truth) for doc in self.documents]
@@ -61,38 +83,52 @@ class Corpus:
             return {"document_count": 0}
         import statistics
 
-        return {
+        s = {
             "document_count": len(self.documents),
             "gt_length_mean": round(statistics.mean(gt_lengths), 1),
             "gt_length_median": round(statistics.median(gt_lengths), 1),
             "gt_length_min": min(gt_lengths),
             "gt_length_max": max(gt_lengths),
+            "has_ocr_text": self.has_ocr_text,
+            "ocr_text_count": self.ocr_text_count,
         }
+        return s
 
 
 def load_corpus_from_directory(
     directory: str | Path,
     name: Optional[str] = None,
     gt_suffix: str = ".gt.txt",
+    ocr_suffix: str = ".ocr.txt",
     encoding: str = "utf-8",
 ) -> Corpus:
-    """Charge un corpus depuis un dossier local de paires image / GT.
+    """Charge un corpus depuis un dossier local.
+
+    Supporte deux formats :
+    - **Paires** : ``image + .gt.txt``
+    - **Triplets** : ``image + .gt.txt + .ocr.txt`` (post-correction LLM)
+
+    Le fichier ``.ocr.txt`` est optionnel.  Quand il est présent, le champ
+    ``Document.ocr_text`` est renseigné et le benchmark peut l'utiliser
+    comme entrée OCR bruitée pour tester la post-correction LLM sans
+    relancer un moteur OCR.
 
     Parameters
     ----------
     directory:
-        Chemin vers le dossier contenant les paires image + fichier GT.
+        Chemin vers le dossier contenant les paires/triplets.
     name:
         Nom du corpus (par défaut : nom du dossier).
     gt_suffix:
         Suffixe des fichiers vérité terrain (par défaut : ``.gt.txt``).
+    ocr_suffix:
+        Suffixe des fichiers OCR bruité (par défaut : ``.ocr.txt``).
     encoding:
         Encodage des fichiers texte (par défaut : utf-8).
 
     Returns
     -------
     Corpus
-        Objet Corpus prêt à être utilisé dans le pipeline.
 
     Raises
     ------
@@ -115,6 +151,8 @@ def load_corpus_from_directory(
         if p.suffix.lower() in IMAGE_EXTENSIONS and not p.name.startswith(".")
     )
 
+    ocr_text_loaded = 0
+
     for image_path in image_paths:
         gt_path = image_path.with_name(image_path.stem + gt_suffix)
         if not gt_path.exists():
@@ -129,10 +167,21 @@ def load_corpus_from_directory(
             skipped += 1
             continue
 
+        # OCR bruité optionnel (.ocr.txt)
+        ocr_text: Optional[str] = None
+        ocr_path = image_path.with_name(image_path.stem + ocr_suffix)
+        if ocr_path.exists():
+            try:
+                ocr_text = ocr_path.read_text(encoding=encoding).strip()
+                ocr_text_loaded += 1
+            except OSError as exc:
+                logger.warning("Impossible de lire %s : %s — OCR bruité ignoré.", ocr_path, exc)
+
         documents.append(
             Document(
                 image_path=image_path,
                 ground_truth=ground_truth,
+                ocr_text=ocr_text,
             )
         )
 
@@ -145,7 +194,13 @@ def load_corpus_from_directory(
     if skipped:
         logger.info("%d image(s) ignorée(s) faute de fichier GT.", skipped)
 
-    logger.info("Corpus '%s' chargé : %d documents.", corpus_name, len(documents))
+    if ocr_text_loaded:
+        logger.info(
+            "Corpus '%s' chargé : %d documents (%d avec OCR bruité — post-correction disponible).",
+            corpus_name, len(documents), ocr_text_loaded,
+        )
+    else:
+        logger.info("Corpus '%s' chargé : %d documents.", corpus_name, len(documents))
     return Corpus(
         name=corpus_name,
         documents=documents,

picarones/core/runner.py

@@ -71,8 +71,23 @@ def _io_doc_worker(
     Exécute l'OCR et calcule les métriques dans un thread.  L'instance du
     moteur est partagée entre les threads — les adaptateurs HTTP sont
     généralement sans état mutable entre les appels.
+
+    Si le document possède un texte OCR pré-calculé (corpus triplet) et que
+    le moteur est un pipeline OCR+LLM, utilise ``run_with_ocr_text()`` pour
+    court-circuiter l'étape OCR et tester directement la post-correction LLM.
     """
-    ocr_result = engine.run(doc.image_path)  # type: ignore[attr-defined]
+    doc_ocr_text = getattr(doc, "ocr_text", None)
+    if doc_ocr_text is not None:
+        # Corpus triplet — vérifier si le moteur supporte run_with_ocr_text
+        run_with = getattr(engine, "run_with_ocr_text", None)
+        if run_with is not None:
+            ocr_result = run_with(doc.image_path, doc_ocr_text)  # type: ignore[attr-defined]
+        else:
+            # Moteur OCR classique — ignorer le texte OCR pré-calculé
+            ocr_result = engine.run(doc.image_path)  # type: ignore[attr-defined]
+    else:
+        ocr_result = engine.run(doc.image_path)  # type: ignore[attr-defined]
+
     return _compute_document_result(
         doc_id=doc.doc_id,  # type: ignore[attr-defined]
         image_path=str(doc.image_path),  # type: ignore[attr-defined]

picarones/pipelines/base.py

@@ -139,72 +139,53 @@ class OCRLLMPipeline(BaseOCREngine):
         ocr_v = self.ocr_engine._safe_version() if self.ocr_engine else "—"
         return f"ocr={ocr_v}; llm={self.llm_adapter.model}"
 
-    def _run_ocr(self, image_path: Path) -> tuple[str, Optional[str]]:
-        """Logique interne du pipeline — appelée par ``run()``.
+    def _run_llm_step(
+        self, image_path: Path, ocr_text: str,
+    ) -> tuple[str, Optional[str]]:
+        """Étape LLM du pipeline (commune à run() et run_with_ocr_text()).
 
-        Returns
-        -------
-        tuple[str, Optional[str]]
-            (llm_text, ocr_intermediate) — ocr_intermediate est None en mode zero_shot.
+        Construit le prompt, appelle le LLM, retourne ``(llm_text, ocr_intermediate)``.
+        ``ocr_intermediate`` est ``None`` en mode zero_shot.
         """
-        ocr_text = ""
-
         if self.mode == PipelineMode.ZERO_SHOT:
             image_b64 = _image_to_b64(image_path)
             prompt = self._build_prompt(image_b64=image_b64)
-            logger.debug(
-                "[%s] zero-shot — longueur prompt : %d car.", self._name, len(prompt)
-            )
             logger.info("[Pipeline] appel LLM pour doc %s (zero-shot)", image_path.name)
             result = self.llm_adapter.complete(prompt, image_b64=image_b64)
-            logger.info("[Pipeline] LLM retourné pour doc %s", image_path.name)
 
         elif self.mode == PipelineMode.TEXT_ONLY:
-            if self.ocr_engine is None:
-                raise ValueError("ocr_engine est requis pour le mode text_only")
-            ocr_result = self.ocr_engine.run(image_path)
-            ocr_text = ocr_result.text
-            logger.debug(
-                "[%s] texte OCR : %d car. → envoi au LLM.",
-                self._name, len(ocr_text),
-            )
             if not ocr_text.strip():
                 logger.warning(
-                    "[%s] le moteur OCR a produit un texte vide pour '%s'. "
-                    "Le LLM recevra un prompt sans texte OCR ({ocr_output} vide).",
+                    "[%s] texte OCR vide pour '%s' — le LLM recevra {ocr_output} vide.",
                     self._name, image_path.name,
                 )
             prompt = self._build_prompt(ocr_text=ocr_text)
-            logger.info("[Pipeline] appel LLM pour doc %s (text_only, ocr=%d chars)", image_path.name, len(ocr_text))
+            logger.info(
+                "[Pipeline] appel LLM pour doc %s (text_only, ocr=%d chars)",
+                image_path.name, len(ocr_text),
+            )
             result = self.llm_adapter.complete(prompt)
-            logger.info("[Pipeline] LLM retourné pour doc %s", image_path.name)
 
         else:  # TEXT_AND_IMAGE
-            if self.ocr_engine is None:
-                raise ValueError("ocr_engine est requis pour le mode text_and_image")
-            ocr_result = self.ocr_engine.run(image_path)
-            ocr_text = ocr_result.text
-            logger.debug(
-                "[%s] texte OCR : %d car. + image → envoi au LLM.",
-                self._name, len(ocr_text),
-            )
             if not ocr_text.strip():
                 logger.warning(
-                    "[%s] le moteur OCR a produit un texte vide pour '%s'. "
-                    "Le LLM recevra un prompt sans texte OCR ({ocr_output} vide).",
+                    "[%s] texte OCR vide pour '%s' — le LLM recevra {ocr_output} vide.",
                     self._name, image_path.name,
                 )
             image_b64 = _image_to_b64(image_path)
             prompt = self._build_prompt(ocr_text=ocr_text, image_b64=image_b64)
-            logger.info("[Pipeline] appel LLM pour doc %s (text_and_image, ocr=%d chars)", image_path.name, len(ocr_text))
+            logger.info(
+                "[Pipeline] appel LLM pour doc %s (text_and_image, ocr=%d chars)",
+                image_path.name, len(ocr_text),
+            )
             result = self.llm_adapter.complete(prompt, image_b64=image_b64)
-            logger.info("[Pipeline] LLM retourné pour doc %s", image_path.name)
+
+        logger.info("[Pipeline] LLM retourné pour doc %s", image_path.name)
 
         if not result.success:
             raise RuntimeError(f"Erreur LLM ({self.llm_adapter.model}): {result.error}")
 
         llm_text = result.text
-        # INFO — bilan OCR→LLM visible sur HuggingFace (niveau INFO)
         logger.info(
             "[Pipeline] %s — OCR: %d chars → LLM: %d chars",
             image_path.name, len(ocr_text), len(llm_text),
@@ -227,6 +208,26 @@ class OCRLLMPipeline(BaseOCREngine):
         ocr_intermediate = ocr_text if self.mode != PipelineMode.ZERO_SHOT else None
         return llm_text, ocr_intermediate
 
+    def _run_ocr(self, image_path: Path) -> tuple[str, Optional[str]]:
+        """Logique interne du pipeline — lance l'OCR engine puis le LLM.
+
+        Returns
+        -------
+        tuple[str, Optional[str]]
+            (llm_text, ocr_intermediate) — ocr_intermediate est None en mode zero_shot.
+        """
+        ocr_text = ""
+        if self.mode != PipelineMode.ZERO_SHOT:
+            if self.ocr_engine is None:
+                raise ValueError(
+                    f"ocr_engine est requis pour le mode {self.mode.value} "
+                    "(utilisez run_with_ocr_text() pour la post-correction sans OCR engine)"
+                )
+            ocr_result = self.ocr_engine.run(image_path)
+            ocr_text = ocr_result.text
+
+        return self._run_llm_step(image_path, ocr_text)
+
     # ------------------------------------------------------------------
     # Override run() pour injecter les métadonnées pipeline
     # ------------------------------------------------------------------
@@ -272,6 +273,69 @@ class OCRLLMPipeline(BaseOCREngine):
             metadata=metadata,
         )
 
+    # ------------------------------------------------------------------
+    # Post-correction avec OCR pré-calculé
+    # ------------------------------------------------------------------
+
+    def run_with_ocr_text(
+        self, image_path: str | Path, ocr_text: str,
+    ) -> EngineResult:
+        """Exécute le pipeline avec un texte OCR pré-fourni (corpus triplet).
+
+        Utilisé quand le corpus contient des fichiers ``.ocr.txt`` : le
+        texte OCR bruité est fourni directement, sans lancer de moteur OCR.
+
+        Parameters
+        ----------
+        image_path:
+            Chemin de l'image (utilisée en mode multimodal, ignorée en text_only).
+        ocr_text:
+            Texte OCR bruité pré-calculé.
+
+        Returns
+        -------
+        EngineResult
+        """
+        image_path = Path(image_path)
+        start = time.perf_counter()
+
+        ocr_intermediate: Optional[str] = ocr_text
+        try:
+            text, _ = self._run_llm_step(image_path, ocr_text)
+            error = None
+        except Exception as exc:  # noqa: BLE001
+            text = ""
+            error = str(exc)
+            logger.warning(
+                "[%s] erreur pipeline (post-correction) pour '%s' : %s",
+                self._name, image_path.name, exc,
+            )
+
+        duration = time.perf_counter() - start
+
+        metadata: dict = {
+            "engine_version": self._safe_version(),
+            "pipeline_mode": self.mode.value,
+            "prompt_file": self.prompt_path,
+            "prompt_template": self._prompt_template,
+            "llm_model": self.llm_adapter.model,
+            "llm_provider": self.llm_adapter.name,
+            "pipeline_steps": self._build_steps_info(),
+            "is_pipeline": True,
+            "ocr_source": "corpus",  # distingue de "live"
+        }
+        if ocr_intermediate is not None:
+            metadata["ocr_intermediate"] = ocr_intermediate
+
+        return EngineResult(
+            engine_name=self.name,
+            image_path=str(image_path),
+            text=text,
+            duration_seconds=round(duration, 4),
+            error=error,
+            metadata=metadata,
+        )
+
     # ------------------------------------------------------------------
     # Helpers
     # ------------------------------------------------------------------

picarones/web/app.py

@@ -173,7 +173,8 @@ class HuggingFaceImportRequest(BaseModel):
 
 class CompetitorConfig(BaseModel):
     name: str = ""
-    ocr_engine: str
+    ocr_engine: str = ""
+    """Moteur OCR : 'tesseract', 'mistral_ocr', ... ou 'corpus' pour utiliser l'OCR pré-calculé."""
     ocr_model: str = ""
     llm_provider: str = ""
     llm_model: str = ""
@@ -418,12 +419,66 @@ def _get_tesseract_langs() -> list[str]:
 
 
 # ---------------------------------------------------------------------------
-# API — models (dynamic per provider)
+# API — models (dynamic per provider, with capability metadata)
 # ---------------------------------------------------------------------------
 
+# Modèles Mistral text-only (pas de support vision)
+_MISTRAL_TEXT_ONLY = frozenset({
+    "ministral-3b-latest", "ministral-8b-latest", "mistral-tiny",
+    "mistral-tiny-latest", "open-mistral-7b", "open-mixtral-8x7b",
+    "mistral-small-latest", "mistral-small-2409",
+})
+
+# Familles Ollama multimodales connues
+_OLLAMA_VISION_FAMILIES = frozenset({
+    "llava", "bakllava", "moondream", "minicpm-v", "llama3.2-vision",
+    "llava-llama3", "llava-phi3", "nanollava",
+})
+
+
+def _model_entry(model_id: str, capabilities: list[str]) -> dict:
+    """Crée une entrée modèle avec son ID et ses capacités."""
+    return {"id": model_id, "capabilities": capabilities}
+
+
+def _infer_mistral_capabilities(model_id: str) -> list[str]:
+    mid = model_id.lower()
+    if mid in _MISTRAL_TEXT_ONLY or any(mid.startswith(p) for p in ("ministral", "open-mistral", "open-mixtral")):
+        return ["text"]
+    if "pixtral" in mid or "mistral-ocr" in mid:
+        return ["text", "vision"]
+    # Mistral Large et autres modèles récents supportent la vision
+    return ["text", "vision"]
+
+
+def _infer_openai_capabilities(model_id: str) -> list[str]:
+    mid = model_id.lower()
+    if "gpt-4o" in mid or "gpt-4-turbo" in mid or "gpt-4.1" in mid or "o1" in mid or "o3" in mid:
+        return ["text", "vision"]
+    return ["text"]
+
+
+def _infer_ollama_capabilities(model_name: str) -> list[str]:
+    base = model_name.split(":")[0].lower()
+    if any(base.startswith(family) for family in _OLLAMA_VISION_FAMILIES):
+        return ["text", "vision"]
+    return ["text"]
+
+
 @app.get("/api/models/{provider}")
-async def api_models(provider: str) -> dict:
-    """Retourne la liste des modèles disponibles pour un provider, en temps réel."""
+async def api_models(
+    provider: str,
+    capability: str = Query(default="", description="Filtre par capacité : 'text', 'vision', ou vide pour tout"),
+) -> dict:
+    """Retourne les modèles disponibles avec leurs capacités (text, vision).
+
+    Interroge l'API du provider en temps réel.  Les capacités sont déterminées
+    par heuristique sur le nom du modèle quand l'API ne fournit pas cette
+    information directement.
+
+    Le paramètre ``capability`` filtre les résultats (ex : ``?capability=vision``
+    ne retourne que les modèles supportant la vision).
+    """
     import urllib.error
     import urllib.request as _urlreq
 
@@ -432,98 +487,128 @@ async def api_models(provider: str) -> dict:
         with _urlreq.urlopen(req, timeout=10) as resp:
             return json.loads(resp.read().decode())
 
+    def _filter_and_format(models: list[dict]) -> dict:
+        if capability:
+            models = [m for m in models if capability in m["capabilities"]]
+        return {
+            "provider": provider,
+            "models": models,
+            "model_ids": [m["id"] for m in models],
+        }
+
     if provider == "tesseract":
-        return {"provider": provider, "models": _get_tesseract_langs()}
+        langs = _get_tesseract_langs()
+        return {"provider": provider, "models": langs, "model_ids": langs}
 
     if provider == "mistral_ocr":
         api_key = os.environ.get("MISTRAL_API_KEY")
         if not api_key:
-            return {"provider": provider, "models": [], "error": "MISTRAL_API_KEY non définie"}
+            return {"provider": provider, "models": [], "model_ids": [], "error": "MISTRAL_API_KEY non définie"}
         try:
             data = _fetch_json(
                 "https://api.mistral.ai/v1/models",
                 {"Authorization": f"Bearer {api_key}"},
             )
-            models = sorted(
-                m["id"] for m in data.get("data", [])
+            models = [
+                _model_entry(m["id"], _infer_mistral_capabilities(m["id"]))
+                for m in data.get("data", [])
                 if "pixtral" in m["id"].lower() or "mistral-ocr" in m["id"].lower()
-            )
-            return {"provider": provider, "models": models}
+            ]
+            return _filter_and_format(sorted(models, key=lambda m: m["id"]))
         except Exception as exc:
-            return {
-                "provider": provider,
-                "models": ["pixtral-12b-2409", "pixtral-large-latest", "mistral-ocr-latest"],
-                "error": str(exc),
-            }
+            fallback = [
+                _model_entry("pixtral-12b-2409", ["text", "vision"]),
+                _model_entry("pixtral-large-latest", ["text", "vision"]),
+                _model_entry("mistral-ocr-latest", ["text", "vision"]),
+            ]
+            return {**_filter_and_format(fallback), "error": str(exc)}
 
     if provider == "openai":
         api_key = os.environ.get("OPENAI_API_KEY")
         if not api_key:
-            return {"provider": provider, "models": [], "error": "OPENAI_API_KEY non définie"}
+            return {"provider": provider, "models": [], "model_ids": [], "error": "OPENAI_API_KEY non définie"}
         try:
             data = _fetch_json(
                 "https://api.openai.com/v1/models",
                 {"Authorization": f"Bearer {api_key}"},
             )
-            models = sorted(
-                (m["id"] for m in data.get("data", []) if "gpt-4" in m["id"].lower()),
-                reverse=True,
-            )
-            return {"provider": provider, "models": models}
+            models = [
+                _model_entry(m["id"], _infer_openai_capabilities(m["id"]))
+                for m in data.get("data", [])
+                if "gpt-4" in m["id"].lower() or "o1" in m["id"].lower() or "o3" in m["id"].lower()
+            ]
+            return _filter_and_format(sorted(models, key=lambda m: m["id"], reverse=True))
         except Exception as exc:
-            return {
-                "provider": provider,
-                "models": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"],
-                "error": str(exc),
-            }
+            fallback = [
+                _model_entry("gpt-4o", ["text", "vision"]),
+                _model_entry("gpt-4o-mini", ["text", "vision"]),
+                _model_entry("gpt-4-turbo", ["text", "vision"]),
+            ]
+            return {**_filter_and_format(fallback), "error": str(exc)}
 
     if provider == "anthropic":
         api_key = os.environ.get("ANTHROPIC_API_KEY")
         if not api_key:
-            return {"provider": provider, "models": [], "error": "ANTHROPIC_API_KEY non définie"}
+            return {"provider": provider, "models": [], "model_ids": [], "error": "ANTHROPIC_API_KEY non définie"}
         try:
             data = _fetch_json(
                 "https://api.anthropic.com/v1/models",
                 {"x-api-key": api_key, "anthropic-version": "2023-06-01"},
             )
-            models = [m["id"] for m in data.get("data", [])]
-            return {"provider": provider, "models": models}
+            # Tous les modèles Claude 3+ supportent la vision
+            models = [_model_entry(m["id"], ["text", "vision"]) for m in data.get("data", [])]
+            return _filter_and_format(models)
         except Exception as exc:
-            return {
-                "provider": provider,
-                "models": ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"],
-                "error": str(exc),
-            }
+            fallback = [
+                _model_entry("claude-sonnet-4-6", ["text", "vision"]),
+                _model_entry("claude-haiku-4-5-20251001", ["text", "vision"]),
+                _model_entry("claude-opus-4-6", ["text", "vision"]),
+            ]
+            return {**_filter_and_format(fallback), "error": str(exc)}
 
     if provider == "mistral":
         api_key = os.environ.get("MISTRAL_API_KEY")
         if not api_key:
-            return {"provider": provider, "models": [], "error": "MISTRAL_API_KEY non définie"}
+            return {"provider": provider, "models": [], "model_ids": [], "error": "MISTRAL_API_KEY non définie"}
         try:
             data = _fetch_json(
                 "https://api.mistral.ai/v1/models",
                 {"Authorization": f"Bearer {api_key}"},
             )
-            models = sorted(
-                m["id"] for m in data.get("data", [])
+            models = [
+                _model_entry(m["id"], _infer_mistral_capabilities(m["id"]))
+                for m in data.get("data", [])
                 if "pixtral" not in m["id"].lower() and "mistral-ocr" not in m["id"].lower()
-            )
-            return {"provider": provider, "models": models}
+            ]
+            return _filter_and_format(sorted(models, key=lambda m: m["id"]))
         except Exception as exc:
-            return {
-                "provider": provider,
-                "models": ["mistral-large-latest", "mistral-small-latest"],
-                "error": str(exc),
-            }
+            fallback = [
+                _model_entry("mistral-large-latest", ["text", "vision"]),
+                _model_entry("mistral-small-latest", ["text"]),
+            ]
+            return {**_filter_and_format(fallback), "error": str(exc)}
 
     if provider == "ollama":
-        return {"provider": provider, "models": _list_ollama_models()}
+        _, model_names = _fetch_ollama_info()
+        models = [
+            _model_entry(name, _infer_ollama_capabilities(name))
+            for name in model_names
+        ]
+        return _filter_and_format(models)
 
     if provider == "google_vision":
-        return {"provider": provider, "models": ["document_text_detection", "text_detection"]}
+        models = [
+            _model_entry("document_text_detection", ["vision"]),
+            _model_entry("text_detection", ["vision"]),
+        ]
+        return _filter_and_format(models)
 
     if provider == "azure_doc_intel":
-        return {"provider": provider, "models": ["prebuilt-document", "prebuilt-read"]}
+        models = [
+            _model_entry("prebuilt-document", ["vision"]),
+            _model_entry("prebuilt-read", ["vision"]),
+        ]
+        return _filter_and_format(models)
 
     if provider == "prompts":
         prompts_dir = Path(__file__).parent.parent / "prompts"
@@ -531,7 +616,7 @@ async def api_models(provider: str) -> dict:
             prompts = sorted(f.name for f in prompts_dir.glob("*.txt"))
         else:
             prompts = []
-        return {"provider": provider, "models": prompts}
+        return {"provider": provider, "models": prompts, "model_ids": prompts}
 
     raise HTTPException(status_code=404, detail=f"Provider inconnu : {provider}")
 
@@ -700,6 +785,12 @@ def _analyze_corpus_dir(path: Path) -> dict:
     else:
         dominant_format = "texte brut"
 
+    # Détecter les fichiers OCR bruité (.ocr.txt) pour les corpus triplets
+    ocr_text_count = sum(
+        1 for p in pairs
+        if (path / (Path(p["image"]).stem + ".ocr.txt")).exists()
+    )
+
     return {
         "doc_count": len(pairs),
         "pairs": pairs[:20],
@@ -709,6 +800,8 @@ def _analyze_corpus_dir(path: Path) -> dict:
         "warnings": [f"GT manquant : {img}" for img in missing_gt[:5]],
         "usable": len(pairs) > 0,
         "gt_format": dominant_format,
+        "has_ocr_text": ocr_text_count > 0,
+        "ocr_text_count": ocr_text_count,
     }
 
 
@@ -729,8 +822,8 @@ def _flatten_zip_to_dir(zf: zipfile.ZipFile, dest: Path) -> None:
         # Ignorer les fichiers cachés macOS (._* créés par AppleDouble dans les ZIPs)
         if name.startswith("."):
             continue
-        # Accepter images, .gt.txt et .xml (ALTO/PAGE)
-        if p.suffix.lower() in _IMAGE_EXTS or name.endswith(".gt.txt") or p.suffix.lower() == ".xml":
+        # Accepter images, .gt.txt, .ocr.txt et .xml (ALTO/PAGE)
+        if p.suffix.lower() in _IMAGE_EXTS or name.endswith(".gt.txt") or name.endswith(".ocr.txt") or p.suffix.lower() == ".xml":
             # Protection ZIP bomb : vérifier la taille décompressée
             total_size += member.file_size
             if total_size > _MAX_ZIP_TOTAL_SIZE:
@@ -762,7 +855,7 @@ async def api_corpus_upload(files: list[UploadFile] = File(...)) -> dict:
                 import io
                 with zipfile.ZipFile(io.BytesIO(data)) as zf:
                     _flatten_zip_to_dir(zf, corpus_dir)
-            elif suffix in _IMAGE_EXTS or filename.endswith(".gt.txt") or suffix in (".txt", ".xml"):
+            elif suffix in _IMAGE_EXTS or filename.endswith(".gt.txt") or filename.endswith(".ocr.txt") or suffix in (".txt", ".xml"):
                 (corpus_dir / filename).write_bytes(data)
             # Ignorer les autres types
 
@@ -1114,36 +1207,73 @@ async def api_benchmark_run(req: BenchmarkRunRequest) -> dict:
     return {"job_id": job_id, "status": "pending"}
 
 
-def _engine_from_competitor(comp: CompetitorConfig) -> Any:
-    """Instancie un moteur OCR (ou pipeline OCR+LLM) depuis une CompetitorConfig."""
-    from picarones.engines.tesseract import TesseractEngine
-    from picarones.engines.mistral_ocr import MistralOCREngine
+def _build_llm_adapter(comp: CompetitorConfig) -> Any:
+    """Instancie un adaptateur LLM depuis la config d'un concurrent."""
+    if comp.llm_provider == "openai":
+        from picarones.llm.openai_adapter import OpenAIAdapter
+        return OpenAIAdapter(model=comp.llm_model or None)
+    elif comp.llm_provider == "anthropic":
+        from picarones.llm.anthropic_adapter import AnthropicAdapter
+        return AnthropicAdapter(model=comp.llm_model or None)
+    elif comp.llm_provider == "mistral":
+        from picarones.llm.mistral_adapter import MistralAdapter
+        return MistralAdapter(model=comp.llm_model or None)
+    elif comp.llm_provider == "ollama":
+        from picarones.llm.ollama_adapter import OllamaAdapter
+        return OllamaAdapter(model=comp.llm_model or None)
+    else:
+        raise ValueError(f"Provider LLM inconnu : {comp.llm_provider}")
 
+
+def _engine_from_competitor(comp: CompetitorConfig) -> Any:
+    """Instancie un moteur OCR (ou pipeline OCR+LLM) depuis une CompetitorConfig.
+
+    Modes supportés :
+    - ``ocr_engine`` = 'tesseract', 'mistral_ocr', etc. → moteur OCR seul
+    - ``ocr_engine`` + ``llm_provider`` → pipeline OCR live + LLM
+    - ``ocr_engine`` = 'corpus' + ``llm_provider`` → post-correction LLM
+      avec OCR pré-calculé (fichiers .ocr.txt du corpus triplet)
+    - ``ocr_engine`` = '' + ``llm_provider`` → LLM seul (zero-shot ou post-correction)
+    """
     engine_id = comp.ocr_engine
 
-    if engine_id == "tesseract":
-        ocr = TesseractEngine(config={"lang": comp.ocr_model or "fra", "psm": 6})
-    elif engine_id == "mistral_ocr":
-        ocr = MistralOCREngine(config={"model": comp.ocr_model or "mistral-ocr-latest"})
-    elif engine_id == "google_vision":
-        try:
-            from picarones.engines.google_vision import GoogleVisionEngine
-            ocr = GoogleVisionEngine(config={"detection_type": comp.ocr_model or "document_text_detection"})
-        except ImportError as exc:
-            raise RuntimeError("Google Vision non disponible (google-cloud-vision non installé).") from exc
-    elif engine_id == "azure_doc_intel":
-        try:
-            from picarones.engines.azure_doc_intel import AzureDocIntelEngine
-            ocr = AzureDocIntelEngine(config={"model": comp.ocr_model or "prebuilt-document"})
-        except ImportError as exc:
-            raise RuntimeError("Azure Document Intelligence non disponible.") from exc
-    else:
-        raise ValueError(f"Moteur OCR inconnu : {engine_id}")
+    # Pipeline post-correction avec OCR pré-calculé (corpus triplet)
+    is_corpus_ocr = engine_id in ("corpus", "")
 
-    if not comp.llm_provider:
-        return ocr
+    if is_corpus_ocr and not comp.llm_provider:
+        raise ValueError(
+            "ocr_engine='corpus' nécessite un llm_provider "
+            "(pour la post-correction ou le zero-shot)"
+        )
+
+    ocr = None
+    if not is_corpus_ocr:
+        from picarones.engines.tesseract import TesseractEngine
+        from picarones.engines.mistral_ocr import MistralOCREngine
 
-    # Pipeline OCR+LLM
+        if engine_id == "tesseract":
+            ocr = TesseractEngine(config={"lang": comp.ocr_model or "fra", "psm": 6})
+        elif engine_id == "mistral_ocr":
+            ocr = MistralOCREngine(config={"model": comp.ocr_model or "mistral-ocr-latest"})
+        elif engine_id == "google_vision":
+            try:
+                from picarones.engines.google_vision import GoogleVisionEngine
+                ocr = GoogleVisionEngine(config={"detection_type": comp.ocr_model or "document_text_detection"})
+            except ImportError as exc:
+                raise RuntimeError("Google Vision non disponible.") from exc
+        elif engine_id == "azure_doc_intel":
+            try:
+                from picarones.engines.azure_doc_intel import AzureDocIntelEngine
+                ocr = AzureDocIntelEngine(config={"model": comp.ocr_model or "prebuilt-document"})
+            except ImportError as exc:
+                raise RuntimeError("Azure Document Intelligence non disponible.") from exc
+        else:
+            raise ValueError(f"Moteur OCR inconnu : {engine_id}")
+
+        if not comp.llm_provider:
+            return ocr
+
+    # Pipeline OCR+LLM (live ou post-correction)
     _mode_map = {
         "text_only": "text_only",
         "post_correction_text": "text_only",
@@ -1153,24 +1283,16 @@ def _engine_from_competitor(comp: CompetitorConfig) -> Any:
     }
     mode = _mode_map.get(comp.pipeline_mode, "text_only")
 
-    if comp.llm_provider == "openai":
-        from picarones.llm.openai_adapter import OpenAIAdapter
-        llm = OpenAIAdapter(model=comp.llm_model or None)
-    elif comp.llm_provider == "anthropic":
-        from picarones.llm.anthropic_adapter import AnthropicAdapter
-        llm = AnthropicAdapter(model=comp.llm_model or None)
-    elif comp.llm_provider == "mistral":
-        from picarones.llm.mistral_adapter import MistralAdapter
-        llm = MistralAdapter(model=comp.llm_model or None)
-    elif comp.llm_provider == "ollama":
-        from picarones.llm.ollama_adapter import OllamaAdapter
-        llm = OllamaAdapter(model=comp.llm_model or None)
-    else:
-        raise ValueError(f"Provider LLM inconnu : {comp.llm_provider}")
+    llm = _build_llm_adapter(comp)
 
     from picarones.pipelines.base import OCRLLMPipeline
     prompt = comp.prompt_file or "correction_medieval_french.txt"
-    pipeline_name = comp.name or f"{engine_id}→{comp.llm_model or comp.llm_provider}"
+
+    if is_corpus_ocr:
+        pipeline_name = comp.name or f"corpus_ocr → {comp.llm_model or comp.llm_provider}"
+    else:
+        pipeline_name = comp.name or f"{engine_id} → {comp.llm_model or comp.llm_provider}"
+
     return OCRLLMPipeline(
         ocr_engine=ocr,
         llm_adapter=llm,