doc-ai-runtime 0.1.0__tar.gz

doc_ai_runtime-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 alain2022kalo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

doc_ai_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: doc-ai-runtime
+Version: 0.1.0
+Summary: Modular Document AI Runtime for RAG and Markdown exports.
+Author-email: Alain Kalombo <alain.kalombo@anztech.dev>
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-docx
+Requires-Dist: python-pptx
+Requires-Dist: openpyxl
+Requires-Dist: pytesseract
+Requires-Dist: Pillow
+Requires-Dist: PyMuPDF
+Requires-Dist: surya-ocr
+Requires-Dist: ollama
+Dynamic: license-file
+
+# 📄 Document AI Runtime
+
+Un pipeline modulaire et extensible pour l'extraction de documents (OCR et Bureautique), conçu pour transformer des PDF, images et Word en formats structurés (Markdown et RAG).
+
+Inspiré des capacités de solutions comme ABBYY, ce runtime repose sur une architecture de plugins indépendants manipulant un modèle de données canonique (DOM). 
+
+## 🚀 Fonctionnalités
+
+* **Multi-Formats natifs et OCR :**
+  * **Bureautique (Path B)** : DOCX, XLSX (Excel), PPTX (PowerPoint) extraits nativement.
+  * **PDF Hybride** : Extrait le calque texte natif, et bascule automatiquement sur l'OCR (Surya + Tesseract) pour les pages scannées.
+  * **Images (Path A)** : JPG, PNG traités via IA (Surya Layout + Tesseract OCR).
+* **Moteur XY-Cut** : Algorithme récursif de coupe verticale/horizontale pour reconstruire l'ordre de lecture des documents multi-colonnes complexes.
+* **Exports spécialisés :** Markdown (structuré) et RAG (JSON chunké avec métadonnées).
+
+## 📦 Installation
+
+Installer la bibliothèque et ses dépendances :
+
+	```bash
+	pip install -e .
+
+## 🛠 Architecture
+
+Le projet est construit autour de 4 piliers :
+1. **Le DOM (Document Object Model) :** Des classes Python (`Document`, `Page`, `Region`, `Block`, `Table`, `Cell`) qui modélisent le document de bout en bout.
+2. **Les Interfaces :** `IDocumentLoader` et `IDocumentPlugin` garantissent que tous les modules (Surya, Tesseract, python-docx) communiquent avec le même langage.
+3. **Les Plugins :** Chaque étape (chargement, layout, OCR) est un module interchangeable dans `src/plugins/`. *Remplacer Surya par un autre moteur de layout n'impacte pas le reste du code.*
+4. **Le Pipeline Runner :** L'orchestrateur qui détecte le type de fichier et exécute le bon chemin (A ou B) automatiquement.
+
+## 📦 Installation
+
+### 1. Prérequis Python
+Clonez le dépôt et installez les dépendances Python :
+	```bash
+	pip install python-docx pytesseract Pillow PyMuPDF surya-ocr
+
+### 2. Dépendances Système
+	Tesseract OCR :
+		Windows : Téléchargez l'installeur sur UB-Mannheim et ajoutez-le au PATH.
+		Linux : sudo apt install tesseract-ocr
+	Surya OCR (Optionnel) : Nécessite llama.cpp pour fonctionner. Le runner peut fonctionner avec Tesseract seul si Surya n'est pas configuré.
+
+🏃 Utilisation
+
+	Le runtime s'utilise via le script test_runtime.py (ou votre propre script) qui appelle le PipelineRunner.
+
+	from src.core.pipeline.runner import PipelineRunner
+
+	runner = PipelineRunner()
+
+# Pour un PDF ou une Image -> Export Markdown
+
+	result_md = runner.process("mon_document.pdf", export_mode="markdown")
+	print(result_md)
+
+# Pour un Word -> Export RAG
+
+	result_rag = runner.process("mon_document.docx", export_mode="rag")
+	print(result_rag)
+
+🏃 Utilisation (CLI)
+
+	python main.py --file mon_document.pdf --export markdown
+
+🗂 Structure du dépôt
+
+	doc-ai-runtime/
+	├── src/
+	│   ├── core/               # Le cœur (DOM, Interfaces, Runner)
+	│   │   ├── dom/            # Modèles de données (Document, Page, Block...)
+	│   │   └── pipeline/       # Orchestrateur (runner.py)
+	│   ├── plugins/            # Les briques interchangeables
+	│   │   ├── loaders/        # ImageLoader, PdfLoader, DocxLoader
+	│   │   ├── layout/         # SuryaLayoutPlugin
+	│   │   └── ocr/           # TesseractOCRPlugin
+	│   └── exporters/         # MarkdownExporter, RagExporter
+	├── test_runtime.py         # Script de démonstration
+	└── README.md
+
+🗺 Feuille de route (Roadmap)
+
+	 Document Object Model (DOM)
+	 Loaders (DOCX, Images, PDF)
+	 Layout Analysis (Surya) & OCR (Tesseract)
+	 Exporters Markdown et RAG
+	 Image Quality Analyzer (pré-traitement des scans)
+	 Amélioration du moteur d'ordre de lecture (Reading Order Engine)

