Initial commit

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soumyak
+
+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.

README.md

@@ -1,15 +1,41 @@
+# VisionMark
+
+VisionMark is a local-first document conversion pipeline that transforms various file formats into clean, structured Markdown optimized for Large Language Model (LLM) context windows.
+
+While other tools rely on cloud APIs and external services, VisionMark is built to run entirely on your local machine. It uses a hybrid approach: rule-based parsing for standard text formats and native, local execution of the Qwen2.5-VL vision model for complex, scanned, or visually-heavy documents. This ensures your data remains private and you incur zero API costs.
+
 ---
-title: VisionMark
-emoji: 📊
-colorFrom: green
-colorTo: red
-sdk: gradio
-sdk_version: 6.22.0
-python_version: '3.12'
-app_file: app.py
-pinned: false
-license: mit
-short_description: Convert Anything to Markdown file. (.md for life)
+
+## Core Features
+
+- **Fully Local Execution:** Runs Qwen2.5-VL directly via Hugging Face Transformers. No third-party API keys or cloud services required.
+- **Format Agnostic:** Native support for PDFs, Office documents (DOCX, PPTX, XLSX), images, code files, and Jupyter Notebooks.
+- **Hybrid Pipeline:** Automatically routes text-heavy documents through fast rule-based parsers and uses the vision model for complex layouts or images.
+- **Smart PDF Batching:** Dynamically adjusts batch sizes when processing large PDFs to manage VRAM and token limits efficiently.
+- **Granular Control:** Offers CLI and UI options to control generation temperature, token limits, and concurrent processing threads.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Supported Formats
+   Category   | Formats                          |
+ |------------|----------------------------------|
+ | Documents  | PDF, DOCX, PPTX, XLSX            |
+ | Images     | PNG, JPG, JPEG, BMP              |
+ | Code       | Python, R, JavaScript, C++, etc.|
+ | Notebooks  | Jupyter Notebooks (.ipynb)      |
+ | Markdown   | MD, RMD                          |
+ | Text       | TXT                              |
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/mkdir-smyk/VisionMark.git
+cd VisionMark
+
+python -m venv venv
+source venv/bin/activate
+
+pip install -r requirements.txt

app.py

@@ -0,0 +1,6 @@
+from ui.gradio_app import create_ui
+
+demo = create_ui()
+
+if __name__ == "__main__":
+    demo.launch()

main.py

@@ -0,0 +1,140 @@
+import os
+import argparse
+from pathlib import Path
+from processors.base import BaseDocumentProcessor, DocumentType
+from processors.vision.vision_processor import VisionDocumentProcessor
+
+def process_file(file_path, output_dir, force_vision=False, max_concurrent=2, images_per_batch=1, 
+               temperature=0.0, max_tokens=None, dynamic_batching=True, max_tokens_per_batch=4000,
+               api_key=None, base_url=None, model=None):
+    """Process a single file"""
+    try:
+        print(f"Processing: {file_path}")
+        
+        # Determine document type first
+        doc_type = DocumentType.from_file_extension(file_path)
+        
+        # Select appropriate processor based on type and options
+        if force_vision and doc_type == DocumentType.PDF:
+            print(f"Using Vision processor for PDF: {file_path}")
+            processor = VisionDocumentProcessor(
+                api_key=api_key,
+                base_url=base_url,
+                model=model,
+                temperature=temperature, 
+                max_tokens=max_tokens
+            )
+        elif doc_type == DocumentType.IMAGE:
+            print(f"Using Vision processor for image: {file_path}")
+            processor = VisionDocumentProcessor(
+                api_key=api_key,
+                base_url=base_url,
+                model=model,
+                temperature=temperature, 
+                max_tokens=max_tokens
+            )
+        else:
+            # Use standard document detection
+            processor = BaseDocumentProcessor.get_processor(file_path)
+            
+        print(f"Using {processor.__class__.__name__} for {file_path}")
+        
+        # Process document - with max_concurrent and images_per_batch for PDFs
+        if isinstance(processor, VisionDocumentProcessor) and doc_type == DocumentType.PDF:
+            document = processor.process(
+                file_path, 
+                max_concurrent=max_concurrent, 
+                images_per_batch=images_per_batch,
+                dynamic_batching=dynamic_batching,
+                max_tokens_per_batch=max_tokens_per_batch
+            )
+            print(f"Processed PDF with {max_concurrent} concurrent workers, dynamic batching: {dynamic_batching}")
+        else:
+            document = processor.process(file_path)
+        
+        # Generate output filename
+        base_name = Path(file_path).stem
+        output_base = os.path.join(output_dir, base_name)
+        
+        md_path = f"{output_base}.md"
+        with open(md_path, "w", encoding="utf-8") as f:
+            f.write(document.to_markdown())
+        print(f"Markdown saved to: {md_path}")
+            
+    except Exception as e:
+        print(f"Error processing {file_path}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+def process_directory(input_dir, output_dir, force_vision=False, max_concurrent=2, images_per_batch=1,
+                    temperature=0.0, max_tokens=None, dynamic_batching=True, max_tokens_per_batch=4000,
+                    api_key=None, base_url=None, model=None):
+    """Process all files in directory"""
+    for root, _, files in os.walk(input_dir):
+        for file in files:
+            file_path = os.path.join(root, file)
+            process_file(file_path, output_dir, force_vision, max_concurrent, images_per_batch,
+                        temperature, max_tokens, dynamic_batching, max_tokens_per_batch,
+                        api_key, base_url, model)
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert documents to structured markdown")
+    
+    parser.add_argument("input", nargs="?", help="Input file or directory path")
+    parser.add_argument("--output", "-o", help="Output directory path", default="output")
+    parser.add_argument("--ui", action="store_true", help="Launch graphical user interface")
+    parser.add_argument("--force-vision", action="store_true", 
+                       help="Force using vision model for PDFs instead of text extraction")
+    parser.add_argument("--max-concurrent", type=int, default=2,
+                       help="Maximum number of concurrent workers for PDF page processing (default: 2)")
+    parser.add_argument("--api-key", help="API key for Qwen vision processor")
+    parser.add_argument("--base-url", help="Base URL for API")
+    parser.add_argument("--model", help="Model name to use")
+    parser.add_argument("--images-per-batch", type=int, default=1,
+                       help="Maximum number of PDF pages to process in a single API call (default: 1, 2+ enables multi-image processing)")
+    parser.add_argument("--temperature", type=float, default=0.0,
+                       help="Temperature for vision model generation (0.0-1.0, lower is more deterministic)")
+    parser.add_argument("--max-tokens", type=int, 
+                       help="Maximum tokens for vision model generation (default uses model's limit)")
+    parser.add_argument("--dynamic-batching", action="store_true", default=True,
+                       help="Automatically determine optimal batch size based on image complexity. The optimal batch size will not exceed the number set by --images-per-batch.")
+    parser.add_argument("--no-dynamic-batching", action="store_false", dest="dynamic_batching",
+                       help="Disable dynamic batching and use fixed images-per-batch")
+    parser.add_argument("--max-tokens-per-batch", type=int, default=4000,
+                       help="Maximum tokens per batch when using dynamic batching (default: 4000)")
+    
+    args = parser.parse_args()
+    
+    # Launch UI if requested
+    if args.ui:
+        from ui.app import create_ui
+        app = create_ui()
+        # Allow access to any path
+        app.launch(allowed_paths=["/"])
+        return
+    
+    # If no input is provided and not in UI mode, print help
+    if not args.input:
+        parser.print_help()
+        return
+    
+    # Ensure output directory exists
+    os.makedirs(args.output, exist_ok=True)
+    
+    if os.path.isdir(args.input):
+        # Process directory
+        process_directory(
+            args.input, args.output, args.force_vision, args.max_concurrent, args.images_per_batch,
+            args.temperature, args.max_tokens, args.dynamic_batching, args.max_tokens_per_batch,
+            args.api_key, args.base_url, args.model
+        )
+    else:
+        # Process single file
+        process_file(
+            args.input, args.output, args.force_vision, args.max_concurrent, args.images_per_batch,
+            args.temperature, args.max_tokens, args.dynamic_batching, args.max_tokens_per_batch,
+            args.api_key, args.base_url, args.model
+        )
+
+if __name__ == "__main__":
+    main()

processors/__init__.py

@@ -0,0 +1,19 @@
+"""
+VisionMark document processors package.
+"""
+
+from processors.base import (
+    BaseDocumentProcessor,
+    DocumentType,
+    DocumentElement,
+    DocumentSection,
+    StructuredDocument
+)
+
+__all__ = [
+    'BaseDocumentProcessor',
+    'DocumentType',
+    'DocumentElement',
+    'DocumentSection',
+    'StructuredDocument'
+]

processors/base.py

