integrations/pdf_processing/README.md

# PDF Processing Module for ATOM

A comprehensive PDF processing system with OCR capabilities, image comprehension, and memory storage integration for the ATOM platform.

## Overview

This module provides advanced PDF processing capabilities for ATOM, including:

- **Text Extraction**: Extract text from searchable PDFs using PyPDF2
- **OCR Processing**: Optical Character Recognition for scanned PDFs and images
- **Image Comprehension**: AI-powered understanding of visual content using OpenAI Vision
- **Memory Integration**: Store processed content in LanceDB for semantic search
- **Fallback Strategies**: Graceful degradation when external services are unavailable

## Features

### Core Processing
- **Multi-format Support**: Process PDFs from files, URLs, or byte streams
- **Smart PDF Detection**: Automatically detect searchable vs scanned PDFs
- **OCR with Fallback**: Cascade through multiple OCR engines (Tesseract, EasyOCR, OpenAI)
- **Image Extraction**: Extract and process embedded images
- **Batch Processing**: Support for processing multiple PDFs efficiently

### Memory Storage
- **Vector Embeddings**: Generate embeddings for semantic search
- **Metadata Management**: Store comprehensive document metadata
- **Semantic Search**: Find documents based on content similarity
- **Document Statistics**: Track usage and storage metrics
- **Tag-based Organization**: Categorize documents with custom tags

### Integration Features
- **RESTful API**: Complete API for integration with other services
- **Health Monitoring**: Service status and capability reporting
- **Error Handling**: Robust error handling with detailed feedback
- **Configuration**: Flexible configuration for different environments

## Installation

### System Dependencies

**Ubuntu/Debian:**
```bash
sudo apt-get update
sudo apt-get install tesseract-ocr poppler-utils
```

**macOS:**
```bash
brew install tesseract poppler
```