doc_ai_runtime-0.1.0/README.md

@@ -0,0 +1,88 @@
+# 📄 Document AI Runtime
+
+Un pipeline modulaire et extensible pour l'extraction de documents (OCR et Bureautique), conçu pour transformer des PDF, images et Word en formats structurés (Markdown et RAG).
+
+Inspiré des capacités de solutions comme ABBYY, ce runtime repose sur une architecture de plugins indépendants manipulant un modèle de données canonique (DOM). 
+
+## 🚀 Fonctionnalités
+
+* **Multi-Formats natifs et OCR :**
+  * **Bureautique (Path B)** : DOCX, XLSX (Excel), PPTX (PowerPoint) extraits nativement.
+  * **PDF Hybride** : Extrait le calque texte natif, et bascule automatiquement sur l'OCR (Surya + Tesseract) pour les pages scannées.
+  * **Images (Path A)** : JPG, PNG traités via IA (Surya Layout + Tesseract OCR).
+* **Moteur XY-Cut** : Algorithme récursif de coupe verticale/horizontale pour reconstruire l'ordre de lecture des documents multi-colonnes complexes.
+* **Exports spécialisés :** Markdown (structuré) et RAG (JSON chunké avec métadonnées).
+
+## 📦 Installation
+
+Installer la bibliothèque et ses dépendances :
+
+	```bash
+	pip install -e .
+
+## 🛠 Architecture
+
+Le projet est construit autour de 4 piliers :
+1. **Le DOM (Document Object Model) :** Des classes Python (`Document`, `Page`, `Region`, `Block`, `Table`, `Cell`) qui modélisent le document de bout en bout.
+2. **Les Interfaces :** `IDocumentLoader` et `IDocumentPlugin` garantissent que tous les modules (Surya, Tesseract, python-docx) communiquent avec le même langage.
+3. **Les Plugins :** Chaque étape (chargement, layout, OCR) est un module interchangeable dans `src/plugins/`. *Remplacer Surya par un autre moteur de layout n'impacte pas le reste du code.*
+4. **Le Pipeline Runner :** L'orchestrateur qui détecte le type de fichier et exécute le bon chemin (A ou B) automatiquement.
+
+## 📦 Installation
+
+### 1. Prérequis Python
+Clonez le dépôt et installez les dépendances Python :
+	```bash
+	pip install python-docx pytesseract Pillow PyMuPDF surya-ocr
+
+### 2. Dépendances Système
+	Tesseract OCR :
+		Windows : Téléchargez l'installeur sur UB-Mannheim et ajoutez-le au PATH.
+		Linux : sudo apt install tesseract-ocr
+	Surya OCR (Optionnel) : Nécessite llama.cpp pour fonctionner. Le runner peut fonctionner avec Tesseract seul si Surya n'est pas configuré.
+
+🏃 Utilisation
+
+	Le runtime s'utilise via le script test_runtime.py (ou votre propre script) qui appelle le PipelineRunner.
+
+	from src.core.pipeline.runner import PipelineRunner
+
+	runner = PipelineRunner()
+
+# Pour un PDF ou une Image -> Export Markdown
+
+	result_md = runner.process("mon_document.pdf", export_mode="markdown")
+	print(result_md)
+
+# Pour un Word -> Export RAG
+
+	result_rag = runner.process("mon_document.docx", export_mode="rag")
+	print(result_rag)
+
+🏃 Utilisation (CLI)
+
+	python main.py --file mon_document.pdf --export markdown
+
+🗂 Structure du dépôt
+
+	doc-ai-runtime/
+	├── src/
+	│   ├── core/               # Le cœur (DOM, Interfaces, Runner)
+	│   │   ├── dom/            # Modèles de données (Document, Page, Block...)
+	│   │   └── pipeline/       # Orchestrateur (runner.py)
+	│   ├── plugins/            # Les briques interchangeables
+	│   │   ├── loaders/        # ImageLoader, PdfLoader, DocxLoader
+	│   │   ├── layout/         # SuryaLayoutPlugin
+	│   │   └── ocr/           # TesseractOCRPlugin
+	│   └── exporters/         # MarkdownExporter, RagExporter
+	├── test_runtime.py         # Script de démonstration
+	└── README.md
+
+🗺 Feuille de route (Roadmap)
+
+	 Document Object Model (DOM)
+	 Loaders (DOCX, Images, PDF)
+	 Layout Analysis (Surya) & OCR (Tesseract)
+	 Exporters Markdown et RAG
+	 Image Quality Analyzer (pré-traitement des scans)
+	 Amélioration du moteur d'ordre de lecture (Reading Order Engine)

