@@ -31,6 +31,18 @@
 **Stability and Troubleshooting:**
 - Use ARM64 images and ensure all models are present to avoid runtime errors.
 - Memory management has been improved through the integration of mimalloc (a high-performance memory allocator), which significantly reduces memory growth during document processing. While earlier versions experienced memory leaks, this optimization addresses those concerns. Still, monitor memory usage for long-running sessions and restart the container if you observe unusual resource consumption.
+
+  **Processing Large Documents with Page Chunking:**
+  
+  For processing exceptionally large documents (e.g., 1000+ page PDFs) within memory constraints, configure the `page_chunk_size` option. This splits large PDFs into smaller page chunks during conversion, preventing Out-Of-Memory (OOM) errors without requiring additional memory allocation beyond the recommended 8GB minimum.
+  
+  Page chunking can be configured in two ways:
+  - In `PipelineOptions`: Set `page_chunk_size` when creating the pipeline options
+  - In `BatchConcurrencySettings`: Set `settings.perf.page_chunk_size`
+  
+  When enabled, chunks are treated as independent documents and processed in parallel based on `doc_batch_concurrency` settings. Consider increasing concurrency when using page chunking to process multiple chunks simultaneously (e.g., for a 500-page document with `page_chunk_size=50`, you could use `doc_batch_concurrency=10` to process all 10 chunks in parallel).
+  
+  Example values: Start with 50 or 100 pages per chunk and adjust based on your document size and available memory. Smaller chunk sizes reduce peak memory usage but increase overhead; larger chunks process faster but require more memory per chunk.
 
   **Memory Debugging Endpoints:**
   

@@ -16,6 +16,7 @@
     - `generate_page_images`, `generate_picture_images`: Extract page/picture images
     - `force_backend_text`: Force backend text extraction
     - `layout_custom_config`, `table_structure_custom_config`: Custom model configs for layout/table structure (see Table Structure Models section below)
+    - `page_chunk_size` (default: None): Number of pages to process as a single chunk. When processing large PDFs (e.g., 1000+ pages), this limits memory usage and allows streaming chunked results instead of waiting for the entire document. If None, the entire document is processed at once. See Page Chunking section below for details.
     - Additional options for chart extraction, picture description, and more
 
 ---
@@ -67,6 +68,37 @@
 result = converter.convert(source="scanned.pdf")
 text = result.document.export_to_text(traverse_pictures=True)
 markdown = result.document.export_to_markdown(traverse_pictures=True)
+```
+
+- **Page Chunking for Large Documents**: The `page_chunk_size` option enables processing large documents (e.g., 1000+ page PDFs) in chunks to prevent memory overflow (OOM) errors. When configured, the document is split into page chunks that are treated as independent documents and processed based on `doc_batch_concurrency`. Key behaviors:
+    - **Using `convert()` vs `convert_all()`**: When `page_chunk_size` is enabled, `convert()` only returns the first chunk. Use `convert_all()` to stream all chunks of the document.
+    - **Parallelization**: Chunks are treated as independent documents, so increase `doc_batch_concurrency` to process multiple chunks in parallel (e.g., 500 total pages / 50 page chunks = 10 concurrency for 10 chunks).
+    - **Default Behavior**: If `page_chunk_size` is not set (None), the entire document is processed at once.
+
+```python
+from docling.datamodel.pipeline_options import PdfPipelineOptions
+from docling.datamodel.base_models import InputFormat
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.datamodel.settings import settings
+
+# Configure chunking for large PDFs
+pipeline_options = PdfPipelineOptions()
+pipeline_options.page_chunk_size = 50  # Process 50 pages per chunk
+
+# Increase concurrency to parallelize chunks
+settings.perf.doc_batch_concurrency = 10  # Process 10 chunks in parallel
+settings.perf.doc_batch_size = 10
+
+converter = DocumentConverter(
+    format_options={
+        InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options)
+    }
+)
+
+# Use convert_all() to stream all chunks
+for result in converter.convert_all(["large_document.pdf"]):
+    print(f"Processed chunk: pages {result.input.limits.page_range}")
+    # Process each chunk as it completes
 ```
 
 - **Notes**: Only PDF supports image resolution adjustment. For more details, see [pipeline options code](https://github.com/docling-project/docling/blob/ae4fdbbb09fd377bb271e9b2efe541873eeb2990/docling/datamodel/pipeline_options.py#L891-L1336) and [example](https://app.dosu.dev/097760a8-135e-4789-8234-90c8837d7f1c/documents/9640186d-61e1-4ca1-9d8a-b82b3ee6bff8). Refer to the Python SDK documentation for usage of `format_options`. See the API reference for details on new preset/custom config fields and deprecated options.