Implement multi-document processing capabilities and enhance UI

- Introduced support for processing up to 5 files simultaneously with a combined size limit of 20MB.
- Added new processing types: Combined, Individual, Summary, and Comparison for enhanced document analysis.
- Updated the Gemini Flash parser to handle multiple documents and format outputs based on processing type.
- Enhanced the UI to dynamically display processing options and real-time validation for file uploads.
- Unified document conversion method to streamline single and multi-file processing.
- Improved error handling and logging for batch processing operations.

README.md

@@ -20,11 +20,17 @@ A Hugging Face Space that converts various document formats to Markdown and lets
 
 ### Document Conversion
 - Convert PDFs, Office documents, images, and more to Markdown
+- **🆕 Multi-Document Processing**: Process up to 5 files simultaneously (20MB combined)
 - Multiple parser options:
   - MarkItDown: For comprehensive document conversion
   - Docling: For advanced PDF understanding with table structure recognition
   - GOT-OCR: For image-based OCR with LaTeX support
-  - Gemini Flash: For AI-powered text extraction
+  - Gemini Flash: For AI-powered text extraction with **advanced multi-document capabilities**
+- **🆕 Intelligent Processing Types**:
+  - **Combined**: Merge documents into unified content with duplicate removal
+  - **Individual**: Separate sections per document with clear organization
+  - **Summary**: Executive overview + detailed analysis of all documents
+  - **Comparison**: Cross-document analysis with similarities/differences tables
 - Download converted documents as Markdown files
 
 ### 🤖 RAG Chat with Documents
@@ -40,34 +46,68 @@ A Hugging Face Space that converts various document formats to Markdown and lets
 
 ### User Interface
 - **Dual-tab interface**: Document Converter + Chat
+- **🆕 Unified File Input**: Single interface handles both single and multiple file uploads
+- **🆕 Dynamic Processing Options**: Multi-document processing type selector appears automatically
+- **🆕 Real-time Validation**: Live feedback on file count, size limits, and processing mode
 - **Real-time status monitoring** for RAG system with environment detection
 - **Auto-ingestion** of converted documents into chat system
 - **Enhanced status display**: Shows vector store document count, chat history files, and environment type
 - **Data management controls**: Clear All Data button with comprehensive feedback
 - **Filename preservation**: Downloaded files maintain original names (e.g., "example data.pdf" → "example data.md")
+- **🆕 Smart Output Naming**: Batch processing creates descriptive filenames (e.g., "Combined_3_Documents_20240125.md")
 - Clean, responsive UI with modern styling
 
-## Using MarkItDown & Docling
+## Supported Libraries
 