doc_ai_runtime-0.1.0/doc_ai_runtime.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: doc-ai-runtime
+Version: 0.1.0
+Summary: Modular Document AI Runtime for RAG and Markdown exports.
+Author-email: Alain Kalombo <alain.kalombo@anztech.dev>
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-docx
+Requires-Dist: python-pptx
+Requires-Dist: openpyxl
+Requires-Dist: pytesseract
+Requires-Dist: Pillow
+Requires-Dist: PyMuPDF
+Requires-Dist: surya-ocr
+Requires-Dist: ollama
+Dynamic: license-file
+
+# 📄 Document AI Runtime
+
+Un pipeline modulaire et extensible pour l'extraction de documents (OCR et Bureautique), conçu pour transformer des PDF, images et Word en formats structurés (Markdown et RAG).
+
+Inspiré des capacités de solutions comme ABBYY, ce runtime repose sur une architecture de plugins indépendants manipulant un modèle de données canonique (DOM). 
+
+## 🚀 Fonctionnalités
+
+* **Multi-Formats natifs et OCR :**
+  * **Bureautique (Path B)** : DOCX, XLSX (Excel), PPTX (PowerPoint) extraits nativement.
+  * **PDF Hybride** : Extrait le calque texte natif, et bascule automatiquement sur l'OCR (Surya + Tesseract) pour les pages scannées.
+  * **Images (Path A)** : JPG, PNG traités via IA (Surya Layout + Tesseract OCR).
+* **Moteur XY-Cut** : Algorithme récursif de coupe verticale/horizontale pour reconstruire l'ordre de lecture des documents multi-colonnes complexes.
+* **Exports spécialisés :** Markdown (structuré) et RAG (JSON chunké avec métadonnées).
+
+## 📦 Installation
+
+Installer la bibliothèque et ses dépendances :
+
+	```bash
+	pip install -e .
+
+## 🛠 Architecture
+
+Le projet est construit autour de 4 piliers :
+1. **Le DOM (Document Object Model) :** Des classes Python (`Document`, `Page`, `Region`, `Block`, `Table`, `Cell`) qui modélisent le document de bout en bout.
+2. **Les Interfaces :** `IDocumentLoader` et `IDocumentPlugin` garantissent que tous les modules (Surya, Tesseract, python-docx) communiquent avec le même langage.
+3. **Les Plugins :** Chaque étape (chargement, layout, OCR) est un module interchangeable dans `src/plugins/`. *Remplacer Surya par un autre moteur de layout n'impacte pas le reste du code.*
+4. **Le Pipeline Runner :** L'orchestrateur qui détecte le type de fichier et exécute le bon chemin (A ou B) automatiquement.
+
+## 📦 Installation
+
+### 1. Prérequis Python
+Clonez le dépôt et installez les dépendances Python :
+	```bash
+	pip install python-docx pytesseract Pillow PyMuPDF surya-ocr
+
+### 2. Dépendances Système
+	Tesseract OCR :
+		Windows : Téléchargez l'installeur sur UB-Mannheim et ajoutez-le au PATH.
+		Linux : sudo apt install tesseract-ocr
+	Surya OCR (Optionnel) : Nécessite llama.cpp pour fonctionner. Le runner peut fonctionner avec Tesseract seul si Surya n'est pas configuré.
+
+🏃 Utilisation
+
+	Le runtime s'utilise via le script test_runtime.py (ou votre propre script) qui appelle le PipelineRunner.
+
+	from src.core.pipeline.runner import PipelineRunner
+
+	runner = PipelineRunner()
+
+# Pour un PDF ou une Image -> Export Markdown
+
+	result_md = runner.process("mon_document.pdf", export_mode="markdown")
+	print(result_md)
+
+# Pour un Word -> Export RAG
+
+	result_rag = runner.process("mon_document.docx", export_mode="rag")
+	print(result_rag)
+
+🏃 Utilisation (CLI)
+
+	python main.py --file mon_document.pdf --export markdown
+
+🗂 Structure du dépôt
+
+	doc-ai-runtime/
+	├── src/
+	│   ├── core/               # Le cœur (DOM, Interfaces, Runner)
+	│   │   ├── dom/            # Modèles de données (Document, Page, Block...)
+	│   │   └── pipeline/       # Orchestrateur (runner.py)
+	│   ├── plugins/            # Les briques interchangeables
+	│   │   ├── loaders/        # ImageLoader, PdfLoader, DocxLoader
+	│   │   ├── layout/         # SuryaLayoutPlugin
+	│   │   └── ocr/           # TesseractOCRPlugin
+	│   └── exporters/         # MarkdownExporter, RagExporter
+	├── test_runtime.py         # Script de démonstration
+	└── README.md
+
+🗺 Feuille de route (Roadmap)
+
+	 Document Object Model (DOM)
+	 Loaders (DOCX, Images, PDF)
+	 Layout Analysis (Surya) & OCR (Tesseract)
+	 Exporters Markdown et RAG
+	 Image Quality Analyzer (pré-traitement des scans)
+	 Amélioration du moteur d'ordre de lecture (Reading Order Engine)

