Update app.py

app.py

@@ -2,10 +2,13 @@ import gradio as gr
 import json
 import tempfile
 import os
-from typing import List, Optional, Literal, Tuple, Union
+import zipfile
+import shutil
+from typing import List, Optional, Literal, Tuple, Union, Dict
 from PIL import Image
 import requests
 from io import BytesIO
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 import spaces
 from pathlib import Path
@@ -144,13 +147,14 @@ PIPELINE_CONFIGS = {
 }
 
 
-def handle_image_input(image_path: Union[str, None], progress: gr.Progress = None) -> str:
+def handle_image_input(image_path: Union[str, None], progress: gr.Progress = None, desc_prefix: str = "") -> str:
     """
     Handle image input from various sources (local file, URL, or uploaded file).
     
     Args:
         image_path: Path to image file or URL
         progress: Progress tracker for UI updates
+        desc_prefix: Prefix for progress descriptions
         
     Returns:
         Local file path to the image
@@ -159,13 +163,13 @@ def handle_image_input(image_path: Union[str, None], progress: gr.Progress = Non
         raise ValueError("No image provided. Please upload an image or provide a URL.")
     
     if progress:
-        progress(0.1, desc="Processing image input...")
+        progress(0.1, desc=f"{desc_prefix}Processing image input...")
     
     # If it's a URL, download the image
     if isinstance(image_path, str) and (image_path.startswith("http://") or image_path.startswith("https://")):
         try:
             if progress:
-                progress(0.2, desc="Downloading image from URL...")
+                progress(0.2, desc=f"{desc_prefix}Downloading image from URL...")
             response = requests.get(image_path, timeout=30)
             response.raise_for_status()
             
@@ -192,18 +196,49 @@ def handle_image_input(image_path: Union[str, None], progress: gr.Progress = Non
     return image_path
 
 
+def parse_image_input(image_input: Union[str, List[str], None]) -> List[str]:
+    """
+    Parse image input which can be a single path, multiple paths, or URLs separated by newlines.
+    
+    Args:
+        image_input: Single image path, list of paths, or newline-separated URLs/paths
+        
+    Returns:
+        List of image paths/URLs
+    """
+    if not image_input:
+        return []
+    
+    if isinstance(image_input, list):
+        return image_input
+    
+    if isinstance(image_input, str):
+        # Check if it's multiple URLs/paths separated by newlines
+        lines = image_input.strip().split('\n')
+        paths = []
+        for line in lines:
+            line = line.strip()
+            if line:  # Skip empty lines
+                paths.append(line)
+        return paths if paths else [image_input]
+    
+    return []
+
+
 @spaces.GPU
-def _process_htr_pipeline(
-    image_path: str, 
+def _process_htr_pipeline_batch(
+    image_paths: List[str], 
     document_type: FormatChoices, 
     custom_settings: Optional[str] = None,
     progress: gr.Progress = None
-) -> Collection:
-    """Process HTR pipeline and return the processed collection."""
+) -> Dict[str, Collection]:
+    """Process HTR pipeline for multiple images and return processed collections."""
+    
+    results = {}
+    temp_files = []
+    
+    total_images = len(image_paths)
     
-    # Handle image input
-    image_path = handle_image_input(image_path, progress)
-
     if custom_settings:
         try:
             config = json.loads(custom_settings)
@@ -211,79 +246,120 @@ def _process_htr_pipeline(
             raise ValueError("Invalid JSON in custom_settings parameter. Please check your JSON syntax.")
     else:
         config = PIPELINE_CONFIGS[document_type]
-
-    if progress:
-        progress(0.3, desc="Initializing HTR pipeline...")
     
-    collection = Collection([image_path])
+    # Initialize pipeline once for all images
     pipeline = Pipeline.from_config(config)
-
-    try:
-        # Track pipeline steps
-        total_steps = len(config.get("steps", []))
-        
-        if progress:
-            progress(0.4, desc=f"Running HTR pipeline with {total_steps} steps...")
-        
-        # Run the pipeline (we could add more granular progress here if the pipeline supports it)
-        processed_collection = pipeline.run(collection)
-        
-        if progress:
-            progress(0.9, desc="Pipeline complete, preparing results...")
-        
-        return processed_collection
-    except Exception as pipeline_error:
-        raise RuntimeError(f"Pipeline execution failed: {str(pipeline_error)}")
-    finally:
-        # Clean up temporary file if it was downloaded
-        if image_path and image_path.startswith(tempfile.gettempdir()):
-            try:
-                os.unlink(image_path)
-            except:
-                pass
+    
+    for idx, image_path in enumerate(image_paths):
+        try:
+            image_name = Path(image_path).stem if not image_path.startswith("http") else f"image_{idx+1}"
+            
+            if progress:
+                progress((idx + 0.2) / total_images, 
+                        desc=f"Processing image {idx+1}/{total_images}: {image_name}")
+            
+            # Handle image input
+            processed_path = handle_image_input(image_path, progress, 
+                                               desc_prefix=f"[{idx+1}/{total_images}] ")
+            
+            # Track temp files for cleanup
+            if processed_path.startswith(tempfile.gettempdir()):
+                temp_files.append(processed_path)
+            
+            if progress:
+                progress((idx + 0.5) / total_images, 
+                        desc=f"Running HTR on image {idx+1}/{total_images}: {image_name}")
+            
+            # Process with pipeline
+            collection = Collection([processed_path])
+            processed_collection = pipeline.run(collection)
+            
+            results[image_name] = processed_collection
+            
+            if progress:
+                progress((idx + 0.9) / total_images, 
+                        desc=f"Completed image {idx+1}/{total_images}: {image_name}")
+            
+        except Exception as e:
+            results[image_name] = f"Error: {str(e)}"
+            print(f"Error processing {image_path}: {str(e)}")
+    
+    # Cleanup temp files
+    for temp_file in temp_files:
+        try:
+            os.unlink(temp_file)
+        except:
+            pass
+    
+    if progress:
+        progress(1.0, desc=f"Completed processing {total_images} images!")
+    
+    return results
 
 
-def htr_text(
-    image_path: str,
+def htr_text_batch(
+    image_input: Union[str, List[str]],
     document_type: FormatChoices = "letter_swedish",
     custom_settings: Optional[str] = None,
+    return_format: str = "separate",  # "separate" or "combined"
     progress: gr.Progress = gr.Progress()
 ) -> str:
     """