@@ -0,0 +1,291 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union, Any
+from enum import Enum
+from pathlib import Path
+import os
+import json
+
+class DocumentType(Enum):
+    """Supported document types"""
+    PDF = "pdf"
+    IMAGE = "image"  # jpg, png, etc.
+    WORD = "docx"
+    POWERPOINT = "pptx"
+    JUPYTER = "ipynb"
+    PYTHON = "py"
+    R_SCRIPT = "r"
+    R_MARKDOWN = "rmd"
+    MARKDOWN = "md"
+    TEXT = "txt"
+    EXCEL = "excel"  # xlsx, xls files
+    UNKNOWN = "unknown"
+    
+    @classmethod
+    def from_file_extension(cls, file_path: str) -> "DocumentType":
+        """Determine document type from file extension"""
+        ext = os.path.splitext(file_path.lower())[1][1:]
+        
+        if ext in ("jpg", "jpeg", "png", "bmp", "tiff"):
+            return cls.IMAGE
+        elif ext == "pdf":
+            return cls.PDF
+        elif ext == "docx":
+            return cls.WORD
+        elif ext == "pptx":
+            return cls.POWERPOINT
+        elif ext == "ipynb":
+            return cls.JUPYTER
+        elif ext == "py":
+            return cls.PYTHON
+        elif ext == "r":
+            return cls.R_SCRIPT
+        elif ext == "rmd":
+            return cls.R_MARKDOWN
+        elif ext == "md":
+            return cls.MARKDOWN
+        elif ext == "txt":
+            return cls.TEXT
+        elif ext in ("xlsx", "xls", "xlsm"):
+            return cls.EXCEL
+        else:
+            return cls.UNKNOWN
+
+class DocumentElement:
+    """Base class for document elements"""
+    def __init__(
+        self, 
+        content: str, 
+        element_type: str,
+        position: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        self.content = content
+        self.element_type = element_type
+        self.position = position or {}
+        self.metadata = metadata or {}
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        return {
+            "content": self.content,
+            "type": self.element_type,
+            "position": self.position,
+            "metadata": self.metadata
+        }
+        
+    def to_markdown(self) -> str:
+        """Convert to markdown representation"""
+        if self.element_type == "heading":
+            level = self.metadata.get("level", 1)
+            return f"{'#' * level} {self.content}\n\n"
+        elif self.element_type == "paragraph":
+            return f"{self.content}\n\n"
+        elif self.element_type == "code":
+            lang = self.metadata.get("language", "")
+            return f"```{lang}\n{self.content}\n```\n\n"
+        elif self.element_type == "list_item":
+            return f"- {self.content}\n"
+        elif self.element_type == "image":
+            alt = self.metadata.get("alt", "Image")
+            src = self.metadata.get("src", "")
+            return f"![{alt}]({src})\n\n"
+        elif self.element_type == "table":
+            # Basic table rendering - in real implementation this would be more complex
+            return f"**Table**: {self.content}\n\n"
+        else:
+            return f"{self.content}\n\n"
+
+class DocumentSection:
+    """Section of a document containing multiple elements"""
+    def __init__(
+        self,
+        title: Optional[str] = None,
+        elements: Optional[List[DocumentElement]] = None,
+        level: int = 1,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        self.title = title
+        self.elements = elements or []
+        self.level = level
+        self.metadata = metadata or {}
+        
+    def add_element(self, element: DocumentElement) -> None:
+        """Add an element to the section"""
+        self.elements.append(element)
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        return {
+            "title": self.title,
+            "level": self.level,
+            "elements": [element.to_dict() for element in self.elements],
+            "metadata": self.metadata
+        }
+        
+    def to_markdown(self) -> str:
+        """Convert to markdown representation"""
+        result = ""
+        if self.title:
+            result += f"{'#' * self.level} {self.title}\n\n"
+            
+        for element in self.elements:
+            result += element.to_markdown()
+            
+        return result
+
+class StructuredDocument:
+    """Complete structured document"""
+    def __init__(
+        self,
+        title: Optional[str] = None,
+        source_file: Optional[str] = None,
+        doc_type: Optional[DocumentType] = None,
+        sections: Optional[List[DocumentSection]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        self.title = title
+        self.source_file = source_file
+        self.doc_type = doc_type or DocumentType.UNKNOWN
+        self.sections = sections or []
+        self.metadata = metadata or {}
+        
+    def add_section(self, section: DocumentSection) -> None:
+        """Add a section to the document"""
+        self.sections.append(section)
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        return {
+            "title": self.title,
+            "source_file": self.source_file,
+            "doc_type": self.doc_type.value if self.doc_type else None,
+            "sections": [section.to_dict() for section in self.sections],
+            "metadata": self.metadata
+        }
+        
+    def to_markdown(self) -> str:
+        """Convert document to markdown format"""
+        # If we have direct markdown in metadata, use that
+        if "markdown" in self.metadata:
+            return self.metadata["markdown"]
+        
+        # Otherwise, build markdown from structure
+        parts = []
+        
+        # Add document title
+        if self.title:
+            parts.append(f"# {self.title}\n\n")
+        
+        # Add each section
+        for section in self.sections:
+            # Add section title with appropriate heading level
+            if section.title:
+                level = section.level if section.level else 1
+                heading = "#" * (level + 1)  # +1 because document title is h1
+                parts.append(f"{heading} {section.title}\n\n")
+            
+            # Add elements
+            for element in section.elements:
+                if element.element_type == "markdown":
+                    # For markdown elements, just add the content directly
+                    parts.append(f"{element.content}\n\n")
+                else:
+                    # For other elements, convert to markdown
+                    if element.element_type == "paragraph":
+                        parts.append(f"{element.content}\n\n")
+                    elif element.element_type == "heading":
+                        level = element.metadata.get("level", 2)
+                        heading = "#" * (level + 1)  # +1 because doc title is h1
+                        parts.append(f"{heading} {element.content}\n\n")
+                    elif element.element_type == "list":
+                        for item in element.content.split("\n"):
+                            parts.append(f"- {item.strip()}\n")
+                        parts.append("\n")
+                    elif element.element_type == "code":
+                        lang = element.metadata.get("language", "")
+                        parts.append(f"```{lang}\n{element.content}\n```\n\n")
+                    else:
+                        # Default behavior for unknown element types
+                        parts.append(f"{element.content}\n\n")
+        
+        return "".join(parts)
+        
+    def save_markdown(self, output_path: str) -> None:
+        """Save as markdown file"""
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(self.to_markdown())
+            
+    def get_direct_markdown(self) -> str:
+        """
+        Get direct markdown if available, otherwise generate from structure
+        
+        Returns:
+            str: Markdown representation of the document
+        """
+        if "direct_markdown" in self.metadata:
+            return self.metadata["direct_markdown"]
+        else:
+            return self.to_markdown()
+
+class BaseDocumentProcessor(ABC):
+    """Abstract base class for document processors"""
+    
+    def __init__(self):
+        """Initialize the document processor"""
+        pass
+        
+    @abstractmethod
+    def process(self, file_path: str) -> StructuredDocument:
+        """
+        Process a document and return structured content
+        
+        Args:
+            file_path: Path to the document file
+            
+        Returns:
+            StructuredDocument: The processed document
+        """
+        pass
+
+    @classmethod
+    def get_processor(cls, file_path: str, force_vision: bool = False) -> "BaseDocumentProcessor":
+        """Factory method to get appropriate processor for a file"""
+        doc_type = DocumentType.from_file_extension(file_path)
+        
+        # Import here to avoid circular imports
+        from processors.text.pdf_processor import PDFProcessor
+        from processors.vision.vision_processor import VisionDocumentProcessor
+        from processors.text.docx_processor import DocxProcessor
+        from processors.text.pptx_processor import PowerPointProcessor
+        from processors.text.ipynb_processor import JupyterNotebookProcessor
+        from processors.text.code_processor import CodeFileProcessor
+        from processors.text.markdown_processor import MarkdownProcessor
+        from processors.text.text_processor import TextProcessor
+        from processors.text.excel_processor import ExcelProcessor
+        
+        # Use vision processor if forced (applies to PDF)
+        if force_vision:
+            return VisionDocumentProcessor()
+        
+        # Return appropriate processor based on document type
+        if doc_type == DocumentType.PDF:
+            return PDFProcessor()
+        elif doc_type == DocumentType.WORD:
+            return DocxProcessor()
+        elif doc_type == DocumentType.POWERPOINT:
+            return PowerPointProcessor() 
+        elif doc_type == DocumentType.JUPYTER:
+            return JupyterNotebookProcessor()
+        elif doc_type == DocumentType.IMAGE:
+            return VisionDocumentProcessor()
+        elif doc_type in (DocumentType.PYTHON, DocumentType.R_SCRIPT):
+            return CodeFileProcessor()
+        elif doc_type in (DocumentType.MARKDOWN, DocumentType.R_MARKDOWN):
+            return MarkdownProcessor()
+        elif doc_type == DocumentType.EXCEL:
+            return ExcelProcessor()
+        elif doc_type == DocumentType.TEXT:
+            return TextProcessor()
+        else:
+            # Default to text processor for unknown types
+            return TextProcessor()

processors/text/__init__.py

@@ -0,0 +1,19 @@
+from processors.text.pdf_processor import PDFProcessor
+from processors.text.docx_processor import DocxProcessor
+from processors.text.pptx_processor import PowerPointProcessor
+from processors.text.ipynb_processor import JupyterNotebookProcessor
+from processors.text.code_processor import CodeFileProcessor
+from processors.text.markdown_processor import MarkdownProcessor
+from processors.text.text_processor import TextProcessor
+from processors.text.excel_processor import ExcelProcessor
+
+__all__ = [
+    'PDFProcessor',
+    'DocxProcessor',
+    'PowerPointProcessor',
+    'JupyterNotebookProcessor',
+    'CodeFileProcessor',
+    'MarkdownProcessor',
+    'TextProcessor',
+    'ExcelProcessor',
+]

processors/text/code_processor.py

@@ -0,0 +1,66 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+
+class CodeFileProcessor(BaseDocumentProcessor):
+    """Processor for code files (Python, R, etc.)"""
+    
+    # Language mapping for syntax highlighting
+    LANGUAGE_MAP = {
+        "py": "python",
+        "r": "r",
+        "js": "javascript",
+        "ts": "typescript",
+        "sh": "bash",
+        "cpp": "cpp",
+        "c": "c",
+        "java": "java",
+        "go": "go",
+        "rb": "ruby",
+        "php": "php",
+    }
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process code file"""
+        file_ext = Path(file_path).suffix.lower()[1:]
+        doc_type = DocumentType.from_file_extension(file_path)
+        
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=doc_type
+        )
+        
+        try:
+            # Read code file
+            with open(file_path, 'r', encoding='utf-8') as f:
+                code_content = f.read()
+            
+            # Get language for syntax highlighting
+            language = self.LANGUAGE_MAP.get(file_ext, file_ext)
+            
+            # Create markdown representation
+            markdown = f"# {Path(file_path).name}\n\n"
+            markdown += f"```{language}\n{code_content}\n```\n"
+            
+            # Create document structure
+            main_section = DocumentSection(title=Path(file_path).name)
+            main_section.add_element(DocumentElement(
+                content=code_content,
+                element_type="code",
+                metadata={"language": language}
+            ))
+            document.add_section(main_section)
+            
+            # Store markdown
+            document.metadata["markdown"] = markdown
+            
+        except Exception as e:
+            print(f"Error processing code file: {e}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process code file: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document

processors/text/docx_processor.py

@@ -0,0 +1,470 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+import mammoth
+import re
+import docx
+from docx2python import docx2python
+import pandas as pd
+from io import StringIO
+
+class DocxProcessor(BaseDocumentProcessor):
+    """Processor for DOCX documents with enhanced table support"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process DOCX document with improved table handling"""
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.WORD
+        )
+        
+        try:
+            # First approach: Try to extract tables using python-docx directly
+            doc = docx.Document(file_path)
+            has_tables = len(doc.tables) > 0
+            
+            # Convert DOCX to Markdown using mammoth for general content
+            with open(file_path, "rb") as docx_file:
+                result = mammoth.convert_to_markdown(docx_file)
+            markdown_content = result.value
+            
+            # If document has tables, use our direct table extraction
+            if (has_tables):
+                markdown_content = self._handle_tables_directly(doc, markdown_content)
+            else:
+                # As a fallback, try docx2python for table extraction
+                try:
+                    doc_data = docx2python(file_path)
+                    if hasattr(doc_data, 'tables') and doc_data.tables:
+                        markdown_content = self._process_tables(file_path, markdown_content, doc_data.tables)
+                except Exception as table_error:
+                    print(f"Warning: Unable to process tables with docx2python: {table_error}")
+            
+            # Create a single section with the markdown content
+            section = DocumentSection(title="Document Content")
+            section.add_element(DocumentElement(
+                content=markdown_content,
+                element_type="markdown"
+            ))
+            document.add_section(section)
+            
+            # Store raw markdown in metadata
+            document.metadata["markdown"] = markdown_content
+            
+            # Extract any messages/warnings
+            if result.messages:
+                document.metadata["conversion_messages"] = [msg.message for msg in result.messages]
+                
+        except Exception as e:
+            print(f"Error extracting content from DOCX: {e}")
+            # Create error section
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process document: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document
+        
+    def _handle_tables_directly(self, doc, content):
+        """
+        Extract tables directly from python-docx and insert them as proper markdown tables
+        
+        Args:
+            doc: python-docx Document object
+            content: Markdown content from mammoth
+            
+        Returns:
+            str: Markdown content with properly formatted tables
+        """
+        if not doc.tables:
+            return content
+            
+        # Split content into paragraphs
+        paragraphs = content.split('\n\n')
+        result_paragraphs = []
+        table_markers = []
+        
+        # Find potential table markers
+        for i, para in enumerate(paragraphs):
+            if 'table' in para.lower():
+                table_markers.append(i)
+                
+        # If no explicit markers, look for potential places by identifying short consecutive lines
+        if not table_markers:
+            for i in range(len(paragraphs) - 1):
+                lines = paragraphs[i].split('\n')
+                # Look for potential table headers (short lines)
+                if all(len(line) < 30 for line in lines) and len(lines) > 1:
+                    table_markers.append(i)
+        
+        # Process each paragraph, inserting tables at appropriate places
+        i = 0
+        tables_inserted = 0
+        
+        while i < len(paragraphs):
+            if i in table_markers and tables_inserted < len(doc.tables):
+                # Add the current paragraph (table caption or header)
+                result_paragraphs.append(paragraphs[i])
+                
+                # Convert the table to markdown and add it
+                table_md = self._table_to_markdown(doc.tables[tables_inserted])
+                result_paragraphs.append(table_md)
+                
+                # Skip any paragraphs that might be part of the table in the original content
+                next_text = False
+                j = i + 1
+                while j < len(paragraphs) and not next_text:
+                    # Check if paragraph j looks like normal text
+                    if len(paragraphs[j].split('\n')) <= 1 and len(paragraphs[j]) > 30:
+                        next_text = True
+                    j += 1
+                
+                if next_text:
+                    i = j - 1  # Go back to the text paragraph
+                else:
+                    i = j
+                
+                tables_inserted += 1
+            else:
+                # Regular paragraph, just add it
+                result_paragraphs.append(paragraphs[i])
+                i += 1
+        
+        # If we still have tables left, add them at the end
+        for j in range(tables_inserted, len(doc.tables)):
+            table_md = self._table_to_markdown(doc.tables[j])
+            result_paragraphs.append("Additional table found:")
+            result_paragraphs.append(table_md)
+            
+        return '\n\n'.join(result_paragraphs)
+        
+    def _table_to_markdown(self, table):
+        """
+        Convert python-docx table to markdown table format
+        
+        Args:
+            table: python-docx Table object
+            
+        Returns:
+            str: Markdown table
+        """
+        if not table.rows:
+            return ""
+            
+        markdown_rows = []
+        
+        # Get cell text for each row (preserve empty cells)
+        all_rows = []
+        for row in table.rows:
+            row_cells = []
+            for cell in row.cells:
+                # Remove newlines and extra spaces from cell text
+                cell_text = cell.text.strip().replace('\n', ' ')
+                cell_text = re.sub(r'\s+', ' ', cell_text)
+                row_cells.append(cell_text if cell_text else " ")
+            all_rows.append(row_cells)
+            
+        # Determine the number of columns based on the row with the most cells
+        num_cols = max(len(row) for row in all_rows)
+        
+        # Ensure all rows have the same number of columns
+        for row in all_rows:
+            while len(row) < num_cols:
+                row.append(" ")
+        
+        # Generate header row
+        header_row = "| " + " | ".join(all_rows[0]) + " |"
+        markdown_rows.append(header_row)
+        
+        # Generate separator row
+        separator_row = "| " + " | ".join(["---"] * num_cols) + " |"
+        markdown_rows.append(separator_row)
+        
+        # Generate data rows
+        for row in all_rows[1:]:
+            data_row = "| " + " | ".join(row) + " |"
+            markdown_rows.append(data_row)
+            
+        return "\n".join(markdown_rows)
+    
+    def _process_tables(self, file_path: str, content: str, tables_data) -> str:
+        """
+        Process tables extracted by docx2python and replace mammoth's table output
+        with better markdown tables
+        
+        Args:
+            file_path: Path to the DOCX file
+            content: Markdown content from mammoth
+            tables_data: Tables extracted by docx2python
+            
+        Returns:
+            str: Markdown content with improved tables
+        """
+        if not tables_data:
+            # Direct table detection in the content if docx2python didn't find tables
+            return self._detect_and_format_tables_from_content(content, file_path)
+        
+        try:
+            # Try to use python-docx to get additional table information
+            doc = docx.Document(file_path)
+            
+            # Find table markers in mammoth output
+            table_pattern = r'\|[^\n]+\|\n\|[^\n]+\|'
+            table_matches = list(re.finditer(table_pattern, content))
+            
+            # If no tables found with the standard pattern, try a broader pattern
+            if not table_matches:
+                # This broader pattern looks for possible table content by finding consecutive lines 
+                # with keyword patterns that might indicate a flattened table
+                broader_pattern = r'(?:[\w\s]+\n){2,}(?:[\w\s]+)'
+                table_matches = list(re.finditer(broader_pattern, content))
+            
+            # If we still don't find tables with regex patterns, use doc.tables directly
+            if (not table_matches or not doc.tables) and doc.tables:
+                return self._reconstruct_tables_from_python_docx(content, doc.tables)
+                
+            # Start with the original content
+            result = content
+            
+            # If tables found in docx but not in mammoth output, reconstruct them completely
+            if doc.tables and not table_matches:
+                return self._reconstruct_tables_from_python_docx(content, doc.tables)
+                
+            # Standard processing when we have matching tables
+            offset = 0
+            
+            # Process each table
+            for i, table_data in enumerate(tables_data):
+                if i >= len(doc.tables):
+                    break
+                    
+                # Get table from python-docx
+                table = doc.tables[i]
+                
+                # Find the table in the content
+                if i < len(table_matches):
+                    table_match = table_matches[i]
+                    start_pos = table_match.start() + offset
+                    end_pos = table_match.end() + offset
+                else:
+                    # If we don't have an exact match, place the table at the end
+                    start_pos = len(result)
+                    end_pos = start_pos
+                
+                # Convert table to pandas DataFrame
+                df = self._table_to_dataframe(table_data)
+                
+                # Convert DataFrame to markdown table
+                markdown_table = self._df_to_markdown(df)
+                
+                # Replace table in content
+                result = result[:start_pos] + markdown_table + result[end_pos:]
+                
+                # Update offset for next replacement
+                offset += len(markdown_table) - (end_pos - start_pos)
+            
+            return result
+        
+        except Exception as e:
+            print(f"Error processing tables: {e}")
+            # Fallback to direct content processing
+            return self._detect_and_format_tables_from_content(content, file_path)
+    
+    def _detect_and_format_tables_from_content(self, content: str, file_path: str) -> str:
+        """
+        Detect and format tables directly from the content when docx2python fails
+        
+        Args:
+            content: Markdown content
+            file_path: Path to the DOCX file
+            
+        Returns:
+            str: Content with improved tables
+        """
+        try:
+            # Try to open with python-docx directly
+            doc = docx.Document(file_path)
+            if not doc.tables:
+                return content
+                
+            return self._reconstruct_tables_from_python_docx(content, doc.tables)
+        except:
+            # Another fallback approach - try to detect tables based on text patterns
+            # Look for lines that might be table headers (consecutive short lines followed by a series of values)
+            lines = content.split('\n')
+            result = []
+            i = 0
+            while i < len(lines):
+                line = lines[i]
+                # Check if this line might be the start of a table (contains "table" keyword)
+                if "table" in line.lower() and i + 2 < len(lines):
+                    potential_headers = []
+                    j = i + 1
+                    # Collect potential header lines (short lines with no punctuation)
+                    while j < len(lines) and len(lines[j].strip()) < 30 and not re.search(r'[.,:;]', lines[j]) and lines[j].strip():
+                        potential_headers.append(lines[j].strip())
+                        j += 1
+                    
+                    # If we found potential headers, format as a table
+                    if len(potential_headers) >= 2:
+                        result.append(line)  # Add the table description line
+                        result.append("")    # Empty line before table
+                        
+                        # Create markdown table headers
+                        result.append("| " + " | ".join(potential_headers) + " |")
+                        result.append("| " + " | ".join(["---"] * len(potential_headers)) + " |")
+                        
+                        # Try to detect table rows
+                        k = j
+                        row_data = []
+                        while k < len(lines) and len(row_data) < 20:  # Limit to 20 rows to avoid false positives
+                            if not lines[k].strip():
+                                k += 1
+                                continue
+                            
+                            if len(lines[k].strip()) < 30:
+                                row_data.append(lines[k].strip())
+                            else:
+                                break  # Stop if we hit a long line (paragraph)
+                            k += 1
+                        
+                        # Create rows based on headers (split data into rows)
+                        rows = []
+                        row = []
+                        for item in row_data:
+                            row.append(item)
+                            if len(row) == len(potential_headers):
+                                rows.append("| " + " | ".join(row) + " |")
+                                row = []
+                        
+                        # If we have a partial row at the end, add it with empty cells
+                        if row:
+                            while len(row) < len(potential_headers):
+                                row.append("")
+                            rows.append("| " + " | ".join(row) + " |")
+                        
+                        # Add all rows to result
+                        result.extend(rows)
+                        result.append("")  # Empty line after table
+                        
+                        i = k  # Skip processed lines
+                    else:
+                        result.append(line)
+                        i += 1
+                else:
+                    result.append(line)
+                    i += 1
+            
+            return "\n".join(result)
+    
+    def _reconstruct_tables_from_python_docx(self, content: str, tables) -> str:
+        """
+        Completely reconstruct tables using python-docx
+        
+        Args:
+            content: Original markdown content
+            tables: Tables from python-docx
+            
+        Returns:
+            str: Content with properly formatted tables
+        """
+        # First, find places in the content where tables might go
+        # Look for lines mentioning "table" for table captions/descriptions
+        table_markers = []
+        lines = content.split('\n')
+        
+        for i, line in enumerate(lines):
+            if re.search(r'table|Table', line):
+                table_markers.append(i)
+        
+        # If we found markers for all tables, use them to insert tables
+        if table_markers and len(table_markers) >= len(tables):
+            for i, table in enumerate(tables):
+                if i >= len(table_markers):
+                    break
+                    
+                marker_pos = table_markers[i]
+                
+                # Create markdown table from this table
+                markdown_table = self._convert_python_docx_table(table)
+                
+                # Insert after the marker line
+                lines.insert(marker_pos + 1, "")
+                lines.insert(marker_pos + 2, markdown_table)
+                lines.insert(marker_pos + 3, "")
+                
+                # Update remaining marker positions
+                for j in range(i + 1, len(table_markers)):
+                    table_markers[j] += 3
+            
+            return "\n".join(lines)
+        else:
+            # If we can't find markers for all tables, append tables at the end
+            result = content
+            
+            for table in tables:
+                markdown_table = self._convert_python_docx_table(table)
+                result += "\n\n" + markdown_table + "\n"
+                
+            return result
+    
+    def _convert_python_docx_table(self, table) -> str:
+        """
+        Convert a python-docx table to markdown
+        
+        Args:
+            table: python-docx table object
+            
+        Returns:
+            str: Markdown table
+        """
+        # Extract the table data
+        table_data = []
+        
+        for row in table.rows:
+            row_data = []
+            for cell in row.cells:
+                # Get text and clean it
+                text = cell.text.strip().replace('\n', ' ')
+                row_data.append(text)
+            table_data.append(row_data)
+            
+        # If no data, return empty string
+        if not table_data:
+            return ""
+            
+        # Get the max columns
+        max_cols = max(len(row) for row in table_data)
+        
+        # Ensure all rows have the same number of columns
+        for row in table_data:
+            while len(row) < max_cols:
+                row.append("")
+        
+        # Create header row
+        header = "| " + " | ".join(table_data[0]) + " |"
+        
+        # Create separator row
+        separator = "| " + " | ".join(["---"] * max_cols) + " |"
+        
+        # Create data rows
+        rows = []
+        for row in table_data[1:]:
+            rows.append("| " + " | ".join(row) + " |")
+            
+        # Combine all parts
+        return header + "\n" + separator + "\n" + "\n".join(rows)
+    
+    def _df_to_markdown(self, df: pd.DataFrame) -> str:
+        """Convert pandas DataFrame to markdown table"""
+        if df.empty:
+            return ''
+            
+        # Use pandas built-in to_markdown when possible
+        try:
+            return df.to_markdown(index=False)
+        except Exception as e:
+            # Fallback to manual conversion
+            return self._complex_df_to_markdown(df)

processors/text/excel_processor.py

@@ -0,0 +1,138 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+import pandas as pd
+import os
+
+class ExcelProcessor(BaseDocumentProcessor):
+    """Processor for Excel files (xlsx, xls, xlsm)"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """
+        Process Excel file and convert to markdown
+        
+        Args:
+            file_path: Path to Excel file
+            
+        Returns:
+            StructuredDocument: The processed document
+        """
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.EXCEL
+        )
+        
+        try:
+            # Get all sheet names
+            xl = pd.ExcelFile(file_path)
+            sheet_names = xl.sheet_names
+            
+            # Process all sheets and create complete markdown
+            all_markdown = []
+            
+            # Add document title - make it more descriptive
+            # Clean up the filename to remove temporary path prefixes
+            filename = Path(file_path).stem
+            # Remove temporary filename prefixes like med_temp_XXX_
+            if 'med_temp_' in filename:
+                clean_filename = filename.split('_', 3)[-1] if len(filename.split('_')) > 3 else filename
+            else:
+                clean_filename = filename
+                
+            all_markdown.append(f"# Excel Document: {clean_filename}\n\n")
+            
+            # Track sheet data for document metadata
+            sheets_data = {}
+            
+            # Process each sheet
+            for sheet_name in sheet_names:
+                # Read the sheet into a DataFrame
+                df = pd.read_excel(file_path, sheet_name=sheet_name)
+                
+                # Skip empty sheets
+                if df.empty:
+                    continue
+                
+                # Create markdown for this sheet with better heading
+                sheet_markdown = f"## Sheet: {sheet_name}"
+                
+                # Add row and column count for better context
+                row_count = len(df)
+                col_count = len(df.columns)
+                sheet_markdown += f" ({row_count} rows × {col_count} columns)\n\n"
+                
+                # Convert DataFrame to markdown table
+                table_markdown = df.to_markdown(index=False)
+                if table_markdown:
+                    sheet_markdown += table_markdown + "\n\n"
+                else:
+                    # Fallback for complex tables
+                    sheet_markdown += self._complex_df_to_markdown(df) + "\n\n"
+                
+                # Add sheet data to metadata
+                sheets_data[sheet_name] = {
+                    "rows": row_count,
+                    "columns": col_count,
+                    "column_names": df.columns.tolist()
+                }
+                
+                # Create section for this sheet with improved title
+                section = DocumentSection(title=f"Sheet: {sheet_name} ({row_count} rows × {col_count} columns)", level=2)
+                section.metadata["sheet_name"] = sheet_name
+                section.metadata["rows"] = row_count
+                section.metadata["columns"] = col_count
+                
+                # Add the table as a markdown element
+                section.add_element(DocumentElement(
+                    content=table_markdown,
+                    element_type="markdown"
+                ))
+                
+                # Add section to document
+                document.add_section(section)
+                
+                # Add to combined markdown
+                all_markdown.append(sheet_markdown)
+            
+            # Store the combined markdown in metadata
+            document.metadata["markdown"] = "\n".join(all_markdown)
+            document.metadata["sheets"] = sheets_data
+            document.metadata["sheet_count"] = len(sheet_names)
+            
+        except Exception as e:
+            print(f"Error processing Excel file: {str(e)}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process Excel file: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+            document.metadata["error"] = str(e)
+            
+        return document
+    
+    def _complex_df_to_markdown(self, df: pd.DataFrame) -> str:
+        """
+        Convert complex DataFrames to markdown tables
+        Handles cases where the standard to_markdown might fail
+        
+        Args:
+            df: DataFrame to convert
+            
+        Returns:
+            str: Markdown table representation
+        """
+        # Create header row
+        header = "| " + " | ".join(str(col) for col in df.columns) + " |"
+        
+        # Create separator row
+        separator = "| " + " | ".join(["---"] * len(df.columns)) + " |"
+        
+        # Create data rows
+        rows = []
+        for _, row in df.iterrows():
+            row_str = "| " + " | ".join(str(val) if not pd.isna(val) else "" for val in row) + " |"
+            rows.append(row_str)
+        
+        # Combine all parts
+        return header + "\n" + separator + "\n" + "\n".join(rows)

processors/text/ipynb_processor.py

@@ -0,0 +1,90 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+import json
+import nbformat
+
+class JupyterNotebookProcessor(BaseDocumentProcessor):
+    """Processor for Jupyter Notebooks"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process Jupyter Notebook"""
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.JUPYTER
+        )
+        
+        try:
+            # Parse the notebook
+            notebook = nbformat.read(file_path, as_version=4)
+            
+            # Create a section for each cell
+            markdown_parts = []
+            
+            # Add notebook title if available
+            if 'title' in notebook.metadata:
+                markdown_parts.append(f"# {notebook.metadata['title']}\n\n")
+            
+            # Process cells
+            for i, cell in enumerate(notebook.cells):
+                cell_type = cell.cell_type
+                
+                # For markdown cells, add the content directly
+                if cell_type == 'markdown':
+                    markdown_parts.append(cell.source + "\n\n")
+                    
+                    # Also add to document structure
+                    section = DocumentSection(title=f"Markdown Cell {i+1}")
+                    section.add_element(DocumentElement(
+                        content=cell.source,
+                        element_type="markdown"
+                    ))
+                    document.add_section(section)
+                    
+                # For code cells, format as code blocks with output
+                elif cell_type == 'code':
+                    # Code
+                    markdown_parts.append(f"```python\n{cell.source}\n```\n\n")
+                    
+                    # Add code to document structure
+                    section = DocumentSection(title=f"Code Cell {i+1}")
+                    section.add_element(DocumentElement(
+                        content=cell.source,
+                        element_type="code",
+                        metadata={"language": "python"}
+                    ))
+                    
+                    # Process output if available
+                    if hasattr(cell, 'outputs') and cell.outputs:
+                        outputs = []
+                        for output in cell.outputs:
+                            if output.output_type == 'stream':
+                                outputs.append(f"```\n{output.text}\n```\n\n")
+                            elif output.output_type == 'execute_result':
+                                if 'text/plain' in output.data:
+                                    outputs.append(f"```\n{output.data['text/plain']}\n```\n\n")
+                        
+                        if outputs:
+                            output_content = "".join(outputs)
+                            markdown_parts.append(f"**Output:**\n\n{output_content}")
+                            section.add_element(DocumentElement(
+                                content=output_content,
+                                element_type="code_output"
+                            ))
+                    
+                    document.add_section(section)
+            
+            # Store combined markdown in metadata
+            document.metadata["markdown"] = "".join(markdown_parts)
+            
+        except Exception as e:
+            print(f"Error processing notebook: {e}")
+            # Create error section
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process notebook: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document

processors/text/markdown_processor.py

@@ -0,0 +1,81 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+import re
+
+class MarkdownProcessor(BaseDocumentProcessor):
+    """Processor for Markdown and R Markdown files"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process markdown file"""
+        doc_type = DocumentType.from_file_extension(file_path)
+        
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=doc_type
+        )
+        
+        try:
+            # Read markdown content
+            with open(file_path, 'r', encoding='utf-8') as f:
+                markdown_content = f.read()
+            
+            # Extract sections based on headings
+            section_pattern = r'^(#{1,6})\s+(.+)$'
+            current_section = DocumentSection(title="Main Content")
+            current_content = []
+            last_position = 0
+            
+            for match in re.finditer(section_pattern, markdown_content, re.MULTILINE):
+                # If we have content before this heading, add it to current section
+                if last_position < match.start():
+                    content_before = markdown_content[last_position:match.start()].strip()
+                    if content_before:
+                        current_section.add_element(DocumentElement(
+                            content=content_before,
+                            element_type="markdown"
+                        ))
+                        current_content.append(content_before)
+                
+                # Add current section to document if it has content
+                if current_content:
+                    document.add_section(current_section)
+                    current_content = []
+                
+                # Create new section for this heading
+                level = len(match.group(1))  # Number of # characters
+                title = match.group(2)
+                current_section = DocumentSection(title=title, level=level)
+                
+                last_position = match.end()
+            
+            # Add any remaining content to the last section
+            if last_position < len(markdown_content):
+                remaining_content = markdown_content[last_position:].strip()
+                if remaining_content:
+                    current_section.add_element(DocumentElement(
+                        content=remaining_content,
+                        element_type="markdown"
+                    ))
+                    current_content.append(remaining_content)
+            
+            # Add the last section if it has content
+            if current_content:
+                document.add_section(current_section)
+            
+            # For R Markdown, we could additionally parse and extract R code chunks
+            # but for now we'll just handle it as regular markdown
+            
+            # Store the original markdown content
+            document.metadata["markdown"] = markdown_content
+            
+        except Exception as e:
+            print(f"Error processing markdown file: {e}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process markdown file: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document

processors/text/pdf_processor.py

@@ -0,0 +1,94 @@
+import os
+from typing import Dict, List, Optional, Union, Any
+from pathlib import Path
+
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+
+class PDFProcessor(BaseDocumentProcessor):
+    """Processor for PDF documents"""
+    
+    def __init__(self, use_vision_for_complex: bool = True):
+        """
+        Initialize PDF processor
+        
+        Args:
+            use_vision_for_complex: Whether to use vision processing for complex PDFs
+        """
+        super().__init__()
+        self.use_vision_for_complex = use_vision_for_complex
+        
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process PDF document"""
+        # First try text extraction
+        document = self._extract_text(file_path)
+        
+        # If text extraction didn't yield much content and vision processing is enabled,
+        # fall back to vision processing
+        content_size = sum(len(element.content) for section in document.sections for element in section.elements)
+        if content_size < 500 and self.use_vision_for_complex:
+            from processors.vision.vision_processor import VisionDocumentProcessor
+            try:
+                return VisionDocumentProcessor().process(file_path)
+            except Exception as e:
+                # If vision processing fails, return what we got from text extraction
+                print(f"Vision processing failed: {e}")
+                pass
+                
+        return document
+        
+    def _extract_text(self, file_path: str) -> StructuredDocument:
+        """Extract text from PDF using PyPDF2"""
+        from PyPDF2 import PdfReader
+        
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.PDF
+        )
+        
+        try:
+            reader = PdfReader(file_path)
+            
+            # Simple processing - create one section per page
+            for i, page in enumerate(reader.pages):
+                text = page.extract_text()
+                if not text.strip():
+                    continue
+                    
+                section = DocumentSection(title=f"Page {i+1}")
+                section.metadata["page"] = i+1
+                
+                # Simple paragraph splitting
+                paragraphs = text.split("\n\n")
+                for para in paragraphs:
+                    if not para.strip():
+                        continue
+                        
+                    # Try to detect if paragraph is a heading
+                    element_type = "paragraph"
+                    metadata = {}
+                    
+                    # Simple heuristic: if paragraph is short and ends with colon, it might be a heading
+                    if len(para) < 100 and para.strip().endswith(":"):
+                        element_type = "heading"
+                        metadata["level"] = 2
+                        
+                    section.add_element(DocumentElement(
+                        content=para.strip(),
+                        element_type=element_type,
+                        metadata=metadata
+                    ))
+                    
+                document.add_section(section)
+                
+        except Exception as e:
+            print(f"Error extracting text from PDF: {e}")
+            # Create error section
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to extract text: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+            
+        return document

processors/text/pptx_processor.py

@@ -0,0 +1,92 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+from pptx import Presentation
+
+class PowerPointProcessor(BaseDocumentProcessor):
+    """Processor for PowerPoint (PPTX) documents"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process PowerPoint presentation"""
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.POWERPOINT
+        )
+        
+        try:
+            # Open presentation
+            presentation = Presentation(file_path)
+            
+            # Storage for markdown output
+            markdown_parts = []
+            markdown_parts.append(f"# {Path(file_path).stem}\n\n")
+            
+            # Process each slide
+            for i, slide in enumerate(presentation.slides):
+                # Create section for each slide
+                slide_section = DocumentSection(title=f"Slide {i+1}", level=1)
+                slide_section.metadata["slide_number"] = i+1
+                
+                # Add slide title to markdown
+                markdown_parts.append(f"## Slide {i+1}\n\n")
+                
+                # Process slide title if available
+                if slide.shapes.title:
+                    title_text = slide.shapes.title.text
+                    markdown_parts.append(f"### {title_text}\n\n")
+                    
+                    title_element = DocumentElement(
+                        content=title_text,
+                        element_type="heading",
+                        metadata={"level": 3}
+                    )
+                    slide_section.add_element(title_element)
+                
+                # Process text elements
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip() and shape != slide.shapes.title:
+                        shape_text = shape.text.strip()
+                        # Skip if it's same as title
+                        if slide.shapes.title and shape_text == slide.shapes.title.text:
+                            continue
+                        
+                        markdown_parts.append(f"{shape_text}\n\n")
+                        
+                        # Add text as paragraph
+                        text_element = DocumentElement(
+                            content=shape_text,
+                            element_type="paragraph"
+                        )
+                        slide_section.add_element(text_element)
+                
+                # Add notes if available
+                if slide.has_notes_slide and slide.notes_slide.notes_text_frame.text.strip():
+                    notes_text = slide.notes_slide.notes_text_frame.text.strip()
+                    markdown_parts.append(f"**Notes:**\n\n{notes_text}\n\n")
+                    
+                    notes_element = DocumentElement(
+                        content=notes_text,
+                        element_type="paragraph",
+                        metadata={"is_notes": True}
+                    )
+                    slide_section.add_element(notes_element)
+                
+                # Add divider between slides
+                markdown_parts.append("---\n\n")
+                
+                # Add section to document
+                document.add_section(slide_section)
+            
+            # Store combined markdown
+            document.metadata["markdown"] = "".join(markdown_parts)
+            
+        except Exception as e:
+            print(f"Error processing PowerPoint: {e}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process PowerPoint: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document

processors/text/text_processor.py

@@ -0,0 +1,41 @@
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+from pathlib import Path
+
+class TextProcessor(BaseDocumentProcessor):
+    """Processor for plain text files"""
+    
+    def process(self, file_path: str) -> StructuredDocument:
+        """Process text file"""
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=DocumentType.TEXT
+        )
+        
+        try:
+            # Read text content
+            with open(file_path, 'r', encoding='utf-8') as f:
+                text_content = f.read()
+            
+            # Create document structure
+            main_section = DocumentSection(title="Text Content")
+            main_section.add_element(DocumentElement(
+                content=text_content,
+                element_type="paragraph"
+            ))
+            document.add_section(main_section)
+            
+            # Generate markdown representation
+            markdown = f"# {Path(file_path).name}\n\n{text_content}\n"
+            document.metadata["markdown"] = markdown
+            
+        except Exception as e:
+            print(f"Error processing text file: {e}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process text file: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+        
+        return document

processors/vision/__init__.py

@@ -0,0 +1,7 @@
+"""
+Vision-based document processors using Qwen2.5-VL.
+"""
+
+from processors.vision.vision_processor import VisionDocumentProcessor
+
+__all__ = ['VisionDocumentProcessor']

processors/vision/vision_processor.py

@@ -0,0 +1,658 @@
+import os
+import base64
+from typing import Dict, List, Optional, Union, Any, Tuple
+from pathlib import Path
+from io import BytesIO
+
+from PIL import Image
+from openai import OpenAI
+
+from processors.base import BaseDocumentProcessor, StructuredDocument, DocumentSection, DocumentElement, DocumentType
+
+class VisionDocumentProcessor(BaseDocumentProcessor):
+    """Document processor using Qwen2.5-VL via OpenAI-compatible API"""
+    
+    # Configurable remote model and API settings
+    MODEL_PATH = "Qwen/Qwen2.5-VL-32B-Instruct:featherless-ai"
+    BASE_URL = "https://router.huggingface.co/v1"
+    API_KEY = None
+    
+    @classmethod
+    def configure_api(
+        cls,
+        api_key=None,
+        base_url=None,
+        model=None,
+    ):
+        """
+        Configure class-level API settings for the remote vision model.
+        """
+        if api_key:
+            cls.API_KEY = api_key
+            
+        if base_url:
+            cls.BASE_URL = base_url
+            
+        if model:
+            cls.MODEL_PATH = model
+    
+    def __init__(
+        self, 
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        model: Optional[str] = None,
+        temperature: float = 0.0,
+        max_tokens: Optional[int] = None
+    ):
+        """
+        Initialize remote vision document processor with OpenAI SDK
+        
+        Args:
+            api_key: API key for the remote service
+            base_url: Base URL for the OpenAI compatible endpoint
+            model: Remote model identifier
+            temperature: Temperature for generation (0.0-1.0).
+            max_tokens: Maximum tokens to generate.
+        """
+        super().__init__()
+        
+        self.temperature = float(temperature) if temperature is not None else 0.0
+        self.max_tokens = int(max_tokens) if max_tokens is not None else 4000
+        
+        self.model = model or self.MODEL_PATH
+        api_key = (
+            api_key
+            or self.API_KEY
+            or os.getenv("HF_TOKEN")
+        )
+        self.client = OpenAI(
+            base_url=base_url or self.BASE_URL,
+            api_key=api_key,
+        )
+            
+    def process(self, file_path: str, max_concurrent: int = 2, images_per_batch: int = 1, 
+                dynamic_batching: bool = True, max_tokens_per_batch: int = 4000) -> StructuredDocument:
+        """
+        Process document using remote vision model
+        
+        Args:
+            file_path: Path to document file
+            max_concurrent: Maximum number of concurrent API calls for PDFs
+            images_per_batch: Number of consecutive pages to process in a single API call
+                (1 = traditional single page processing, 2+ = multi-image processing)
+            dynamic_batching: Whether to dynamically determine batch sizes based on image complexity
+            max_tokens_per_batch: Maximum tokens per batch when using dynamic batching
+            
+        Returns:
+            StructuredDocument: Processed document
+        """
+        # Get document type
+        doc_type = DocumentType.from_file_extension(file_path)
+        
+        # Create document with basic metadata
+        document = StructuredDocument(
+            title=Path(file_path).stem,
+            source_file=file_path,
+            doc_type=doc_type
+        )
+        
+        # If file is PDF, process each page separately
+        if (doc_type == DocumentType.PDF):
+            if images_per_batch > 1:
+                # Use multi-image processing if specified
+                self._process_pdf_multi(file_path, document, max_concurrent, images_per_batch, 
+                                        dynamic_batching, max_tokens_per_batch)
+            else:
+                # Use original single-page processing
+                self._process_pdf(file_path, document, max_concurrent)
+                
+            # Ensure page markers are removed from final document output
+            if "markdown" in document.metadata:
+                document.metadata["markdown"] = self._remove_page_markers(document.metadata["markdown"])
+                
+                # Also update section content to remove page markers
+                for section in document.sections:
+                    for element in section.elements:
+                        if element.element_type == "markdown":
+                            element.content = self._remove_page_markers(element.content)
+                            
+        else:
+            # For images and other document types
+            image_content = self._prepare_image(file_path)
+            
+            # Get markdown response directly
+            markdown_response = self._call_api(image_content)
+            
+            # Create a section for the entire document
+            section = DocumentSection(title=Path(file_path).stem, level=1)
+            section.add_element(DocumentElement(
+                content=markdown_response,
+                element_type="markdown"
+            ))
+            document.add_section(section)
+            
+            # Store raw markdown in metadata
+            document.metadata["markdown"] = markdown_response
+        
+        return document
+    
+    def _prepare_image(self, file_path: str) -> str:
+        """Read image file and encode as base64"""
+        with open(file_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+    
+    def _process_pdf(self, file_path: str, document: StructuredDocument, max_concurrent: int = 2) -> None:
+        """
+        Process PDF document with parallel page processing
+        """
+        from pdf2image import convert_from_path
+        import tempfile
+        import concurrent.futures
+        
+        # Storage for combined markdown from all pages
+        all_markdown = [None] * 0  # Will resize based on page count
+        all_sections = [None] * 0  # Will resize based on page count
+        
+        try:
+            # Convert PDF to images
+            with tempfile.TemporaryDirectory() as path:
+                # Check if we can convert the PDF
+                try:
+                    print("Converting PDF to images...")
+                    images = convert_from_path(file_path)
+                    page_count = len(images)
+                    print(f"Converted {page_count} pages")
+                    
+                    # Resize result arrays
+                    all_markdown = [None] * page_count
+                    all_sections = [None] * page_count
+                    
+                except Exception as e:
+                    print(f"Error converting PDF to images: {str(e)}")
+                    error_section = DocumentSection(title="Error")
+                    error_section.add_element(DocumentElement(
+                        content=f"Failed to convert PDF to images: {str(e)}",
+                        element_type="paragraph"
+                    ))
+                    document.add_section(error_section)
+                    return
+                
+                # Save all images first
+                image_paths = []
+                for i, image in enumerate(images):
+                    temp_image_path = os.path.join(path, f"page_{i+1}.jpg")
+                    image.save(temp_image_path, "JPEG")
+                    image_paths.append((i, temp_image_path))
+                
+                # Process pages in parallel
+                with concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent) as executor:
+                    # Submit all tasks and store the futures
+                    future_to_page = {
+                        executor.submit(self._process_single_page, path, index, temp_path): (index, temp_path) 
+                        for index, temp_path in image_paths
+                    }
+                    
+                    # Process completed tasks as they finish
+                    completed = 0
+                    for future in concurrent.futures.as_completed(future_to_page):
+                        index, temp_path = future_to_page[future]
+                        try:
+                            section, markdown = future.result()
+                            all_sections[index] = section
+                            all_markdown[index] = markdown
+                            completed += 1
+                            print(f"Completed page {index+1}/{page_count} ({completed}/{page_count} done)")
+                        except Exception as e:
+                            print(f"Error processing page {index+1}: {str(e)}")
+                            error_section = DocumentSection(title=f"Error on Page {index+1}")
+                            error_section.add_element(DocumentElement(
+                                content=f"Failed to process page: {str(e)}",
+                                element_type="paragraph"
+                            ))
+                            all_sections[index] = error_section
+                            all_markdown[index] = f"## Page {index+1}\n\nError processing page: {str(e)}"
+                
+                # Add all sections to document in correct order
+                for section in all_sections:
+                    if section:
+                        document.add_section(section)
+                        
+                # Combine all markdown
+                valid_markdown = [md for md in all_markdown if md]
+                if valid_markdown:
+                    document.metadata["markdown"] = "\n\n".join(valid_markdown)
+                    
+        except Exception as e:
+            print(f"Error in PDF processing: {str(e)}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process PDF: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+
+    def _process_pdf_multi(self, file_path: str, document: StructuredDocument, max_concurrent: int = 2, images_per_batch: int = 2, 
+                           dynamic_batching: bool = True, max_tokens_per_batch: int = 4000) -> None:
+        """
+        Process PDF document with multi-image batches for improved context
+        """
+        from pdf2image import convert_from_path
+        import tempfile
+        import concurrent.futures
+        
+        # Storage for combined markdown from all pages
+        all_markdown = []
+        all_sections = []
+        
+        try:
+            # Convert PDF to images
+            with tempfile.TemporaryDirectory() as path:
+                # Check if we can convert the PDF
+                try:
+                    print("Converting PDF to images...")
+                    images = convert_from_path(file_path)
+                    page_count = len(images)
+                    print(f"Converted {page_count} pages")
+                    
+                    # Initialize result arrays
+                    all_markdown = [None] * page_count
+                    all_sections = [None] * page_count
+                    
+                except Exception as e:
+                    print(f"Error converting PDF to images: {str(e)}")
+                    error_section = DocumentSection(title="Error")
+                    error_section.add_element(DocumentElement(
+                        content=f"Failed to convert PDF to images: {str(e)}",
+                        element_type="paragraph"
+                    ))
+                    document.add_section(error_section)
+                    return
+                
+                # Save all images first
+                image_paths = []
+                for i, image in enumerate(images):
+                    temp_image_path = os.path.join(path, f"page_{i+1}.jpg")
+                    image.save(temp_image_path, "JPEG")
+                    image_paths.append((i, temp_image_path))
+                
+                # Create batch groups
+                batch_tasks = []
+                
+                for i in range(0, len(image_paths), images_per_batch):
+                    batch = image_paths[i:i+images_per_batch]
+                    if batch:
+                        # For each batch, all indices and paths
+                        indices = [idx for idx, _ in batch]
+                        paths = [p for _, p in batch]
+                        batch_tasks.append((indices, paths))
+                
+                print(f"Processing PDF with {len(batch_tasks)} batches of up to {images_per_batch} pages each")
+                
+                # Process batches in parallel
+                with concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent) as executor:
+                    # Submit all batch tasks
+                    future_to_batch = {
+                        executor.submit(self._process_multi_page_batch, path, indices, paths): (indices, paths) 
+                        for indices, paths in batch_tasks
+                    }
+                    
+                    # Process completed batch tasks
+                    completed_batches = 0
+                    for future in concurrent.futures.as_completed(future_to_batch):
+                        indices, paths = future_to_batch[future]
+                        try:
+                            results = future.result()  # List of (section, markdown) tuples
+                            
+                            # Store results in correct positions
+                            for i, (idx, result) in enumerate(zip(indices, results)):
+                                if result:
+                                    section, markdown = result
+                                    all_sections[idx] = section
+                                    all_markdown[idx] = markdown
+                            
+                            completed_batches += 1
+                            processed_pages = min(completed_batches * images_per_batch, page_count)
+                            print(f"Completed batch {completed_batches}/{len(batch_tasks)} ({processed_pages}/{page_count} pages)")
+                            
+                        except Exception as e:
+                            print(f"Error processing batch {indices}: {str(e)}")
+                            # Create error sections for failed pages
+                            for idx in indices:
+                                page_num = idx + 1
+                                error_section = DocumentSection(title=f"Error on Page {page_num}")
+                                error_section.add_element(DocumentElement(
+                                    content=f"Failed to process page batch: {str(e)}",
+                                    element_type="paragraph"
+                                ))
+                                all_sections[idx] = error_section
+                                all_markdown[idx] = f"## Page {page_num}\n\nError processing page: {str(e)}"
+                
+                # Add all sections to document in correct order
+                for section in all_sections:
+                    if section:
+                        document.add_section(section)
+                        
+                # Combine all markdown
+                valid_markdown = [md for md in all_markdown if md]
+                if valid_markdown:
+                    document.metadata["markdown"] = "\n\n".join(valid_markdown)
+                    
+        except Exception as e:
+            print(f"Error in PDF processing: {str(e)}")
+            error_section = DocumentSection(title="Error")
+            error_section.add_element(DocumentElement(
+                content=f"Failed to process PDF: {str(e)}",
+                element_type="paragraph"
+            ))
+            document.add_section(error_section)
+
+    def _process_single_page(self, temp_dir: str, page_index: int, image_path: str) -> tuple:
+        """
+        Process a single page in the PDF
+        """
+        print(f"Started processing page {page_index+1}")
+        page_num = page_index + 1  # Convert to 1-based page numbers for display
+        
+        # Process image
+        image_content = self._prepare_image(image_path)
+        markdown_response = self._call_api(image_content)
+        
+        # Create section for this page
+        section = DocumentSection(title=f"Page {page_num}", level=1)
+        section.metadata["page"] = page_num
+        section.add_element(DocumentElement(
+            content=markdown_response,
+            element_type="markdown"
+        ))
+        
+        # Format markdown with page indicator
+        page_markdown = f"## Page {page_num}\n\n{markdown_response}"
+        
+        return section, page_markdown
+        
+    def _call_api(self, image_content: str) -> str:
+        """
+        Run remote vision model inference using OpenAI compatible API
+        
+        Args:
+            image_content: Base64 encoded image
+            
+        Returns:
+            str: Markdown representation of the document
+        """
+        prompt_text = (
+            "Convert this document into clean Markdown.\n"
+            "Requirements:\n"
+            "- preserve headings\n"
+            "- preserve tables\n"
+            "- preserve lists\n"
+            "- preserve code blocks\n"
+            "- preserve formatting\n"
+            "- preserve hierarchy\n"
+            "- do not include page numbers\n"
+            "- output Markdown only\n"
+            "- do not explain your reasoning"
+        )
+        
+        print("Running remote model inference...")
+        try:
+            data_uri = f"data:image/jpeg;base64,{image_content}"
+            
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt_text
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": data_uri
+                            }
+                        }
+                    ]
+                }
+            ]
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+            )
+            
+            markdown_response = response.choices[0].message.content
+            print("\nMarkdown response generated successfully")
+            return markdown_response
+            
+        except Exception as e:
+            print(f"Error during remote inference: {str(e)}")
+            return f"# Model Error\n\nFailed to process document: {str(e)}"
+
+    def _call_api_multi_image(self, image_contents: list, page_numbers: list) -> str:
+        """
+        Run remote vision model inference with multiple images 
+        
+        Args:
+            image_contents: List of base64 encoded images
+            page_numbers: List of page numbers for these images
+            
+        Returns:
+            str: Markdown representation of the document across multiple pages
+        """
+        print(f"Processing {len(image_contents)} images remotely")
+        
+        try:
+            content = []
+            
+            for img in image_contents:
+                content.append({
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{img}"
+                    }
+                })
+                
+            prompt_text = (
+                f"These are consecutive pages from a document (pages {', '.join(map(str, page_numbers))}). "
+                "Convert this document into clean Markdown.\n"
+                "Requirements:\n"
+                "- preserve headings\n"
+                "- preserve tables\n"
+                "- preserve lists\n"
+                "- preserve code blocks\n"
+                "- preserve formatting\n"
+                "- preserve hierarchy\n"
+                "- do not include page numbers\n"
+                "- output Markdown only\n"
+                "- do not explain your reasoning"
+            )
+            
+            content.append({
+                "type": "text",
+                "text": prompt_text
+            })
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": content
+                    }
+                ],
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            print(f"Multi-image inference failed ({str(e)}). Falling back to sequential processing.")
+            
+            # Fallback to sequential execution if context window or multi-image processing fails
+            results = []
+            for img_content, page_num in zip(image_contents, page_numbers):
+                print(f"Running fallback inference for page {page_num}...")
+                page_markdown = self._call_api(img_content)
+                results.append(f"## Page {page_num}\n\n{page_markdown}")
+                
+            return "\n\n".join(results)
+
+    def _process_multi_page_batch(self, temp_dir: str, page_indices: list, image_paths: list) -> list:
+        """
+        Process multiple pages in a single API call
+        """
+        page_numbers = [idx+1 for idx in page_indices]  # Convert to 1-based page numbers
+        print(f"Processing batch with pages: {page_numbers}")
+        
+        # Encode all images in the batch
+        image_contents = []
+        for path in image_paths:
+            image_contents.append(self._prepare_image(path))
+        
+        # Call API with multiple images
+        markdown_response = self._call_api_multi_image(image_contents, page_numbers)
+        
+        # Split response by page markers
+        results = []
+        
+        try:
+            # Check if it's a multi-page response with page markers
+            if "## Page" in markdown_response:
+                # Attempt to split by page markers
+                parts = []
+                current_part = []
+                current_page_idx = None
+                
+                for line in markdown_response.split("\n"):
+                    if line.strip().startswith("## Page"):
+                        # If we already have content for a page, save it
+                        if current_part and current_page_idx is not None:
+                            parts.append((current_page_idx, "\n".join(current_part)))
+                        
+                        # Start a new page
+                        current_part = [line]
+                        
+                        # Extract page number from heading
+                        try:
+                            page_text = line.strip().replace("## Page", "").strip()
+                            current_page_idx = int(page_text) - 1  # Convert to 0-based index
+                        except:
+                            # If we can't extract page number, use position in batch
+                            current_page_idx = len(parts)
+                    else:
+                        current_part.append(line)
+                        
+                # Add the last part
+                if current_part and current_page_idx is not None:
+                    parts.append((current_page_idx, "\n".join(current_part)))
+                    
+                # Create sections for each identified page
+                for page_idx, content in parts:
+                    if 0 <= page_idx < len(page_indices):
+                        idx = page_indices[page_idx]
+                        page_num = idx + 1
+                        
+                        section = DocumentSection(title=f"Page {page_num}", level=1)
+                        section.metadata["page"] = page_num
+                        section.add_element(DocumentElement(
+                            content=content,
+                            element_type="markdown"
+                        ))
+                        
+                        # Include page heading if not already there
+                        if not content.strip().startswith("## Page"):
+                            page_markdown = f"## Page {page_num}\n\n{content}"
+                        else:
+                            page_markdown = content
+                            
+                        results.append((section, page_markdown))
+            else:
+                # If no page markers are found, distribute content evenly
+                # This is a fallback and likely to be less accurate
+                for i, idx in enumerate(page_indices):
+                    page_num = idx + 1
+                    
+                    # Simple approach - split content by number of pages
+                    chunk_size = max(1, len(markdown_response) // len(page_indices))
+                    start_pos = i * chunk_size
+                    end_pos = start_pos + chunk_size if i < len(page_indices)-1 else len(markdown_response)
+                    
+                    content = markdown_response[start_pos:end_pos]
+                    
+                    section = DocumentSection(title=f"Page {page_num}", level=1)
+                    section.metadata["page"] = page_num
+                    section.add_element(DocumentElement(
+                        content=content,
+                        element_type="markdown"
+                    ))
+                    
+                    page_markdown = f"## Page {page_num}\n\n{content}"
+                    results.append((section, page_markdown))
+        except Exception as e:
+            print(f"Error parsing multi-page response: {str(e)}")
+            # Fallback - create an error section for each page
+            for idx in page_indices:
+                page_num = idx + 1
+                error_content = f"Error parsing multi-page response: {str(e)}"
+                
+                section = DocumentSection(title=f"Page {page_num}", level=1)
+                section.metadata["page"] = page_num
+                section.add_element(DocumentElement(
+                    content=error_content,
+                    element_type="paragraph"
+                ))
+                
+                page_markdown = f"## Page {page_num}\n\n{error_content}"
+                results.append((section, page_markdown))
+        
+        # Ensure we have a result for each page in the batch
+        while len(results) < len(page_indices):
+            idx = page_indices[len(results)]
+            page_num = idx + 1
+            error_message = "No content was generated for this page in the batch."
+            
+            section = DocumentSection(title=f"Page {page_num}", level=1)
+            section.metadata["page"] = page_num
+            section.add_element(DocumentElement(
+                content=error_message,
+                element_type="paragraph"
+            ))
+            
+            page_markdown = f"## Page {page_num}\n\n{error_message}"
+            results.append((section, page_markdown))
+        
+        return results
+
+    def _remove_page_markers(self, content: str) -> str:
+        """
+        Remove page marker headings from the markdown content
+        """
+        if not content:
+            return content
+            
+        # Split by lines and filter out page marker headings
+        lines = content.split('\n')
+        filtered_lines = []
+        skip_next_empty = False
+        
+        for line in lines:
+            # Check if line is a page marker (## Page X)
+            if line.strip().startswith('## Page '):
+                skip_next_empty = True  # Skip the next empty line if it exists
+                continue
+                
+            # Skip empty line after page marker
+            if skip_next_empty and not line.strip():
+                skip_next_empty = False
+                continue
+                
+            filtered_lines.append(line)
+            
+        # Rejoin the filtered lines
+        cleaned_content = '\n'.join(filtered_lines)
+        
+        return cleaned_content

requirements.txt

@@ -0,0 +1,24 @@
+# Core dependencies
+requests>=2.31.0
+pillow>=10.0.0
+beautifulsoup4>=4.12.0
+pydantic>=2.5.0
+tqdm>=4.66.0
+openai>=1.30.0
+
+# Document handling
+PyPDF2>=3.0.0
+pdf2image>=1.16.3
+python-docx>=1.0.0
+python-pptx>=0.6.21
+nbformat>=5.9.0
+markdown>=3.5.1
+tree-sitter>=0.20.1
+mammoth>=1.6.0
+docx2python>=1.0.0
+pandas>=2.0.0
+openpyxl>=3.1.0
+tabulate>=0.9.0
+
+# UI Framework
+gradio>=4.13.0

ui/__init__.py

@@ -0,0 +1 @@
+# UI package

ui/gradio_app.py

@@ -0,0 +1,81 @@
+import gradio as gr
+
+from processors.base import BaseDocumentProcessor, DocumentType
+from processors.vision.vision_processor import VisionDocumentProcessor
+
+MODEL_NAME = "Qwen/Qwen2.5-VL-32B-Instruct:featherless-ai"
+
+
+def convert_document(
+    uploaded_file,
+    force_vision,
+    temperature,
+):
+    if uploaded_file is None:
+        return "Please upload a document."
+
+    try:
+        doc_type = DocumentType.from_file_extension(uploaded_file)
+
+        if force_vision or doc_type == DocumentType.IMAGE:
+            processor = VisionDocumentProcessor(
+                temperature=temperature,
+            )
+        else:
+            processor = BaseDocumentProcessor.get_processor(uploaded_file)
+
+        document = processor.process(uploaded_file)
+
+        return document.to_markdown()
+
+    except Exception as e:
+        return f"Error:\n\n{str(e)}"
+
+
+def create_ui():
+
+    with gr.Blocks(title="VisionMark") as demo:
+
+        gr.Markdown("# VisionMark")
+        gr.Markdown(
+            "Convert PDFs and images into structured Markdown using a Vision Language Model."
+        )
+
+        file_input = gr.File(
+            label="Upload Document",
+            type="filepath",
+        )
+
+        force_vision = gr.Checkbox(
+            value=False,
+            label="Force Vision Processing",
+        )
+
+        gr.Markdown(f"**Model:** `{MODEL_NAME}`")
+
+        temperature = gr.Slider(
+            minimum=0.0,
+            maximum=1.0,
+            value=0.0,
+            step=0.1,
+            label="Temperature",
+        )
+
+        convert_btn = gr.Button("Convert")
+
+        output = gr.Code(
+            label="Markdown Output",
+            language="markdown",
+        )
+
+        convert_btn.click(
+            fn=convert_document,
+            inputs=[
+                file_input,
+                force_vision,
+                temperature,
+            ],
+            outputs=output,
+        )
+
+    return demo