doc_ai_runtime-0.1.0/doc_ai_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+doc_ai_runtime.egg-info/PKG-INFO
+doc_ai_runtime.egg-info/SOURCES.txt
+doc_ai_runtime.egg-info/dependency_links.txt
+doc_ai_runtime.egg-info/requires.txt
+doc_ai_runtime.egg-info/top_level.txt
+src/core/config.py
+src/core/interfaces.py
+src/core/dom/models.py
+src/core/pipeline/runner.py
+src/exporters/markdown.py
+src/exporters/rag.py
+src/plugins/layout/surya_layout.py
+src/plugins/loaders/docx_loader.py
+src/plugins/loaders/image_loader.py
+src/plugins/loaders/pdf_loader.py
+src/plugins/loaders/pptx_loader.py
+src/plugins/loaders/xlsx_loader.py
+src/plugins/ocr/qwen_ocr.py
+src/plugins/ocr/tesseract_ocr.py
+src/plugins/reading_order/reading_order_engine.py

doc_ai_runtime-0.1.0/doc_ai_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doc_ai_runtime-0.1.0/doc_ai_runtime.egg-info/requires.txt

@@ -0,0 +1,8 @@
+python-docx
+python-pptx
+openpyxl
+pytesseract
+Pillow
+PyMuPDF
+surya-ocr
+ollama

doc_ai_runtime-0.1.0/doc_ai_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

doc_ai_runtime-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doc-ai-runtime"
+version = "0.1.0"
+description = "Modular Document AI Runtime for RAG and Markdown exports."
+authors = [{ name = "Alain Kalombo", email = "alain.kalombo@anztech.dev" }]
+readme = "README.md" # Indique à PyPI d'afficher ton README sur sa page web
+license = { text = "MIT" }
+dependencies = [
+    "python-docx",
+    "python-pptx",
+    "openpyxl",
+    "pytesseract",
+    "Pillow",
+    "PyMuPDF",
+    "surya-ocr", 
+    "ollama"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]