-    Extract text from handwritten documents using HTR (Handwritten Text Recognition).
+    Extract text from multiple handwritten documents using HTR.
     
-    This tool processes historical handwritten documents and extracts the text content.
-    Supports various document layouts including letters and book spreads in English and Swedish.
+    This tool processes multiple historical handwritten documents and extracts text content from each.
+    You can provide multiple image paths/URLs separated by newlines, or upload multiple files.
     
     Args:
-        image_path: Path to the document image file or URL to download from
-        document_type: Type of document layout - choose based on your document's structure and language
+        image_input: Single image path/URL, multiple paths/URLs (newline-separated), or list of uploaded files
+        document_type: Type of document layout - choose based on your documents' structure and language
         custom_settings: Optional JSON configuration for advanced pipeline customization
+        return_format: "separate" to show each document's text separately, "combined" to merge all text
         
     Returns:
-        Extracted text from the handwritten document
+        Extracted text from all handwritten documents
     """
     try:
-        progress(0, desc="Starting HTR text extraction...")
+        progress(0, desc="Starting batch HTR text extraction...")
+        
+        # Parse input to get list of images
+        image_paths = parse_image_input(image_input)
+        
+        if not image_paths:
+            return "No images provided. Please upload images or provide URLs."
         
-        processed_collection = _process_htr_pipeline(
-            image_path, document_type, custom_settings, progress
+        progress(0.1, desc=f"Processing {len(image_paths)} images...")
+        
+        # Process all images
+        results = _process_htr_pipeline_batch(
+            image_paths, document_type, custom_settings, progress
         )
         
-        progress(0.95, desc="Extracting text from results...")
-        extracted_text = extract_text_from_collection(processed_collection)
+        # Extract text from results
+        all_texts = []
+        for image_name, collection in results.items():
+            if isinstance(collection, str):  # Error case
+                all_texts.append(f"=== {image_name} ===\n{collection}\n")
+            else:
+                text = extract_text_from_collection(collection)
+                if return_format == "separate":
+                    all_texts.append(f"=== {image_name} ===\n{text}\n")
+                else:
+                    all_texts.append(text)
+        
+        if return_format == "separate":
+            return "\n".join(all_texts)
+        else:
+            return "\n\n".join(all_texts)
         
-        progress(1.0, desc="Text extraction complete!")
-        return extracted_text
-
     except ValueError as e:
         return f"Input error: {str(e)}"
     except Exception as e:
-        return f"HTR text extraction failed: {str(e)}"
+        return f"Batch HTR text extraction failed: {str(e)}"
 
 
-def htrflow_file(
-    image_path: str,
+def htrflow_file_batch(
+    image_input: Union[str, List[str]],
     document_type: FormatChoices = "letter_swedish",
     output_format: FileChoices = DEFAULT_OUTPUT,
     custom_settings: Optional[str] = None,
@@ -291,120 +367,190 @@ def htrflow_file(
     progress: gr.Progress = gr.Progress()
 ) -> str:
     """