-This app integrates multiple powerful document conversion libraries:
+**MarkItDown** ([Microsoft](https://github.com/microsoft/markitdown)): PDF, Office docs, images, audio, HTML, ZIP files, YouTube URLs, EPubs, and more.
 
-### MarkItDown
-[Microsoft's MarkItDown](https://github.com/microsoft/markitdown) library supports a wide range of file formats:
+**Docling** ([IBM](https://github.com/DS4SD/docling)): Advanced PDF understanding with table structure recognition, multiple OCR engines, and layout analysis.
 
-### Docling
-[IBM's Docling](https://github.com/DS4SD/docling) provides advanced document understanding with:
-- **Advanced PDF parsing** with layout understanding, reading order, and table structure recognition
-- **Multiple OCR engines** including EasyOCR and Tesseract
-- **Document format support**: PDF, DOCX, XLSX, PPTX, HTML, Images (PNG, JPG, TIFF, BMP, WEBP), CSV
-- **Local execution** for sensitive data processing
-- **Formula and code understanding** with enrichment features
-- **Picture classification** and description capabilities
+**Gemini Flash** ([Google](https://deepmind.google/technologies/gemini/)): AI-powered document understanding with **advanced multi-document processing capabilities**, cross-format analysis, and intelligent content synthesis.
 
-### MarkItDown Features
-- PDF, PowerPoint (PPTX), Word (DOCX), Excel (XLSX)
-- Images (JPG, PNG), Audio files (with transcription)
-- HTML, Text-based formats (CSV, JSON, XML)
-- ZIP files, YouTube URLs, EPubs, and more!
+## 🚀 Multi-Document Processing
+
+### **What makes this special?**
+Markit v2 introduces **industry-leading multi-document processing** powered by Google's Gemini Flash 2.5, enabling intelligent analysis across multiple documents simultaneously.
+
+### **Key Capabilities:**
+- **📊 Cross-Document Analysis**: Compare and contrast information across different files
+- **🔄 Smart Duplicate Removal**: Intelligently merges overlapping content while preserving unique insights
+- **📋 Format Intelligence**: Handles mixed file types (PDF + images, Word + Excel, etc.) seamlessly
+- **🧠 Contextual Understanding**: Recognizes relationships and patterns across document boundaries
+- **⚡ Single API Call Processing**: Efficient batch processing using Gemini's native multi-document support
+
+### **Processing Types Explained:**
+
+#### 🔗 **Combined Processing**
+- **Purpose**: Create one unified, cohesive document from multiple sources
+- **Best for**: Related documents that should be read as one complete resource
+- **Intelligence**: Removes redundant information while preserving all critical content
+- **Example**: Merge project proposal + budget + timeline into one comprehensive document
+
+#### 📑 **Individual Processing**  
+- **Purpose**: Convert each document separately but organize them in one output
+- **Best for**: Different documents you want in one place for easy reference
+- **Intelligence**: Maintains original structure while creating clear organization
+- **Example**: Meeting agenda + presentation + notes → organized sections
+
+#### 📈 **Summary Processing**
+- **Purpose**: Executive overview + detailed analysis
+- **Best for**: Complex document sets needing high-level insights
+- **Intelligence**: Cross-document pattern recognition and key insight extraction
+- **Example**: Research papers → executive summary + detailed analysis of each paper
+
+#### ⚖️ **Comparison Processing**
+- **Purpose**: Analyze differences, similarities, and relationships
+- **Best for**: Multiple proposals, document versions, or conflicting sources
+- **Intelligence**: Creates comparison tables and identifies discrepancies/alignments
+- **Example**: Contract versions → side-by-side analysis with change identification
+
+### **Technical Advantages:**
+- **Native Multimodal Support**: Processes text + images in same workflow
+- **Advanced Reasoning**: Understands context and relationships between documents
+- **Efficient Processing**: Single Gemini API call vs. multiple individual calls
+- **Format Agnostic**: Works across all supported file types seamlessly
 
 ## Environment Variables
 
@@ -81,6 +121,8 @@ The application uses centralized configuration management. You can enhance funct
 ### ⚙️ **Configuration Options:**
 - `DEBUG`: Set to `true` for debug mode with verbose logging
 - `MAX_FILE_SIZE`: Maximum file size in bytes (default: 10MB)
+- `MAX_BATCH_FILES`: Maximum files for multi-document processing (default: 5)
+- `MAX_BATCH_SIZE`: Maximum combined size for batch processing (default: 20MB)
 - `TEMP_DIR`: Directory for temporary files (default: ./temp)
 - `TESSERACT_PATH`: Custom path to Tesseract executable
 - `TESSDATA_PATH`: Path to Tesseract language data
@@ -118,15 +160,40 @@ The application uses centralized configuration management. You can enhance funct
 ## Usage
 
 ### Document Conversion
+
+#### 📄 **Single Document Processing**
 1. Go to the **"Document Converter"** tab
-2. Select a file to upload
+2. Upload a single file
 3. Choose your preferred parser:
    - **"MarkItDown"** for comprehensive document conversion
    - **"Docling"** for advanced PDF understanding and table extraction
+   - **"Gemini Flash"** for AI-powered text extraction
 4. Select an OCR method based on your chosen parser
 5. Click "Convert"
 6. View the Markdown output and download the converted file
-7. **Documents are automatically added to the RAG system** for chat functionality
+
+#### 📂 **Multi-Document Processing** (NEW!)
+1. Go to the **"Document Converter"** tab
+2. Upload **2-5 files** (up to 20MB combined)
+3. **Processing type selector appears automatically**
+4. Choose your processing type:
+   - **Combined**: Merge all documents into unified content with smart duplicate removal
+   - **Individual**: Keep documents separate with clear section headers
+   - **Summary**: Executive overview + detailed analysis of each document
+   - **Comparison**: Side-by-side analysis with similarities/differences tables
+5. Choose your preferred parser (recommend **Gemini Flash** for best multi-document results)
+6. Click "Convert"
+7. Get intelligent cross-document analysis and download enhanced output
+
+#### 💡 **Multi-Document Tips**
+- **Mixed file types work great**: Upload PDF + images, Word docs + PDFs, etc.
+- **Gemini Flash excels at**: Cross-document reasoning, duplicate detection, and format analysis
+- **Perfect for**: Comparing document versions, analyzing related reports, consolidating research
+- **Real-time validation**: UI shows file count, size limits, and processing mode
+
+#### 🤖 **RAG Integration**
+- **All converted documents are automatically added to the RAG system** for chat functionality
+- Multi-document processing creates richer context for chat interactions
 
 ### 🤖 Chat with Documents
 1. Go to the **"Chat with Documents"** tab
@@ -165,54 +232,30 @@ The application uses centralized configuration management. You can enhance funct
    # For local development (faster startup)
    python run_app.py
    
-   # For testing with clean data (clears chat history and vector store)
+   # For testing with clean data
    python run_app.py --clear-data-and-run
    
-   # To only clear data without running the app
-   python run_app.py --clear-data
+   # Show all available options
+   python run_app.py --help
    ```
 
-### 🧹 **Data Management for Testing:**
-For local development and testing, you can easily clear all stored data:
+### 🧹 **Data Management:**
 
-```bash
-# Clear all data and exit (useful for quick cleanup)
-python run_app.py --clear-data
+**Two ways to clear data:**
 
-# Clear all data then run the app (useful for fresh testing)
-python run_app.py --clear-data-and-run
+1. **Command-line** (for development):
+   - `python run_app.py --clear-data-and-run` - Clear data then start app
+   - `python run_app.py --clear-data` - Clear data and exit
 
-# Show all available options
-python run_app.py --help
-```
+2. **In-app UI** (for users):
+   - Go to "Chat with Documents" tab → Click "🗑️ Clear All Data" button
+   - Automatically detects environment (local vs HF Space)
+   - Provides detailed feedback and starts new session
 
 **What gets cleared:**
-- `data/chat_history/*` - All saved chat sessions
+- `data/chat_history/*` - All saved chat sessions  
 - `data/vector_store/*` - All document embeddings and vector database
 
-This is particularly useful when:
-- Testing new RAG features with fresh data
-- Clearing old chat sessions and documents
-- Resetting the system to a clean state
-- Debugging document ingestion issues
-
-### 🗑️ **In-App Data Clearing:**
-In addition to command-line data clearing, you can also clear data directly from the web interface:
-
-1. Go to the **"Chat with Documents"** tab
-2. Click the **"🗑️ Clear All Data"** button in the control panel
-3. All vector store documents and chat history will be cleared
-4. A new chat session will automatically start
-5. The status panel will update to reflect the cleared state
-
-**Features of in-app clearing:**
-- **Environment Detection**: Automatically works in both local and HF Space environments
-- **Comprehensive Clearing**: Removes both vector store documents and chat history files
-- **Smart Path Resolution**: Uses `/tmp/data/*` for HF Spaces, `./data/*` for local development
-- **User Feedback**: Shows detailed results of what was cleared
-- **Auto-Session Reset**: Starts fresh chat session after clearing
-- **Safe Operation**: Handles errors gracefully and provides status updates
-
 ### 🧪 **Development Features:**
 - **Automatic Environment Setup**: Dependencies are checked and installed automatically
 - **Configuration Validation**: Startup validation reports missing API keys and configuration issues
@@ -225,191 +268,14 @@ In addition to command-line data clearing, you can also clear data directly from
 - [GOT-OCR](https://github.com/stepfun-ai/GOT-OCR-2.0) for image-based OCR
 - [Gradio](https://gradio.app/) for the UI framework
 
-# Markit: Document to Markdown Converter
-
-[![Hugging Face Space](https://img.shields.io/badge/🤗%20Hugging%20Face-Space-blue)](https://huggingface.co/spaces/Ansemin101/Markit_v2)
+---
 
 **Author: Anse Min** | [GitHub](https://github.com/ansemin) | [LinkedIn](https://www.linkedin.com/in/ansemin/)
 
-## Project Links
-- **GitHub Repository**: [github.com/ansemin/Markit_v2](https://github.com/ansemin/Markit_v2)
-- **Hugging Face Space**: [huggingface.co/spaces/Ansemin101/Markit_v2](https://huggingface.co/spaces/Ansemin101/Markit_v2)
-
-## Overview
-Markit is a powerful tool that converts various document formats (PDF, DOCX, images, etc.) to Markdown format. It uses different parsing engines and OCR methods to extract text from documents and convert them to clean, readable Markdown formats.
-
-## Key Features
-- **Multiple Document Formats**: Convert PDFs, Word documents, images, and other document formats
-- **Versatile Output Formats**: Export to Markdown, JSON, plain text, or document tags format
-- **Advanced Parsing Engines**:
-  - **MarkItDown**: Comprehensive document conversion (PDFs, Office docs, images, audio, etc.)
-  - **Docling**: Advanced PDF understanding with table structure, layout analysis, and multiple OCR engines
-  - **Gemini Flash**: AI-powered conversion using Google's Gemini API
-  - **GOT-OCR**: State-of-the-art OCR model for images (JPG/PNG only) with plain text and formatted text options
-  - **Mistral OCR**: Advanced OCR using Mistral's Pixtral model for image-to-text conversion
-- **OCR Integration**: Extract text from images and scanned documents using Tesseract OCR
-- **Interactive UI**: User-friendly Gradio interface with page navigation for large documents
-- **AI-Powered Chat**: Interact with your documents using AI to ask questions about content
-- **ZeroGPU Support**: Optimized for Hugging Face Spaces with Stateless GPU environments
-
-## System Architecture
-
-The application is built with a clean, layered architecture following modern software engineering principles:
-
-### 🏗️ **Core Architecture Components:**
-- **Entry Point** (`app.py`): HF Spaces-compatible application launcher with environment setup
-- **Configuration Layer** (`src/core/config.py`): Centralized configuration management with validation
-- **Service Layer** (`src/services/`): Business logic for document processing and external services
-- **Core Engine** (`src/core/`): Document conversion workflows and utilities
-- **Parser Registry** (`src/parsers/`): Extensible parser system with standardized interfaces
-- **UI Layer** (`src/ui/`): Gradio-based web interface with enhanced error handling
-
-### 🎯 **Key Architectural Features:**
-- **Separation of Concerns**: Clean boundaries between UI, business logic, and core utilities
-- **Centralized Configuration**: All settings, API keys, and validation in one place
-- **Custom Exception Hierarchy**: Proper error handling with user-friendly messages
-- **Plugin Architecture**: Easy addition of new document parsers
-- **HF Spaces Optimized**: Maintains compatibility with Hugging Face deployment requirements
-
-## Installation
-
-### For Local Development
-1. Clone the repository
-2. Install dependencies:
-   ```bash
-   pip install -r requirements.txt
-   ```
-3. Install Tesseract OCR (required for OCR functionality):
-   - Windows: Download and install from [GitHub](https://github.com/UB-Mannheim/tesseract/wiki)
-   - Linux: `sudo apt-get install tesseract-ocr libtesseract-dev`
-   - macOS: `brew install tesseract`
-
-4. Run the application:
-   ```bash
-   python app.py
-   ```
-
-### API Keys Setup
-
-#### Gemini Flash Parser
-To use the Gemini Flash parser, you need to:
-1. Install the Google Generative AI client: `pip install google-genai`
-2. Set the API key environment variable:
-   ```bash
-   # On Windows
-   set GOOGLE_API_KEY=your_api_key_here
-   
-   # On Linux/Mac
-   export GOOGLE_API_KEY=your_api_key_here
-   ```
-3. Alternatively, create a `.env` file in the project root with:
-   ```
-   GOOGLE_API_KEY=your_api_key_here
-   ```
-4. Get your Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey)
-
-#### GOT-OCR Parser
-The GOT-OCR parser requires:
-1. CUDA-capable GPU with sufficient memory
-2. The following dependencies will be installed automatically:
-   ```bash
-   torch
-   torchvision
-   git+https://github.com/huggingface/transformers.git@main  # Latest transformers from GitHub
-   accelerate
-   verovio
-   numpy==1.26.3  # Specific version required
-   opencv-python
-   ```
-3. Note that GOT-OCR only supports JPG and PNG image formats
-4. In HF Spaces, the integration with ZeroGPU is automatic and optimized for Stateless GPU environments
-
-## Deploying to Hugging Face Spaces
-
-### Environment Configuration
-1. Go to your Space settings: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME/settings`
-2. Add the following repository secrets:
-   - Name: `GOOGLE_API_KEY`
-   - Value: Your Gemini API key
-
-### Space Configuration
-Ensure your Hugging Face Space configuration includes:
-```yaml
-build:
-  dockerfile: Dockerfile
-  python_version: "3.10" 
-  system_packages:
-    - "tesseract-ocr"
-    - "libtesseract-dev"
-```
+**Project Links:**
+- [GitHub Repository](https://github.com/ansemin/Markit_v2)
+- [Hugging Face Space](https://huggingface.co/spaces/Ansemin101/Markit_v2)
 
-## How to Use
-
-### Document Conversion
-1. Upload your document using the file uploader
-2. Select a parser provider:
-   - **MarkItDown**: Best for comprehensive document conversion (supports PDFs, Office docs, images, audio, etc.)
-   - **Docling**: Best for advanced PDF understanding with table structure recognition and layout analysis
-   - **Gemini Flash**: Best for AI-powered conversions (requires API key)
-   - **GOT-OCR**: Best for high-quality OCR on images (JPG/PNG only)
-   - **Mistral OCR**: Advanced OCR using Mistral's Pixtral model (requires API key)
-3. Choose an OCR option based on your selected parser:
-   - **None**: No OCR processing (for documents with selectable text)
-   - **Tesseract**: Basic OCR using Tesseract
-   - **Advanced**: Enhanced OCR with layout preservation (available with specific parsers)
-   - **Plain Text**: For GOT-OCR, extracts raw text without formatting
-   - **Formatted Text**: For GOT-OCR, preserves formatting and converts to Markdown
-4. Select your desired output format:
-   - **Markdown**: Clean, readable markdown format
-   - **JSON**: Structured data representation
-   - **Text**: Plain text extraction
-   - **Document Tags**: XML-like structure tags
-5. Click "Convert" to process your document
-6. Navigate through pages using the navigation buttons for multi-page documents
-7. Download the converted content in your selected format
-
-## Configuration & Error Handling
-
-### 🔧 **Automatic Configuration:**
-The application includes intelligent configuration management that:
-- Validates API keys and reports availability at startup
-- Checks for required dependencies and installs them automatically
-- Provides helpful warnings for missing optional components
-- Reports which parsers are available based on current configuration
-
-### 🛡️ **Enhanced Error Handling:**
-- **User-Friendly Messages**: Clear error descriptions instead of technical stack traces
-- **File Validation**: Automatic checking of file size and format compatibility
-- **Parser Availability**: Real-time detection of which parsers can be used
-- **Graceful Degradation**: Application continues working even if some parsers are unavailable
-
-## Troubleshooting
-
-### OCR Issues
-- Ensure Tesseract is properly installed and in your system PATH
-- Check the TESSDATA_PREFIX environment variable is set correctly
-- Verify language files are available in the tessdata directory
-
-### Gemini Flash Parser Issues
-- Confirm your API key is set correctly as an environment variable
-- Check for API usage limits or restrictions
-- Verify the document format is supported by the Gemini API
-
-### GOT-OCR Parser Issues
-- Ensure you have a CUDA-capable GPU with sufficient memory
-- Verify that all required dependencies are installed correctly
-- Remember that GOT-OCR only supports JPG and PNG image formats
-- If you encounter CUDA out-of-memory errors, try using a smaller image
-- In Hugging Face Spaces with Stateless GPU, ensure the `spaces` module is imported before any CUDA initialization
-- If you see errors about "CUDA must not be initialized in the main process", verify the import order in your app.py
-- If you encounter "cannot pickle '_thread.lock' object" errors, this indicates thread locks are being passed to the GPU function
-- The GOT-OCR parser has been optimized for ZeroGPU in Stateless GPU environments with proper serialization handling
-- For local development, the parser will fall back to CPU processing if GPU is not available
-
-### General Issues
-- Check the console logs for error messages
-- Ensure all dependencies are installed correctly
-- For large documents, try processing fewer pages at a time
 
 ## Development Guide
 
@@ -450,7 +316,7 @@ markit_v2/
 │   │   ├── docling_parser.py # 🆕 Docling parser with advanced PDF understanding
 │   │   ├── got_ocr_parser.py # GOT-OCR parser for images
 │   │   ├── mistral_ocr_parser.py # 🆕 Mistral OCR parser
-│   │   └── gemini_flash_parser.py # Gemini Flash parser
+│   │   └── gemini_flash_parser.py # 🆕 Enhanced Gemini Flash parser with multi-document processing
 │   ├── rag/                # 🆕 RAG (Retrieval-Augmented Generation) system
 │   │   ├── __init__.py     # Package initialization
 │   │   ├── embeddings.py   # OpenAI embedding model management

src/core/config.py

@@ -139,11 +139,20 @@ class AppConfig:
     allowed_extensions: tuple = (".pdf", ".png", ".jpg", ".jpeg", ".tiff", ".bmp", ".webp", ".tex", ".xlsx", ".docx", ".pptx", ".html", ".xhtml", ".md", ".csv")
     temp_dir: str = "./temp"
     
+    # Multi-document batch processing settings
+    max_batch_files: int = 5
+    max_batch_size: int = 20 * 1024 * 1024  # 20MB combined
+    batch_processing_types: tuple = ("combined", "individual", "summary", "comparison")
+    
     def __post_init__(self):
         """Load application configuration from environment variables."""
         self.debug = os.getenv("DEBUG", "false").lower() == "true"
         self.max_file_size = int(os.getenv("MAX_FILE_SIZE", self.max_file_size))
         self.temp_dir = os.getenv("TEMP_DIR", self.temp_dir)
+        
+        # Load batch processing configuration
+        self.max_batch_files = int(os.getenv("MAX_BATCH_FILES", self.max_batch_files))
+        self.max_batch_size = int(os.getenv("MAX_BATCH_SIZE", self.max_batch_size))
 
 
 class Config:

src/parsers/gemini_flash_parser.py

@@ -111,6 +111,225 @@ class GeminiFlashParser(DocumentParser):
             print(error_message)
             return f"# Error\n\n{error_message}\n\nPlease check your API key and try again."
     
+    def parse_multiple(self, file_paths: List[Union[str, Path]], processing_type: str = "combined", original_filenames: Optional[List[str]] = None, **kwargs) -> str:
+        """Parse multiple documents using Gemini Flash 2.0."""
+        if not GEMINI_AVAILABLE:
+            raise ImportError(
+                "The Google Gemini API client is not installed. "
+                "Please install it with 'pip install google-genai'."
+            )
+        
+        if not api_key:
+            raise ValueError(
+                "GOOGLE_API_KEY environment variable is not set. "
+                "Please set it to your Gemini API key."
+            )
+        
+        try:
+            # Convert to Path objects and validate
+            path_objects = [Path(fp) for fp in file_paths]
+            self._validate_batch_files(path_objects)
+            
+            # Check for cancellation
+            if self._check_cancellation():
+                return "Conversion cancelled."
+            
+            # Create client
+            client = genai.Client(api_key=api_key)
+            
+            # Create contents for API call
+            contents = self._create_batch_contents(path_objects, processing_type, original_filenames)
+            
+            # Check for cancellation before API call
+            if self._check_cancellation():
+                return "Conversion cancelled."
+            
+            # Generate the response
+            response = client.models.generate_content(
+                model=config.model.gemini_model,
+                contents=contents,
+                config={
+                    "temperature": config.model.temperature,
+                    "top_p": 0.95,
+                    "top_k": 40,
+                    "max_output_tokens": config.model.max_tokens,
+                }
+            )
+            
+            # Format the output based on processing type
+            formatted_output = self._format_batch_output(response.text, path_objects, processing_type, original_filenames)
+            
+            return formatted_output
+            
+        except Exception as e:
+            error_message = f"Error parsing multiple documents with Gemini Flash: {str(e)}"
+            print(error_message)
+            return f"# Error\n\n{error_message}\n\nPlease check your API key and try again."
+    
+    def _validate_batch_files(self, file_paths: List[Path]) -> None:
+        """Validate batch of files for multi-document processing."""
+        # Check file count limit
+        if len(file_paths) == 0:
+            raise ValueError("No files provided for processing")
+        if len(file_paths) > 5:
+            raise ValueError("Maximum 5 files allowed for batch processing")
+        
+        # Check individual files and calculate total size
+        total_size = 0
+        for file_path in file_paths:
+            if not file_path.exists():
+                raise ValueError(f"File not found: {file_path}")
+            
+            file_size = file_path.stat().st_size
+            total_size += file_size
+            
+            # Check individual file size (reasonable limit per file)
+            if file_size > 10 * 1024 * 1024:  # 10MB per file
+                raise ValueError(f"Individual file size exceeds 10MB: {file_path.name}")
+        
+        # Check combined size limit
+        if total_size > 20 * 1024 * 1024:  # 20MB total
+            raise ValueError(f"Combined file size ({total_size / (1024*1024):.1f}MB) exceeds 20MB limit")
+        
+        # Validate file types
+        for file_path in file_paths:
+            file_extension = file_path.suffix.lower()
+            if self._get_mime_type(file_extension) == "application/octet-stream":
+                raise ValueError(f"Unsupported file type: {file_path.name}")
+    
+    def _create_batch_contents(self, file_paths: List[Path], processing_type: str, original_filenames: Optional[List[str]] = None) -> List[Any]:
+        """Create contents list for batch API call."""
+        # Create the prompt based on processing type
+        prompt = self._create_batch_prompt(file_paths, processing_type, original_filenames)
+        
+        # Start with the prompt
+        contents = [prompt]
+        
+        # Add each file as a content part
+        for file_path in file_paths:
+            file_content = file_path.read_bytes()
+            mime_type = self._get_mime_type(file_path.suffix.lower())
+            
+            contents.append(
+                genai.types.Part.from_bytes(
+                    data=file_content,
+                    mime_type=mime_type
+                )
+            )
+        
+        return contents
+    
+    def _create_batch_prompt(self, file_paths: List[Path], processing_type: str, original_filenames: Optional[List[str]] = None) -> str:
+        """Create appropriate prompt for batch processing."""
+        # Use original filenames if provided, otherwise use temp file names
+        if original_filenames:
+            file_names = original_filenames
+        else:
+            file_names = [fp.name for fp in file_paths]
+        file_list = "\n".join([f"- {name}" for name in file_names])
+        
+        base_prompt = f"""I will provide you with {len(file_paths)} documents to process:
+{file_list}
+
+"""
+        
+        if processing_type == "combined":
+            return base_prompt + """Please convert all documents to a single, cohesive markdown document. 
+Merge the content logically, remove duplicate information, and create a unified structure with clear headings.
+Preserve important formatting, tables, lists, and structure from all documents.
+For images, include brief descriptions in markdown image syntax.
+Return only the combined markdown content, no other text."""
+            
+        elif processing_type == "individual":
+            return base_prompt + """Please convert each document to markdown format and present them as separate sections.
+For each document, create a clear section header with the document name.
+Preserve the structure, headings, lists, tables, and formatting within each section.
+For images, include brief descriptions in markdown image syntax.
+Return the content in this format:
+
+# Document 1: [filename]
+[converted content]
+
+# Document 2: [filename]  
+[converted content]
+
+Return only the markdown content, no other text."""
+            
+        elif processing_type == "summary":
+            return base_prompt + """Please create a comprehensive analysis with two parts:
+
+1. EXECUTIVE SUMMARY: A concise overview summarizing the key points from all documents
+2. DETAILED SECTIONS: Individual converted sections for each document
+
+Structure the output as:
+
+# Executive Summary
+[Brief summary of key findings and themes across all documents]
+
+# Detailed Analysis
+
+## Document 1: [filename]
+[converted content]
+
+## Document 2: [filename]
+[converted content]
+
+Preserve formatting, tables, lists, and structure throughout.
+For images, include brief descriptions in markdown image syntax.
+Return only the markdown content, no other text."""
+            
+        elif processing_type == "comparison":
+            return base_prompt + """Please create a comparative analysis of these documents:
+
+1. Create a comparison table highlighting key differences and similarities
+2. Provide individual document summaries
+3. Include a section on cross-document insights
+
+Structure the output as:
+
+# Document Comparison Analysis
+
+## Comparison Table
+| Aspect | Document 1 | Document 2 | Document 3 | ... |
+|--------|------------|------------|------------|-----|
+| [Key aspects found across documents] | | | | |
+
+## Individual Document Summaries
+
+### Document 1: [filename]
+[Key points and content summary]
+
+### Document 2: [filename]
+[Key points and content summary]
+
+## Cross-Document Insights
+[Analysis of patterns, contradictions, or complementary information across documents]
+
+Preserve important formatting and structure.
+For images, include brief descriptions in markdown image syntax.
+Return only the markdown content, no other text."""
+        
+        else:
+            # Fallback to combined
+            return self._create_batch_prompt(file_paths, "combined")
+    
+    def _format_batch_output(self, response_text: str, file_paths: List[Path], processing_type: str, original_filenames: Optional[List[str]] = None) -> str:
+        """Format the batch processing output."""
+        # Add metadata header using original filenames if provided
+        if original_filenames:
+            file_names = original_filenames
+        else:
+            file_names = [fp.name for fp in file_paths]
+        
+        header = f"""<!-- Multi-Document Processing Results -->
+<!-- Processing Type: {processing_type} -->
+<!-- Files Processed: {len(file_paths)} -->
+<!-- File Names: {', '.join(file_names)} -->
+
+"""
+        
+        return header + response_text
+    
     def _get_mime_type(self, file_extension: str) -> str:
         """Get the MIME type for a file extension."""
         mime_types = {

src/services/document_service.py

@@ -7,7 +7,7 @@ import time
 import os
 import threading
 from pathlib import Path
-from typing import Optional, Tuple, Any
+from typing import Optional, Tuple, Any, List
 
 from src.core.config import config
 from src.core.exceptions import (
@@ -269,4 +269,248 @@ class DocumentService:
             if self._check_cancellation() and output_path:
                 self._safe_delete_file(output_path)
             
-            self._conversion_in_progress = False
+            self._conversion_in_progress = False
+    
+    def convert_documents(
+        self, 
+        file_paths: List[str], 
+        parser_name: str, 
+        ocr_method_name: str, 
+        output_format: str,
+        processing_type: str = "combined"
+    ) -> Tuple[str, Optional[str]]:
+        """
+        Unified method to convert single or multiple documents.
+        
+        Args:
+            file_paths: List of paths to input files (can be single file)
+            parser_name: Name of the parser to use
+            ocr_method_name: Name of the OCR method to use
+            output_format: Output format (Markdown, JSON, Text, Document Tags)
+            processing_type: Type of multi-document processing (combined, individual, summary, comparison)
+            
+        Returns:
+            Tuple of (content, output_file_path)
+            
+        Raises:
+            DocumentProcessingError: For general processing errors
+            FileSizeLimitError: When file(s) are too large
+            UnsupportedFileTypeError: For unsupported file types
+            ConversionError: When conversion fails or is cancelled
+        """
+        if not file_paths:
+            raise DocumentProcessingError("No files provided")
+        
+        # Route to appropriate processing method
+        if len(file_paths) == 1:
+            # Single file processing - use existing method
+            return self.convert_document(
+                file_paths[0], parser_name, ocr_method_name, output_format
+            )
+        else:
+            # Multi-file processing - use new batch method
+            return self._convert_multiple_documents(
+                file_paths, parser_name, ocr_method_name, output_format, processing_type
+            )
+    
+    def _convert_multiple_documents(
+        self, 
+        file_paths: List[str], 
+        parser_name: str, 
+        ocr_method_name: str, 
+        output_format: str,
+        processing_type: str
+    ) -> Tuple[str, Optional[str]]:
+        """
+        Convert multiple documents using batch processing.
+        
+        Args:
+            file_paths: List of paths to input files
+            parser_name: Name of the parser to use
+            ocr_method_name: Name of the OCR method to use
+            output_format: Output format (Markdown, JSON, Text, Document Tags)
+            processing_type: Type of multi-document processing
+            
+        Returns:
+            Tuple of (content, output_file_path)
+        """
+        self._conversion_in_progress = True
+        temp_inputs = []
+        output_path = None
+        self._original_file_paths = file_paths  # Store original paths for filename reference
+        
+        try:
+            # Validate all files first
+            for file_path in file_paths:
+                self._validate_file(file_path)
+            
+            if self._check_cancellation():
+                raise ConversionError("Conversion cancelled")
+            
+            # Create temporary files with English names
+            for original_path in file_paths:
+                temp_path = self._create_temp_file(original_path)
+                temp_inputs.append(temp_path)
+                
+                if self._check_cancellation():
+                    raise ConversionError("Conversion cancelled during file preparation")
+            
+            # Process documents using parser factory with multi-document support
+            start_time = time.time()
+            content = self._process_multiple_with_parser(
+                temp_inputs, parser_name, ocr_method_name, output_format, processing_type
+            )
+            
+            if content == "Conversion cancelled.":
+                raise ConversionError("Conversion cancelled by parser")
+            
+            duration = time.time() - start_time
+            logging.info(f"Multiple documents processed in {duration:.2f} seconds")
+            
+            if self._check_cancellation():
+                raise ConversionError("Conversion cancelled")
+            
+            # Create output file with batch naming
+            output_path = self._create_batch_output_file(
+                content, output_format, file_paths, processing_type
+            )
+            
+            return content, output_path
+            
+        except (DocumentProcessingError, FileSizeLimitError, UnsupportedFileTypeError, ConversionError):
+            # Re-raise our custom exceptions
+            for temp_path in temp_inputs:
+                self._safe_delete_file(temp_path)
+            self._safe_delete_file(output_path)
+            raise
+        except Exception as e:
+            # Wrap unexpected exceptions
+            for temp_path in temp_inputs:
+                self._safe_delete_file(temp_path)
+            self._safe_delete_file(output_path)
+            raise DocumentProcessingError(f"Unexpected error during batch conversion: {str(e)}")
+        finally:
+            # Clean up temp input files
+            for temp_path in temp_inputs:
+                self._safe_delete_file(temp_path)
+            
+            # Clean up output file if cancelled
+            if self._check_cancellation() and output_path:
+                self._safe_delete_file(output_path)
+            
+            self._conversion_in_progress = False
+    
+    def _process_multiple_with_parser(
+        self, 
+        temp_file_paths: List[str], 
+        parser_name: str, 
+        ocr_method_name: str, 
+        output_format: str,
+        processing_type: str
+    ) -> str:
+        """Process multiple documents using the parser factory."""
+        try:
+            # Get parser instance
+            from src.parsers.parser_registry import ParserRegistry
+            parser_class = ParserRegistry.get_parser_class(parser_name)
+            
+            if not parser_class:
+                raise DocumentProcessingError(f"Parser '{parser_name}' not found")
+            
+            parser_instance = parser_class()
+            parser_instance.set_cancellation_flag(self._cancellation_flag)
+            
+            # Check if parser supports multi-document processing
+            if hasattr(parser_instance, 'parse_multiple'):
+                # Use multi-document parsing with original filenames for reference
+                return parser_instance.parse_multiple(
+                    file_paths=temp_file_paths,
+                    processing_type=processing_type,
+                    ocr_method=ocr_method_name,
+                    output_format=output_format.lower(),
+                    original_filenames=[Path(fp).name for fp in self._original_file_paths]
+                )
+            else:
+                # Fallback: process individually and combine
+                results = []
+                for i, file_path in enumerate(temp_file_paths):
+                    if self._check_cancellation():
+                        return "Conversion cancelled."
+                    
+                    result = parser_instance.parse(
+                        file_path=file_path,
+                        ocr_method=ocr_method_name
+                    )
+                    
+                    # Add section header for individual results using original filename
+                    original_filename = Path(self._original_file_paths[i]).name
+                    results.append(f"# Document {i+1}: {original_filename}\n\n{result}")
+                
+                return "\n\n---\n\n".join(results)
+                
+        except Exception as e:
+            raise DocumentProcessingError(f"Error processing multiple documents: {str(e)}")
+    
+    def _create_batch_output_file(
+        self, 
+        content: str, 
+        output_format: str, 
+        original_file_paths: List[str],
+        processing_type: str
+    ) -> str:
+        """Create output file for batch processing with descriptive naming."""
+        # Determine file extension
+        format_extensions = {
+            "markdown": ".md",
+            "json": ".json", 
+            "text": ".txt",
+            "document tags": ".doctags"
+        }
+        ext = format_extensions.get(output_format.lower(), ".txt")
+        
+        if self._check_cancellation():
+            raise ConversionError("Conversion cancelled before output file creation")
+        
+        # Create descriptive filename for batch processing
+        file_count = len(original_file_paths)
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        
+        if processing_type == "combined":
+            filename = f"Combined_{file_count}_Documents_{timestamp}{ext}"
+        elif processing_type == "individual":
+            filename = f"Individual_Sections_{file_count}_Files_{timestamp}{ext}"
+        elif processing_type == "summary":
+            filename = f"Summary_Analysis_{file_count}_Files_{timestamp}{ext}"
+        elif processing_type == "comparison":
+            filename = f"Comparison_Analysis_{file_count}_Files_{timestamp}{ext}"
+        else:
+            filename = f"Batch_Processing_{file_count}_Files_{timestamp}{ext}"
+        
+        # Create output file in temp directory
+        temp_dir = tempfile.gettempdir()
+        tmp_path = os.path.join(temp_dir, filename)
+        
+        # Handle filename conflicts
+        counter = 1
+        base_path = tmp_path
+        while os.path.exists(tmp_path):
+            name_part = filename.replace(ext, f"_{counter}{ext}")
+            tmp_path = os.path.join(temp_dir, name_part)
+            counter += 1
+        
+        # Write content to file
+        try:
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                # Write in chunks with cancellation checks
+                chunk_size = 10000  # characters
+                for i in range(0, len(content), chunk_size):
+                    if self._check_cancellation():
+                        self._safe_delete_file(tmp_path)
+                        raise ConversionError("Conversion cancelled during output file writing")
+                    
+                    f.write(content[i:i+chunk_size])
+        except Exception as e:
+            self._safe_delete_file(tmp_path)
+            raise ConversionError(f"Failed to write batch output file: {str(e)}")
+        
+        return tmp_path

src/ui/ui.py

@@ -45,6 +45,51 @@ def monitor_cancellation():
         time.sleep(0.1)  # Check every 100ms
     logger.info("Cancellation monitor thread ending")
 
+def update_ui_for_file_count(files):
+    """Update UI components based on the number of files uploaded."""
+    if not files or len(files) == 0:
+        return (
+            gr.update(visible=False),  # processing_type_selector
+            "<div style='color: #666; font-style: italic;'>Upload documents to begin</div>"  # file_status_text
+        )
+    
+    if len(files) == 1:
+        file_name = files[0].name if hasattr(files[0], 'name') else str(files[0])
+        return (
+            gr.update(visible=False),  # processing_type_selector (hidden for single file)
+            f"<div style='color: #2563eb; font-weight: 500;'>📄 Single document: {file_name}</div>"
+        )
+    else:
+        # Calculate total size for validation display
+        total_size = 0
+        try:
+            for file in files:
+                if hasattr(file, 'size'):
+                    total_size += file.size
+                elif hasattr(file, 'name'):
+                    # For file paths, get size from filesystem
+                    total_size += Path(file.name).stat().st_size
+        except:
+            pass  # Size calculation is optional for display
+        
+        size_display = f" ({total_size / (1024*1024):.1f}MB)" if total_size > 0 else ""
+        
+        # Check if within limits
+        if len(files) > 5:
+            status_color = "#dc2626"  # red
+            status_text = f"⚠️ Too many files: {len(files)}/5 (max 5 files allowed)"
+        elif total_size > 20 * 1024 * 1024:  # 20MB
+            status_color = "#dc2626"  # red
+            status_text = f"⚠️ Files too large{size_display} (max 20MB combined)"
+        else:
+            status_color = "#059669"  # green
+            status_text = f"📂 Batch mode: {len(files)} files{size_display}"
+        
+        return (
+            gr.update(visible=True),  # processing_type_selector (visible for multiple files)
+            f"<div style='color: {status_color}; font-weight: 500;'>{status_text}</div>"
+        )
+
 def validate_file_for_parser(file_path, parser_name):
     """Validate if the file type is supported by the selected parser."""
     if not file_path:
@@ -112,8 +157,48 @@ def run_conversion_thread(file_path, parser_name, ocr_method_name, output_format
     
     return thread, results
 
-def handle_convert(file_path, parser_name, ocr_method_name, output_format, is_cancelled):
-    """Handle file conversion."""
+def run_conversion_thread_multi(file_paths, parser_name, ocr_method_name, output_format, processing_type):
+    """Run the conversion in a separate thread for multiple files."""
+    import threading
+    from src.services.document_service import DocumentService
+    
+    # Results will be shared between threads
+    results = {"content": None, "download_file": None, "error": None}
+    
+    def conversion_worker():
+        try:
+            logger.info(f"Starting multi-file conversion thread for {len(file_paths)} files")
+            
+            # Use the new document service unified method
+            document_service = DocumentService()
+            document_service.set_cancellation_flag(conversion_cancelled)
+            
+            # Call the unified convert_documents method
+            content, output_file = document_service.convert_documents(
+                file_paths=file_paths,
+                parser_name=parser_name,
+                ocr_method_name=ocr_method_name,
+                output_format=output_format,
+                processing_type=processing_type
+            )
+            
+            logger.info(f"Multi-file conversion completed successfully for {len(file_paths)} files")
+            results["content"] = content
+            results["download_file"] = output_file
+            
+        except Exception as e:
+            logger.error(f"Error during multi-file conversion: {str(e)}")
+            results["error"] = str(e)
+    
+    # Create and start the thread
+    thread = threading.Thread(target=conversion_worker)
+    thread.daemon = True
+    thread.start()
+    
+    return thread, results
+
+def handle_convert(files, parser_name, ocr_method_name, output_format, processing_type, is_cancelled):
+    """Handle file conversion for single or multiple files."""
     global conversion_cancelled
     
     # Check if we should cancel before starting
@@ -121,16 +206,31 @@ def handle_convert(file_path, parser_name, ocr_method_name, output_format, is_ca
         logger.info("Conversion cancelled before starting")
         return "Conversion cancelled.", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
     
-    # Validate file type for the selected parser
-    is_valid, error_msg = validate_file_for_parser(file_path, parser_name)
-    if not is_valid:
-        logger.error(f"File validation error: {error_msg}")
+    # Validate files input
+    if not files or len(files) == 0:
+        error_msg = "No files uploaded. Please upload at least one document."
+        logger.error(error_msg)
         return f"Error: {error_msg}", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
     
-    logger.info("Starting conversion with cancellation flag cleared")
+    # Convert Gradio file objects to file paths
+    file_paths = []
+    for file in files:
+        if hasattr(file, 'name'):
+            file_paths.append(file.name)
+        else:
+            file_paths.append(str(file))
+    
+    # Validate file types for the selected parser
+    for file_path in file_paths:
+        is_valid, error_msg = validate_file_for_parser(file_path, parser_name)
+        if not is_valid:
+            logger.error(f"File validation error: {error_msg}")
+            return f"Error: {error_msg}", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+    
+    logger.info(f"Starting conversion of {len(file_paths)} file(s) with cancellation flag cleared")
     
     # Start the conversion in a separate thread
-    thread, results = run_conversion_thread(file_path, parser_name, ocr_method_name, output_format)
+    thread, results = run_conversion_thread_multi(file_paths, parser_name, ocr_method_name, output_format, processing_type)
     
     # Start the monitoring thread
     monitor_thread = threading.Thread(target=monitor_cancellation)
@@ -763,8 +863,27 @@ def create_ui():
                 # State to store the output format (fixed to Markdown)
                 output_format_state = gr.State("Markdown")
 
-                # File input first
-                file_input = gr.File(label="Upload Document", type="filepath")
+                # Multi-file input (supports single and multiple files)
+                files_input = gr.Files(
+                    label="Upload Document(s) - Single file or up to 5 files (20MB max combined)",
+                    file_count="multiple",
+                    file_types=[".pdf", ".png", ".jpg", ".jpeg", ".tiff", ".bmp", ".webp", ".docx", ".doc", ".pptx", ".ppt", ".xlsx", ".xls", ".txt", ".md", ".html", ".htm"]
+                )
+                
+                # Processing type selector (visible only for multiple files)
+                processing_type_selector = gr.Radio(
+                    choices=["combined", "individual", "summary", "comparison"],
+                    value="combined",
+                    label="Multi-Document Processing Type",
+                    info="How to process multiple documents together",
+                    visible=False
+                )
+                
+                # Status text to show file count and processing mode
+                file_status_text = gr.HTML(
+                    value="<div style='color: #666; font-style: italic;'>Upload documents to begin</div>",
+                    label=""
+                )
                 
                 # Provider and OCR options below the file input
                 with gr.Row(elem_classes=["provider-options-row"]):
@@ -805,6 +924,14 @@ def create_ui():
                     cancel_button = gr.Button("Cancel", variant="stop", visible=False)
 
                 # Event handlers for document converter
+                
+                # Update UI when files are uploaded/changed
+                files_input.change(
+                    fn=update_ui_for_file_count,
+                    inputs=[files_input],
+                    outputs=[processing_type_selector, file_status_text]
+                )
+                
                 provider_dropdown.change(
                     lambda p: gr.Dropdown(
                         choices=["Plain Text", "Formatted Text"] if "GOT-OCR" in p else ParserRegistry.get_ocr_options(p),
@@ -845,7 +972,7 @@ def create_ui():
                     queue=False  # Execute immediately
                 ).then(
                     fn=handle_convert,
-                    inputs=[file_input, provider_dropdown, ocr_dropdown, output_format_state, cancel_requested],
+                    inputs=[files_input, provider_dropdown, ocr_dropdown, output_format_state, processing_type_selector, cancel_requested],
                     outputs=[file_display, file_download, convert_button, cancel_button, conversion_thread]
                 )