doc_ai_runtime-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doc_ai_runtime-0.1.0/src/core/dom/models.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+from enum import Enum
+
+class RegionType(Enum):
+    TITLE = "title"
+    TEXT = "text"
+    TABLE = "table"
+    IMAGE = "image"
+    LIST = "list"
+    CAPTION = "caption"
+    HEADER = "header"
+    FOOTER = "footer"
+
+class BlockType(Enum):
+    TEXT = "text"
+    TABLE_CELL = "table_cell"
+    IMAGE = "image"
+    EMPTY = "empty"
+
+@dataclass
+class BoundingBox:
+    """Représente les coordonnées spatiales d'un élément sur la page."""
+    x: float
+    y: float
+    width: float
+    height: float
+    confidence: float = 1.0
+
+@dataclass
+class Style:
+    """Définit le style typographique d'un bloc de texte."""
+    font_name: Optional[str] = None
+    font_size: Optional[float] = None
+    bold: bool = False
+    italic: bool = False
+    underline: bool = False
+    color: Optional[str] = None  # Format hexadécimal, ex: '#000000'
+
+@dataclass
+class Cell:
+    """Représente une cellule d'un tableau."""
+    bbox: BoundingBox
+    text: str = ""
+    row_span: int = 1
+    col_span: int = 1
+    is_header: bool = False
+    confidence: float = 1.0
+
+@dataclass
+class Table:
+    """Représente un tableau structuré."""
+    bbox: BoundingBox
+    rows: int = 0
+    cols: int = 0
+    cells: List[Cell] = field(default_factory=list)
+    reading_order: int = 0
+
+    def get_markdown(self) -> str:
+        """Méthode utilitaire pour un export Markdown rapide (utile plus tard)."""
+        if not self.cells:
+            return ""
+        # Logique de génération Markdown basique à implémenter
+        return "[Tableau Markdown]"
+
+@dataclass
+class Image:
+    """Représente une image détectée dans le document."""
+    bbox: BoundingBox
+    image_data: Optional[bytes] = None  # Stockage binaire ou base64
+    image_path: Optional[str] = None   # Chemin si sauvegardée sur disque
+    caption: Optional[str] = None
+    reading_order: int = 0
+
+@dataclass
+class Block:
+    """L'unité de base de contenu (texte, image, etc.)."""
+    bbox: BoundingBox
+    block_type: BlockType = BlockType.TEXT
+    text: str = ""
+    style: Style = field(default_factory=Style)
+    reading_order: int = 0  # Indispensable pour le RAG et le Markdown
+    confidence: float = 1.0
+    heading_level: Optional[int] = None  # <-- AJOUT : None si ce n'est pas un titre, 1 pour H1, 2 pour H2, etc.
+
+@dataclass
+class Region:
+    """Une zone logique de la page regroupant des blocs."""
+    bbox: BoundingBox
+    region_type: RegionType = RegionType.TEXT
+    blocks: List[Block] = field(default_factory=list)
+    tables: List[Table] = field(default_factory=list)
+    images: List[Image] = field(default_factory=list)
+    reading_order: int = 0
+
+@dataclass
+class Page:
+    """Représente une page physique du document."""
+    page_number: int
+    width: float
+    height: float
+    regions: List[Region] = field(default_factory=list)
+    image_path: Optional[str] = None
+    
+    def get_all_blocks_in_reading_order(self) -> List[Block]:
+        """Retourne tous les blocs de la page triés par ordre de lecture."""
+        blocks = []
+        for region in sorted(self.regions, key=lambda r: r.reading_order):
+            blocks.extend(sorted(region.blocks, key=lambda b: b.reading_order))
+        return blocks
+
+@dataclass
+class Document:
+    """Le modèle racine représentant le document complet."""
+    source_file: str
+    pages: List[Page] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict) # Auteur, date, titre, etc.
+    
+    def get_text(self) -> str:
+        """Extrait tout le texte du document dans l'ordre de lecture (base pour le RAG)."""
+        full_text = []
+        for page in self.pages:
+            for block in page.get_all_blocks_in_reading_order():
+                if block.text:
+                    full_text.append(block.text)
+        return "\n\n".join(full_text)