-    Process handwritten document and generate a formatted output file.
+    Process multiple handwritten documents and generate formatted output files.
     
-    This tool performs HTR on a document and exports the results in various formats
-    suitable for digital archiving, further processing, or integration with other systems.
+    This tool performs HTR on multiple documents and exports the results in various formats.
+    Returns a ZIP file containing all processed documents.
     
     Args:
-        image_path: Path to the document image file or URL to download from
+        image_input: Single image path/URL, multiple paths/URLs (newline-separated), or list of uploaded files
         document_type: Type of document layout - affects segmentation and reading order
         output_format: Desired output format (txt for plain text, alto/page for XML with coordinates, json for structured data)
         custom_settings: Optional JSON configuration for advanced pipeline customization
         server_name: Base URL of the server (used for generating download links)
         
     Returns:
-        Path to the generated file for download
+        Path to ZIP file containing all generated files
     """
     try:
-        progress(0, desc="Starting HTR file processing...")
+        progress(0, desc="Starting batch HTR file processing...")
         
-        original_filename = Path(image_path).stem if image_path else "output"
-
-        processed_collection = _process_htr_pipeline(
-            image_path, document_type, custom_settings, progress
+        # Parse input to get list of images
+        image_paths = parse_image_input(image_input)
+        
+        if not image_paths:
+            error_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
+            error_file.write("No images provided. Please upload images or provide URLs.")
+            error_file.close()
+            return error_file.name
+        
+        progress(0.1, desc=f"Processing {len(image_paths)} images...")
+        
+        # Process all images
+        results = _process_htr_pipeline_batch(
+            image_paths, document_type, custom_settings, progress
         )
-
-        progress(0.92, desc=f"Generating {output_format.upper()} file...")
         
+        progress(0.9, desc="Creating ZIP archive...")
+        
+        # Create temporary directory for output files
         temp_dir = Path(tempfile.mkdtemp())
-        export_dir = temp_dir / output_format
-        processed_collection.save(directory=str(export_dir), serializer=output_format)
-
-        output_file_path = None
-        for root, _, files in os.walk(export_dir):
-            for file in files:
-                old_path = os.path.join(root, file)
-                file_ext = Path(file).suffix
-                new_filename = (
-                    f"{original_filename}.{output_format}"
-                    if not file_ext
-                    else f"{original_filename}{file_ext}"
-                )
-                new_path = os.path.join(root, new_filename)
-                os.rename(old_path, new_path)
-                output_file_path = new_path
-                break
-
-        progress(1.0, desc="File generation complete!")
+        output_files = []
+        
+        for image_name, collection in results.items():
+            if isinstance(collection, str):  # Error case
+                # Write error to text file
+                error_file_path = temp_dir / f"{image_name}_error.txt"
+                with open(error_file_path, 'w') as f:
+                    f.write(collection)
+                output_files.append(error_file_path)
+            else:
+                # Save collection in requested format
+                export_dir = temp_dir / image_name
+                collection.save(directory=str(export_dir), serializer=output_format)
+                
+                # Find and rename the generated file
+                for root, _, files in os.walk(export_dir):
+                    for file in files:
+                        old_path = Path(root) / file
+                        file_ext = Path(file).suffix
+                        new_filename = (
+                            f"{image_name}.{output_format}"
+                            if not file_ext
+                            else f"{image_name}{file_ext}"
+                        )
+                        new_path = temp_dir / new_filename
+                        shutil.move(str(old_path), str(new_path))
+                        output_files.append(new_path)
+                        break
+        
+        # Create ZIP file
+        zip_path = temp_dir / f"htr_batch_{output_format}.zip"
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in output_files:
+                zipf.write(file_path, file_path.name)
+        
+        progress(1.0, desc=f"Batch processing complete! Processed {len(image_paths)} images.")
+        
+        return str(zip_path)
         
-        if output_file_path and os.path.exists(output_file_path):
-            return output_file_path
-        else:
-            return None
-
     except ValueError as e:
-        # Create an error file with the error message
         error_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
-        error_file.write(f"Error: {str(e)}")
+        error_file.write(f"Input error: {str(e)}")
         error_file.close()
         return error_file.name
     except Exception as e:
-        # Create an error file with the error message
         error_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
-        error_file.write(f"HTR file generation failed: {str(e)}")
+        error_file.write(f"Batch HTR file generation failed: {str(e)}")
         error_file.close()
         return error_file.name
 
 
-def htrflow_visualizer_with_progress(
-    image_path: str,
-    htr_document_path: str,
+def htrflow_visualizer_batch(
+    image_input: Union[str, List[str]],
+    htr_documents: Union[str, List[str]],
     server_name: str = "https://gabriel-htrflow-mcp.hf.space",
     progress: gr.Progress = gr.Progress()
 ) -> str:
     """