**Windows:**
- Download Tesseract from [GitHub releases](https://github.com/UB-Mannheim/tesseract/wiki)
- Download Poppler from [poppler-windows releases](https://github.com/oschwartz10612/poppler-windows/releases/)

### Python Dependencies

Add the following to your `requirements.txt`:

```txt
# PDF Processing
PyPDF2>=3.0.0,<4.0.0
pdf2image>=1.16.3,<2.0.0
pillow>=10.0.0,<11.0.0

# OCR Libraries
pytesseract>=0.3.10,<1.0.0
easyocr>=1.7.0,<2.0.0

# AI Vision (Optional)
openai>=1.0.0,<2.0.0

# Image Processing
numpy>=1.24.0,<2.0.0
opencv-python>=4.8.0,<5.0.0
```

## Configuration

### Environment Variables

```bash
# OpenAI API Key (for advanced image comprehension)
OPENAI_API_KEY=your_openai_api_key_here

# Tesseract Path (if not in PATH)
TESSERACT_PATH=/usr/bin/tesseract

# OCR Languages (comma-separated)
OCR_LANGUAGES=en,es,fr,de

# LanceDB Configuration
LANCEDB_URI=./data/lancedb
```

### Service Initialization

```python
from atom.backend.integrations.pdf_processing import PDFOCRService, PDFMemoryIntegration

# Initialize OCR Service
pdf_service = PDFOCRService(
    openai_api_key=os.getenv('OPENAI_API_KEY'),
    tesseract_path=os.getenv('TESSERACT_PATH'),
    easyocr_languages=['en', 'es']  # Default: ['en']
)

# Initialize Memory Integration
memory_service = PDFMemoryIntegration(lancedb_handler=your_lancedb_handler)
```

## API Endpoints

### PDF Processing Endpoints

#### `POST /pdf/process`
Process a PDF file with optional OCR and image comprehension.

**Parameters:**
- `file`: PDF file upload (required)
- `use_ocr`: Use OCR for scanned PDFs (default: true)
- `extract_images`: Extract and process images (default: true)
- `use_advanced_comprehension`: Use AI for image understanding (default: false)
- `fallback_strategy`: "cascade" or "parallel" (default: "cascade")

**Response:**
```json
{
  "processing_summary": {
    "used_ocr": true,
    "ocr_methods_tried": ["tesseract", "easyocr"],
    "best_method": "tesseract",
    "total_pages": 10,
    "total_characters": 2500
  },
  "extracted_content": {
    "text": "Extracted text content...",
    "page_breakdown": [...],
    "images": {...}
  },
  "service_status": {...}
}
```

#### `POST /pdf/process-url`
Process a PDF from a URL.

#### `POST /pdf/extract-text-only`
Fast text extraction without OCR.

#### `POST /pdf/analyze-pdf-type`
Analyze PDF type without full processing.

### Memory Integration Endpoints

#### `POST /pdf-memory/store`
Store processed PDF in memory system.

#### `GET /pdf-memory/search`
Search PDF documents using semantic search.

#### `GET /pdf-memory/documents/{doc_id}`
Retrieve a specific document.

#### `DELETE /pdf-memory/documents/{doc_id}`
Delete a document from memory.

#### `GET /pdf-memory/users/{user_id}/stats`
Get document statistics for a user.

## Usage Examples

### Basic PDF Processing

```python
from atom.backend.integrations.pdf_processing import PDFOCRService

# Initialize service
service = PDFOCRService()

# Process a PDF file
with open('document.pdf', 'rb') as f:
    result = await service.process_pdf(
        pdf_data=f.read(),
        use_ocr=True,
        extract_images=True
    )

print(f"Extracted {result['processing_summary']['total_characters']} characters")
print(f"Used method: {result['processing_summary']['best_method']}")
```

### Memory Integration

```python
from atom.backend.integrations.pdf_processing import PDFMemoryIntegration

# Initialize memory service
memory_service = PDFMemoryIntegration(lancedb_handler=lancedb_handler)

# Store processed PDF
storage_result = await memory_service.store_processed_pdf(
    user_id="user_123",
    processing_result=processing_result,
    source_uri="file:///documents/report.pdf",
    tags=["report", "quarterly", "finance"]
)

# Search documents
search_results = await memory_service.search_pdfs(
    user_id="user_123",
    query="quarterly financial report",
    limit=10,
    similarity_threshold=0.7
)
```

### Complete Workflow

```python
async def process_and_store_pdf(user_id: str, file_path: str):
    # Process PDF
    with open(file_path, 'rb') as f:
        processing_result = await pdf_service.process_pdf(f.read())
    
    # Store in memory
    storage_result = await memory_service.store_processed_pdf(
        user_id=user_id,
        processing_result=processing_result,
        source_uri=f"file://{file_path}"
    )
    
    return storage_result
```

## Fallback Strategies

The system implements intelligent fallback mechanisms:

1. **Cascade Strategy**: Try methods in order of preference
   - OpenAI Vision (if available and requested)
   - EasyOCR
   - Tesseract
   - Basic PyPDF2 extraction

2. **Parallel Strategy**: Try all methods and pick the best result

3. **Service Availability**: Automatically detect available OCR engines

## Error Handling

The module provides comprehensive error handling:

- **File Validation**: Validate PDF files before processing
- **Service Availability**: Check OCR engine availability
- **API Rate Limits**: Handle external API limitations
- **Memory Constraints**: Manage large document processing
- **Network Issues**: Handle connectivity problems gracefully

## Performance Considerations

- **Large Documents**: Process documents in chunks for memory efficiency
- **Batch Processing**: Use batch endpoints for multiple documents
- **Caching**: Implement caching for frequently accessed documents
- **Background Processing**: Use async processing for better performance

## Testing

Run the test suite:

```bash
cd atom/backend/integrations/pdf_processing
python -m pytest tests/ -v
```

## Contributing

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Ensure all tests pass
5. Submit a pull request

## License

This module is part of the ATOM platform and follows the same licensing terms.

## Support

For issues and questions:
- Create an issue in the ATOM repository
- Check the documentation
- Contact the development team