doc_ai_runtime-0.1.0/src/core/interfaces.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from src.core.dom.models import Document
+
+class IDocumentLoader(ABC):
+    """
+    Interface pour les plugins de chargement (Étape 1 du pipeline).
+    Prend un fichier brut en entrée et génère l'objet Document initial.
+    """
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Retourne le nom du chargeur (ex: 'PdfLoader', 'DocxLoader')."""
+        pass
+
+    @abstractmethod
+    def load(self, file_path: str) -> Document:
+        """
+        Charge un fichier et retourne un objet Document partiellement ou 
+        totalement rempli (selon si c'est une image ou un doc natif).
+        """
+        pass
+
+class IDocumentPlugin(ABC):
+    """
+    Interface de base pour toutes les autres étapes du pipeline 
+    (Layout, OCR, Reconstruction, Exporters).
+    """
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Retourne le nom du plugin (ex: 'SuryaLayoutAnalyzer')."""
+        pass
+
+    @abstractmethod
+    def run(self, document: Document) -> Document:
+        """
+        Reçoit l'objet Document, effectue un traitement (ajout de blocs, 
+        extraction de texte, etc.) et retourne l'objet Document mis à jour.
+        """
+        pass

doc_ai_runtime-0.1.0/src/core/pipeline/runner.py

@@ -0,0 +1,83 @@
+import os
+import platform
+
+if platform.system() == "Windows":
+    # Chemin pour ta machine Windows
+    os.environ["LLAMA_CPP_BINARY"] = r"c:\llama.cpp\llama-server.exe"
+else:
+    # Chemin pour ton serveur Ubuntu (Linux)
+    os.environ["LLAMA_CPP_BINARY"] = "/home/linuxbrew/.linuxbrew/bin/llama-server"
+    
+os.environ["SURYA_INFERENCE_BACKEND"] = "llamacpp"
+os.environ["SURYA_GUIDED_LAYOUT"] = "False"
+
+from src.plugins.loaders.image_loader import ImageLoader
+from src.plugins.loaders.docx_loader import DocxLoader
+from src.plugins.loaders.pdf_loader import PdfLoader
+from src.plugins.reading_order.reading_order_engine import ReadingOrderPlugin
+
+from src.plugins.loaders.xlsx_loader import XlsxLoader
+from src.plugins.loaders.pptx_loader import PptxLoader
+from src.plugins.ocr.qwen_ocr import QwenOCRPlugin
+
+from src.plugins.layout.surya_layout import SuryaLayoutPlugin
+from src.plugins.ocr.tesseract_ocr import TesseractOCRPlugin
+from src.exporters.markdown import MarkdownExporter
+from src.exporters.rag import RagExporter
+
+class PipelineRunner:
+    def __init__(self):
+        self.markdown_exporter = MarkdownExporter()
+        self.rag_exporter = RagExporter()
+
+    def process(self, file_path: str, export_mode: str = "markdown") -> str:
+        _, ext = os.path.splitext(file_path)
+        ext = ext.lower()
+        document = None
+        
+        # --- PATH B : PDF (Hybride Natif + OCR) ---
+        if ext == ".pdf":
+            print("-> Fichier PDF détecté. Analyse (Hybride)...")
+            loader = PdfLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".docx":
+            print("-> Fichier DOCX détecté. Extraction native.")
+            loader = DocxLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".xlsx":
+            print("-> Fichier XLSX détecté. Extraction native (Tableaux).")
+            loader = XlsxLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".pptx":
+            print("-> Fichier PPTX détecté. Extraction native (Slides).")
+            loader = PptxLoader()
+            document = loader.load(file_path)
+            
+        # --- PATH A : Images pures (OCR) ---
+        elif ext in [".jpg", ".jpeg", ".png", ".tiff", ".bmp"]:
+            print("-> Fichier Image détecté. Utilisation OCR.")
+            loader = ImageLoader()
+            document = loader.load(file_path)
+            
+            print("   ... Calcul de l'ordre de lecture")
+            reading_order_plugin = ReadingOrderPlugin()
+            document = reading_order_plugin.run(document)
+            
+            # 4. OCR (Qwen2.5-VL lit dans les boîtes de Surya)
+            print("   ... Extraction du texte (Qwen2.5-VL via Ollama)")
+            # ocr_plugin = TesseractOCRPlugin()  <-- On commente Tesseract
+            ocr_plugin = QwenOCRPlugin() 
+            document = ocr_plugin.run(document)
+            
+        else:
+            raise ValueError(f"Format non supporté : {ext}")
+
+        print(f"-> Export demandé : {export_mode}")
+        if export_mode == "rag":
+            return self.rag_exporter.export(document, mode="semantic_chunks")
+        else:
+            return self.markdown_exporter.export(document)
+