-    Create a visualization of HTR results overlaid on the original document.
+    Create visualizations for multiple HTR results overlaid on original documents.
     
-    This tool generates an annotated image showing detected text regions, reading order,
-    and recognized text overlaid on the original document image. Useful for quality control
-    and understanding the HTR process.
+    This tool generates annotated images showing detected text regions and recognized text
+    for multiple documents. Returns a ZIP file containing all visualization images.
     
     Args:
-        image_path: Path to the original document image file or URL
-        htr_document_path: Path to the HTR output file (ALTO or PAGE XML format)
+        image_input: Original document image paths/URLs (newline-separated if string)
+        htr_documents: HTR output files (ALTO/PAGE XML) - must match order of images
         server_name: Base URL of the server (used for generating download links)
         
     Returns:
-        Path to the generated visualization image for download
+        Path to ZIP file containing all visualization images
     """
     try:
-        progress(0, desc="Starting visualization generation...")
+        progress(0, desc="Starting batch visualization generation...")
+        
+        # Parse inputs
+        image_paths = parse_image_input(image_input)
+        htr_paths = parse_image_input(htr_documents) if isinstance(htr_documents, str) else htr_documents
+        
+        if not image_paths:
+            raise ValueError("No images provided")
+        
+        if not htr_paths:
+            raise ValueError("No HTR documents provided")
+        
+        if len(image_paths) != len(htr_paths):
+            raise ValueError(f"Number of images ({len(image_paths)}) doesn't match number of HTR documents ({len(htr_paths)})")
+        
+        progress(0.1, desc=f"Creating visualizations for {len(image_paths)} documents...")
+        
+        temp_dir = Path(tempfile.mkdtemp())
+        output_files = []
+        temp_files = []
+        
+        for idx, (image_path, htr_path) in enumerate(zip(image_paths, htr_paths)):
+            try:
+                image_name = Path(image_path).stem if not image_path.startswith("http") else f"image_{idx+1}"
+                
+                progress((idx + 0.3) / len(image_paths), 
+                        desc=f"Visualizing document {idx+1}/{len(image_paths)}: {image_name}")
+                
+                # Handle image input
+                processed_image = handle_image_input(image_path, progress, 
+                                                    desc_prefix=f"[{idx+1}/{len(image_paths)}] ")
+                if processed_image.startswith(tempfile.gettempdir()):
+                    temp_files.append(processed_image)
+                
+                # Generate visualization
+                viz_result = htrflow_visualizer(processed_image, htr_path, server_name)
+                
+                if viz_result and os.path.exists(viz_result):
+                    # Move to temp dir with proper name
+                    viz_path = temp_dir / f"{image_name}_visualization.png"
+                    shutil.move(viz_result, str(viz_path))
+                    output_files.append(viz_path)
+                
+            except Exception as e:
+                # Create error file for this visualization
+                error_path = temp_dir / f"{image_name}_viz_error.txt"
+                with open(error_path, 'w') as f:
+                    f.write(f"Visualization failed: {str(e)}")
+                output_files.append(error_path)
         
-        # Handle image input
-        image_path = handle_image_input(image_path, progress)
+        # Cleanup temp files
+        for temp_file in temp_files:
+            try:
+                os.unlink(temp_file)
+            except:
+                pass
         
-        progress(0.5, desc="Creating visualization...")
+        progress(0.9, desc="Creating ZIP archive...")
         
-        # Call the original visualizer function
-        result = htrflow_visualizer(image_path, htr_document_path, server_name)
+        # Create ZIP file
+        zip_path = temp_dir / "htr_visualizations.zip"
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in output_files:
+                zipf.write(file_path, file_path.name)
         
-        progress(1.0, desc="Visualization complete!")
+        progress(1.0, desc=f"Visualization complete! Created {len(output_files)} visualizations.")
+        
+        return str(zip_path)
         
-        return result
     except Exception as e:
-        # Create an error file
         error_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
-        error_file.write(f"Visualization failed: {str(e)}")
+        error_file.write(f"Batch visualization failed: {str(e)}")
         error_file.close()
         return error_file.name
-    finally:
-        # Clean up temporary file if it was downloaded
-        if image_path and image_path.startswith(tempfile.gettempdir()):
-            try:
-                os.unlink(image_path)
-            except:
-                pass
 
 
 def extract_text_from_collection(collection: Collection) -> str:
@@ -418,16 +564,20 @@ def extract_text_from_collection(collection: Collection) -> str:
 
 
 def create_htrflow_mcp_server():
-    # HTR Text extraction interface with improved API description
-    htr_text_interface = gr.Interface(
-        fn=htr_text,
+    # Batch HTR Text extraction interface
+    htr_text_batch_interface = gr.Interface(
+        fn=htr_text_batch,
         inputs=[
-            gr.Image(type="filepath", label="Upload Image or Enter URL"),
+            gr.Textbox(
+                label="Image Paths/URLs (one per line) or Upload Files",
+                placeholder="https://example.com/image1.jpg\nhttps://example.com/image2.jpg\n\nOR drag and drop multiple files",
+                lines=5
+            ),
             gr.Dropdown(
                 choices=FORMAT_CHOICES, 
                 value="letter_swedish", 
                 label="Document Type",
-                info="Select the type that best matches your document's layout and language"
+                info="Select the type that best matches your documents' layout and language"
             ),
             gr.Textbox(
                 label="Custom Settings (JSON)",
@@ -435,24 +585,34 @@ def create_htrflow_mcp_server():
                 value="",
                 lines=3
             ),
+            gr.Radio(
+                choices=["separate", "combined"],
+                value="separate",
+                label="Output Format",
+                info="'separate' shows each document's text with headers, 'combined' merges all text"
+            ),
         ],
-        outputs=[gr.Textbox(label="Extracted Text", lines=15)],
-        title="Extract Text from Handwritten Documents",
-        description="Upload a handwritten document image to extract text using AI-powered HTR",
-        api_name="htr_text",
-        api_description="Extract text from handwritten historical documents using advanced HTR models. Supports letters and book spreads in English and Swedish.",
+        outputs=[gr.Textbox(label="Extracted Text", lines=20)],
+        title="Batch Extract Text from Handwritten Documents",
+        description="Process multiple handwritten document images at once. Upload files or provide URLs (one per line)",
+        api_name="htr_text_batch",
+        api_description="Extract text from multiple handwritten historical documents using advanced HTR models. Supports batch processing of letters and book spreads in English and Swedish. If a user passes a file as an input, use the upload_file_to_gradio tool, if present, to upload the file to the gradio app and create a Gradio File Input. Then use the returned path as the input to the tool",
     )
 
-    # HTR File generation interface
-    htrflow_file_interface = gr.Interface(
-        fn=htrflow_file,
+    # Batch HTR File generation interface
+    htrflow_file_batch_interface = gr.Interface(
+        fn=htrflow_file_batch,
         inputs=[
-            gr.Image(type="filepath", label="Upload Image or Enter URL"),
+            gr.Textbox(
+                label="Image Paths/URLs (one per line) or Upload Files",
+                placeholder="https://example.com/image1.jpg\nhttps://example.com/image2.jpg\n\nOR drag and drop multiple files",
+                lines=5
+            ),
             gr.Dropdown(
                 choices=FORMAT_CHOICES, 
                 value="letter_swedish", 
                 label="Document Type",
-                info="Select the type that best matches your document's layout and language"
+                info="Select the type that best matches your documents' layout and language"
             ),
             gr.Dropdown(
                 choices=FILE_CHOICES, 
@@ -473,19 +633,27 @@ def create_htrflow_mcp_server():
                 visible=False  # Hide this from UI but keep for API
             ),
         ],
-        outputs=[gr.File(label="Download HTR Output File")],
-        title="Generate HTR Output Files",
-        description="Process handwritten documents and export in various formats (XML, JSON, TXT)",
-        api_name="htrflow_file",
-        api_description="Process handwritten documents and generate formatted output files. Outputs can be in ALTO XML (with text coordinates), PAGE XML, JSON (structured data), or plain text format.",
+        outputs=[gr.File(label="Download ZIP with HTR Output Files")],
+        title="Batch Generate HTR Output Files",
+        description="Process multiple handwritten documents and export in various formats. Returns a ZIP file with all results.",
+        api_name="htrflow_file_batch",
+        api_description="Process multiple handwritten documents and generate formatted output files. Returns a ZIP containing outputs in ALTO XML (with text coordinates), PAGE XML, JSON (structured data), or plain text format. If a user passes a file as an input, use the upload_file_to_gradio tool, if present, to upload the file to the gradio app and create a Gradio File Input. Then use the returned path as the input to the tool",
     )
 
-    # HTR Visualization interface
-    htrflow_viz = gr.Interface(
-        fn=htrflow_visualizer_with_progress,
+    # Batch HTR Visualization interface
+    htrflow_viz_batch_interface = gr.Interface(
+        fn=htrflow_visualizer_batch,
         inputs=[
-            gr.Image(type="filepath", label="Upload Original Image"),
-            gr.File(label="Upload ALTO/PAGE XML File", file_types=[".xml"]),
+            gr.Textbox(
+                label="Original Image Paths/URLs (one per line)",
+                placeholder="https://example.com/image1.jpg\nhttps://example.com/image2.jpg",
+                lines=5
+            ),
+            gr.File(
+                label="Upload HTR XML Files (ALTO/PAGE)", 
+                file_types=[".xml"],
+                file_count="multiple"
+            ),
             gr.Textbox(
                 label="Server Name",
                 value="https://gabriel-htrflow-mcp.hf.space",
@@ -493,30 +661,97 @@ def create_htrflow_mcp_server():
                 visible=False  # Hide this from UI but keep for API
             ),
         ],
-        outputs=gr.File(label="Download Visualization Image"),
-        title="Visualize HTR Results",
-        description="Create an annotated image showing detected text regions and recognized text",
-        api_name="htrflow_visualizer",
-        api_description="Generate a visualization image showing HTR results overlaid on the original document. Shows detected text regions, reading order, and recognized text for quality control.",
+        outputs=gr.File(label="Download ZIP with Visualization Images"),
+        title="Batch Visualize HTR Results",
+        description="Create annotated images for multiple documents. Images and XML files must be in matching order.",
+        api_name="htrflow_visualizer_batch",
+        api_description="Generate visualization images showing HTR results overlaid on multiple original documents. Shows detected text regions, reading order, and recognized text for quality control. Returns a ZIP file with all visualizations. If a user passes a file as an input, use the upload_file_to_gradio tool, if present, to upload the file to the gradio app and create a Gradio File Input. Then use the returned path as the input to the tool",
+    )
+
+    # Legacy single-file interfaces (kept for backward compatibility)
+    htr_text_interface = gr.Interface(
+        fn=lambda img, doc_type, settings: htr_text_batch(img, doc_type, settings, "separate"),
+        inputs=[
+            gr.Image(type="filepath", label="Upload Image or Enter URL"),
+            gr.Dropdown(
+                choices=FORMAT_CHOICES, 
+                value="letter_swedish", 
+                label="Document Type"
+            ),
+            gr.Textbox(
+                label="Custom Settings (JSON)",
+                placeholder='{"steps": [...]}',
+                value="",
+                lines=3
+            ),
+        ],
+        outputs=[gr.Textbox(label="Extracted Text", lines=15)],
+        title="Extract Text (Single Document)",
+        description="Upload a single handwritten document image to extract text",
+        api_name="htr_text",
+        api_description="Extract text from handwritten historical documents using advanced HTR models. Supports letters and book spreads in English and Swedish. If a user passes a file as an input, use the upload_file_to_gradio tool, if present, to upload the file to the gradio app and create a Gradio File Input. Then use the returned path as the input to the tool",
+    )
+
+    htrflow_file_interface = gr.Interface(
+        fn=lambda img, doc_type, fmt, settings, srv: htrflow_file_batch([img], doc_type, fmt, settings, srv),
+        inputs=[
+            gr.Image(type="filepath", label="Upload Image or Enter URL"),
+            gr.Dropdown(
+                choices=FORMAT_CHOICES, 
+                value="letter_swedish", 
+                label="Document Type"
+            ),
+            gr.Dropdown(
+                choices=FILE_CHOICES, 
+                value=DEFAULT_OUTPUT, 
+                label="Output Format"
+            ),
+            gr.Textbox(
+                label="Custom Settings (JSON)",
+                value="",
+                lines=3
+            ),
+            gr.Textbox(
+                label="Server Name",
+                value="https://gabriel-htrflow-mcp.hf.space",
+                visible=False
+            ),
+        ],
+        outputs=[gr.File(label="Download HTR Output File")],
+        title="Generate File (Single Document)",
+        description="Process a single handwritten document and export in various formats",
+        api_name="htrflow_file",
+        api_description="Process handwritten documents and generate formatted output files. Outputs can be in ALTO XML (with text coordinates), PAGE XML, JSON (structured data), or plain text format. If a user passes a file as an input, use the upload_file_to_gradio tool, if present, to upload the file to the gradio app and create a Gradio File Input. Then use the returned path as the input to the tool",
     )
 
     # Create tabbed interface with better organization
     demo = gr.TabbedInterface(
-        [htr_text_interface, htrflow_file_interface, htrflow_viz],
-        ["Extract Text", "Generate Files", "Visualize Results"],
-        title="🖋️ HTRflow - Handwritten Text Recognition",
+        [
+            htr_text_batch_interface,
+            htrflow_file_batch_interface, 
+            htrflow_viz_batch_interface,
+            htr_text_interface,
+            htrflow_file_interface,
+        ],
+        [
+            "📚 Batch Text Extract",
+            "📁 Batch File Generate",
+            "🖼️ Batch Visualize",
+            "📄 Single Text",
+            "💾 Single File",
+        ],
+        title="🖋️ HTRflow - Handwritten Text Recognition (Batch & Single Processing)",
         analytics_enabled=False,
     )
 
     return demo
 
-
 if __name__ == "__main__":
     demo = create_htrflow_mcp_server()
     demo.launch(
         mcp_server=True, 
         share=False, 
         debug=False,
-        show_api=True,  # Ensure API is visible
+        show_api=True,  
         favicon_path=None,
     )