Data as of Sep 21, 2026 · Based on 349 AI responses from ChatGPT Search and Google AI Mode · See how Parse measures this
To convert complex PDFs with tables into vectors, use a high-accuracy layout parser like 
Docling to convert documents into clean markdown. Once parsed, store the resulting embeddings in a vector database such as
Brands AI recommends here
Named in 56% of answers
Named in 52% of answers
Provides a robust platform for automatically partitioning large document sets into text, tables, and images. It is ideal for teams needing an automated, scalable pipeline to prepare raw data for downstream vectorization.
Named in 46% of answers
Named in 43% of answers
Best for high-fidelity extraction of complex tables and charts. It uses vision-based models to understand layout and converts documents into structured markdown, making it highly effective for complex RAG pipelines.
Source | Citation share |
|---|---|
 best tools & pipeline for processing ~100 heavy NASA PDFs (lots of ...https://www.reddit.com/r/Rag/comments/1oyf7n6/help_best_tools_pipeline_for_processing_100_heavy/ | 3% |
 Build an Enterprise-Scale Multimodal PDF Data Extraction Pipeline with an NVIDIA AI Blueprint | NVIDIA Technical Bloghttps://developer.nvidia.com/blog/build-an-enterprise-scale-multimodal-document-retrieval-pipeline-with-nvidia-nim-agent-blueprint/ | 2% |
 Build an unstructured data pipeline for RAG | Databricks on AWShttps://docs.databricks.com/aws/en/generative-ai/tutorials/ai-cookbook/quality-data-pipeline-rag | 2% |
 RAG Data pipeline for complex documents like PDFs | by Peter Landis | Mediumhttps://medium.com/@thepeterlandis/rag-data-pipeline-for-complex-documents-like-pdfs-ab2e97618e37 | 2% |
 Parse PDFs in a retrieval-augmented generation pipeline | BigQuery | Google Cloud Documentationhttps://cloud.google.com/bigquery/docs/rag-pipeline-pdf | 2% |
 PDF Ingestion Using Graphlit | Graphlit Bloghttps://www.graphlit.com/blog/pdf-ingestion-using-graphlit | 1% |
 Introducing Agentic Document Extraction: Convert Complex Docs to Structured Data | Sumanth P posted on the topic | LinkedInhttps://www.linkedin.com/posts/sumanth077_turn-complex-documents-into-rag-ready-data-activity-7389605020066832384-aZAo | 1% |
How to ingest PDF files for RAG. To ingest many PDFs into a RAG system… | by LLM | Mediumhttps://medium.com/@generative_ai/how-to-ingest-pdf-files-for-rag-f7ddc8bdbf26 | 1% |
 OnyxLab | AI/ML Engineeringhttps://www.onyxlab.ai/docs/getting-started/data | 1% |
 Tutorial: Multimodal Chunking and Embedding with the Document Layout Skill - Azure AI Search | Microsoft Learnhttps://learn.microsoft.com/en-us/azure/search/tutorial-document-layout-multimodal-embeddings | 1% |
Handling complex layouts (multi-column, headers, sidebars) and dense tables requires moving away from naive text-extraction libraries (like `pypdf` or basic `PyMuPDF` ), which flatten text and scramble reading…
Handling complex layouts (multi-column, headers, sidebars) and dense tables requires moving away from naive text-extraction libraries (like pypdf or basic PyMuPDF ), which flatten text and scramble reading order.
A robust ingestion pipeline for complex PDFs relies on a Layout-Aware Parsing -> Structural Representation -> Semantic Chunking -> Vectorization architecture.
Instead of extracting raw character streams, you need a parser that understands visual boundaries, bounding boxes, and hierarchical structures.
Do not flatten tables into plain space-delimited text; embeddings will lose row-column relationships entirely.
<table><tr><td>... ) or structured Markdown. HTML is often preferred for complex tables with merged cells because it explicitly preserves row/column spans.Avoid arbitrary token-counting chunkers (e.g., split every 500 tokens), which cut tables and multi-column paragraphs in half.
#, ##, ### ) and natural section boundaries rather than rigid character lengths.An ideal open-source or hybrid stack looks like this:
MarkdownNodeParser to respect document hierarchy.text-embedding-3-small/large or Cohere Embed v3) that handles dense semantic text well.To help narrow down the exact pipeline configuration, tell me:
For a **large corpus of complex PDFs**, I’d avoid the classic `PDF → plain text → fixed-size chunks → embeddings` pipeline. It tends to destroy the relationships that matter most in technical PDFs—headings, columns, tables, captions, footnotes, and reading order. A better architecture is: ```
For a large corpus of complex PDFs, I’d avoid the classic PDF → plain text → fixed-size chunks → embeddings pipeline. It tends to destroy the relationships that matter most in technical PDFs—headings, columns, tables, captions, footnotes, and reading order.
A better architecture is:
PDFs
↓
Document classification
├─ digital PDF
├─ scanned/OCR PDF
└─ image-heavy / unusual PDF
↓
Layout-aware parsing
↓
Structured document representation
├─ sections / headings
├─ paragraphs
├─ tables
├─ figures + captions
└─ page/bounding-box metadata
↓
Structure-aware chunking
├─ prose chunks
├─ table chunks
└─ figure/caption chunks
↓
Embedding
↓
Vector DB + metadata / keyword index
↓
Hybrid retrieval → reranking → LLM
For an open-source/self-hosted pipeline, Docling is particularly well suited. It performs layout recognition, reading-order recovery, OCR, and table-structure extraction, and its native HybridChunker works on structural document nodes rather than simply slicing text by character count.
That means you can preserve something like:
Document
└── Section: "Revenue Recognition"
├── Paragraph
├── Paragraph
├── Table
│ ├── Header
│ ├── Row
│ └── Row
└── Footnote
rather than embedding an arbitrary 1,000-token slice containing half a table and the beginning of the next section.
For particularly difficult tables, Docling exposes an accurate TableFormer mode in addition to its faster mode.
Azure AI Document Intelligence Layout is another strong option, especially for enterprise-scale ingestion. Its layout model extracts text, sections, reading order, tables, figures, and other structural elements; table extraction retains row/column indices, spans, headers, and bounding regions.
Microsoft specifically recommends using the resulting Markdown/structure for semantic chunking, including making tables their own chunks rather than blindly splitting them with surrounding prose.
I'd use different chunking strategies for different element types:
| Element | Ingestion strategy |
|---|---|
| Headings | Store as hierarchy metadata |
| Normal prose | Semantic/structural chunks |
| Tables | Preserve table structure; usually one table or logical table section per chunk |
| Long tables | Split by logical row groups while repeating headers |
| Figures | Store caption + surrounding explanation; optionally embed image separately |
| Footnotes | Attach to their parent section/table where possible |
| Scanned pages | OCR + layout analysis |
| Headers/footers | Detect and generally remove from semantic content |
For a table, for example, I'd preserve something like:
Section: 3.2 Operating Results
Table: Revenue by Region
| Region | 2024 | 2025 | Change |
| US | ... | ... | ... |
| EU | ... | ... | ... |
rather than flattening it into:
Region US 2024 100 2025 120 Change 20 EU ...
The former gives both the embedding model and downstream LLM considerably more semantic context.
At minimum:
{
"document_id": "annual_report_2025",
"page": 47,
"section": "Operating Results > Revenue",
"element_type": "table",
"chunk_id": "annual_report_2025_p47_t2",
"parent_id": "annual_report_2025_section_3_2",
"source": "annual_report_2025.pdf"
}
I'd also retain bounding boxes/page coordinates if your parser provides them. They make it possible to show the user the exact source region supporting an answer rather than merely saying "page 47."
For complex PDFs, don't rely exclusively on vector similarity:
Query
↓
Dense vector search
+
BM25 / keyword search
↓
Merge candidates
↓
Metadata filtering
↓
Reranker
↓
Top 5–20 chunks
↓
LLM
This is especially important for PDFs containing numbers, identifiers, part numbers, legal clauses, equations, and table values, where lexical matching can complement semantic embeddings.
If I were implementing this today, my baseline would be:
Docling → structured JSON/Markdown → structure-aware chunking → embeddings → hybrid vector/BM25 retrieval → reranker → LLM
For a cloud/enterprise environment, I'd consider:
Azure Document Intelligence Layout → structured Markdown/JSON → semantic chunking → Azure AI Search hybrid retrieval → reranking → LLM
The key architectural decision isn't actually the vector database—it is preserving document structure before you ever create the embeddings. Microsoft's RAG guidance likewise emphasizes layout analysis and semantic/structure-aware chunking for semi-structured documents.
If you tell me roughly how many PDFs, their average page count, whether they're scanned, and what kinds of tables/layouts they contain, I can give you a concrete production architecture (including workers, queues, storage, chunk schema, and embedding/retrieval strategy).
For a **large corpus of complex PDFs**, I’d build the pipeline around **layout-aware parsing first, embeddings second**. The biggest mistake is extracting plain text and then trying to recover tables/layout during chunking. ### Recommended architecture ```
For a large corpus of complex PDFs, I’d build the pipeline around layout-aware parsing first, embeddings second. The biggest mistake is extracting plain text and then trying to recover tables/layout during chunking.
PDFs
│
├─► classify: born-digital vs scanned
│
▼
Layout-aware parser
│
├─ text blocks + reading order
├─ headings/sections
├─ tables → structured representation
├─ figures/captions
├─ page coordinates
└─ OCR where necessary
│
▼
Canonical document representation
│
├─ paragraphs
├─ sections
├─ tables
└─ figures
│
▼
Semantic / structure-aware chunking
│
├─ prose chunks
├─ table chunks
└─ figure/context chunks
│
▼
Embeddings + metadata
│
▼
Vector DB + document/object store
For a self-hosted/open-source pipeline, github.com is particularly well suited. It explicitly handles PDF layout, reading order, tables, formulas and OCR, and maintains a structured document representation rather than reducing everything to a text blob.
Its table pipeline is especially relevant: it can reconstruct merged and borderless tables, and its table extraction has configurable accuracy/cell-matching behavior.
If you're comfortable with a managed cloud service, Azure Document Intelligence's Layout model is another strong architecture. It returns paragraphs, roles, tables, cells, bounding regions, reading structure and OCR information, making it straightforward to preserve provenance.
Don't embed the PDF page wholesale. Convert it into objects roughly like:
{
"document_id": "report-123",
"page": 17,
"section": "3.2 Revenue",
"type": "table",
"content": "Region | 2024 | 2025\nNorth | $10M | $13M\n...",
"metadata": {
"bbox": [72, 310, 520, 690],
"table_id": "table-17-2"
}
}
For prose:
{
"document_id": "report-123",
"page": 18,
"section": "3.2 Revenue",
"type": "paragraph",
"content": "...",
"metadata": {
"parent_section": "3.2 Revenue"
}
}
That metadata becomes extremely valuable for retrieval and citations.
Don't flatten a table into arbitrary text chunks. Preserve:
For embedding, I'd create a retrieval-friendly textual representation of each table, while also storing the original structured table separately.
For example:
Table: Revenue by region, 2024–2025
Units: USD millions
North: 2024 = 10, 2025 = 13
South: 2024 = 8, 2025 = 11
West: 2024 = 14, 2025 = 15
Source: Annual Report, page 17
This makes queries such as "What was North revenue in 2025?" much more likely to retrieve the relevant table.
For numerical/analytical questions, I'd also consider routing retrieved tables to a structured-data/LLM reasoning step rather than relying exclusively on vector similarity.
Use semantic + structural chunking, rather than fixed 500-token windows.
A good hierarchy is:
Document
└── Section
├── paragraph
├── paragraph
├── table
├── paragraph
└── figure
Then make chunks around sections and coherent concepts, with modest overlap where necessary.
I would also keep:
chunk_id
document_id
page_start / page_end
section_path
element_type
parent_element
bbox
source_uri
This lets retrieval return the right passage and lets your application jump back to the exact PDF page.
| Requirement | Pipeline |
|---|---|
| Open source / self-hosted | Docling → structured JSON/Markdown → semantic chunker → embeddings → vector DB |
| Azure-heavy infrastructure | Azure Document Intelligence Layout → canonical representation → chunking → embeddings |
| Mostly simple digital PDFs | Native PDF extraction may be sufficient |
| Scanned PDFs | Layout parser + OCR |
| Financial/scientific PDFs with difficult tables | Layout-aware parser + dedicated table representation |
| Highest retrieval quality | Hybrid vector + keyword/metadata retrieval |
The important architectural principle is "structure first, vectors second." Keep the parsed representation as your source of truth and treat embeddings as an index over that representation.
If you're processing hundreds of thousands/millions of PDFs, I'd additionally make parsing an asynchronous, idempotent batch stage and cache its output before embedding. That prevents expensive re-parsing whenever you change your embedding model or chunking strategy.
If you're comfortable with a managed cloud service, Azure Document Intelligence's Layout model is another strong architecture. It returns paragraphs, roles, tables, cells, bounding regions, reading structure and OCR information, making it straightforward to preserve provenance.
Don't embed the PDF page wholesale. Convert it into objects roughly like:
{
"document_id": "report-123",
"page": 17,
"section": "3.2 Revenue",
"type": "table",
"content": "Region | 2024 | 2025\nNorth | $10M | $13M\n...",
"metadata": {
"bbox": [72, 310, 520, 690],
"table_id": "table-17-2"
}
}
For prose:
{
"document_id": "report-123",
"page": 18,
"section": "3.2 Revenue",
"type": "paragraph",
"content": "...",
"metadata": {
"parent_section": "3.2 Revenue"
}
}
That metadata becomes extremely valuable for retrieval and citations.
Don't flatten a table into arbitrary text chunks. Preserve:
For embedding, I'd create a retrieval-friendly textual representation of each table, while also storing the original structured table separately.
For example:
Table: Revenue by region, 2024–2025
Units: USD millions
North: 2024 = 10, 2025 = 13
South: 2024 = 8, 2025 = 11
West: 2024 = 14, 2025 = 15
Source: Annual Report, page 17
This makes queries such as "What was North revenue in 2025?" much more likely to retrieve the relevant table.
For numerical/analytical questions, I'd also consider routing retrieved tables to a structured-data/LLM reasoning step rather than relying exclusively on vector similarity.
Use semantic + structural chunking, rather than fixed 500-token windows.
A good hierarchy is:
Document
└── Section
├── paragraph
├── paragraph
├── table
├── paragraph
└── figure
Then make chunks around sections and coherent concepts, with modest overlap where necessary.
I would also keep:
chunk_id
document_id
page_start / page_end
section_path
element_type
parent_element
bbox
source_uri
This lets retrieval return the right passage and lets your application jump back to the exact PDF page.
| Requirement | Pipeline |
|---|---|
| Open source / self-hosted | Docling → structured JSON/Markdown → semantic chunker → embeddings → vector DB |
| Azure-heavy infrastructure | Azure Document Intelligence Layout → canonical representation → chunking → embeddings |
| Mostly simple digital PDFs | Native PDF extraction may be sufficient |
| Scanned PDFs | Layout parser + OCR |
| Financial/scientific PDFs with difficult tables | Layout-aware parser + dedicated table representation |
| Highest retrieval quality | Hybrid vector + keyword/metadata retrieval |
The important architectural principle is "structure first, vectors second." Keep the parsed representation as your source of truth and treat embeddings as an index over that representation.
If you're processing hundreds of thousands/millions of PDFs, I'd additionally make parsing an asynchronous, idempotent batch stage and cache its output before embedding. That prevents expensive re-parsing whenever you change your embedding model or chunking strategy.
Handling complex layouts, multi-column designs, and dense tables in PDFs requires moving away from traditional "flat-text" extractors (like basic PyPDF or PyMuPDF). Flat text scrambles multi-column reading orders and turns tables into garbled, context-free strings that ruin vector…
Handling complex layouts, multi-column designs, and dense tables in PDFs requires moving away from traditional "flat-text" extractors (like basic PyPDF or PyMuPDF). Flat text scrambles multi-column reading orders and turns tables into garbled, context-free strings that ruin vector retrieval.
A modern, production-grade ingestion pipeline for complex PDFs relies on a Layout-Aware Parsing -> Semantic/Structure-Preserving Chunking -> Enrichment -> Vector Indexing architecture.
Instead of raw text scraping, you need tools that use computer vision and deep learning models to comprehend document topology (bounding boxes, headers, lists, and table cells).
Standard fixed-size chunking (e.g., split every 500 tokens with 50 overlap) will slice right through a table or separate a table from its header, rendering the vector useless.
To help tailor this pipeline, could you share:
For **large collections of complex PDFs**, I would not use a simple `PDF → text → fixed-size chunks → embeddings` pipeline. You’ll lose reading order, table relationships, captions, and layout context before you ever reach the vector database. ### Recommended architecture ```
For large collections of complex PDFs, I would not use a simple PDF → text → fixed-size chunks → embeddings pipeline. You’ll lose reading order, table relationships, captions, and layout context before you ever reach the vector database.
PDFs
↓
Ingestion / dedup / metadata
↓
Document parser with layout + OCR + table extraction
↓
Canonical structured representation
↓
Structure-aware normalization
↓
Semantic / hierarchical chunking
↓
Embeddings
↓
Vector DB + document/metadata store
↓
Hybrid retrieval + reranking
For the parser, my default choice today would be Docling if you want an open-source/self-hosted pipeline. It specifically handles PDF layout, reading order, tables, OCR, and structured representations, and its HybridChunker is designed around structural document nodes rather than blindly splitting by character count.
A strong alternative is Unstructured, particularly if you want its routing between fast, high-resolution, and vision-based processing. Its current PDF pipeline can route pages according to complexity, while its higher-resolution modes preserve table structure as HTML.
If you're already heavily invested in Azure, Azure AI Document Intelligence's Layout model is another good fit; it exposes table cells, row/column spans, bounding polygons, and reading content that can be converted into Markdown for semantic chunking.
I'd represent a document roughly like:
{
"document_id": "annual_report_2025",
"page": 37,
"section": "Revenue by Geography",
"elements": [
{
"type": "paragraph",
"text": "..."
},
{
"type": "table",
"caption": "Revenue by geography",
"headers": ["Region", "2024", "2025"],
"rows": [
["North America", "$1.2B", "$1.5B"],
["Europe", "$800M", "$920M"]
]
}
]
}
Then create different retrieval representations for different element types:
This is substantially better than embedding raw extracted text because a query like “What was European revenue in 2025?” needs the relationship between the table title → column headers → row → value, not merely the words occurring near one another.
I would also avoid running the most expensive vision/OCR processing on every page.
┌─ simple text page ─────→ native extraction
PDF → page classifier
├─ tables/layout ────────→ layout parser
└─ scanned/complex page ─→ OCR/VLM
This is exactly the kind of routing Unstructured's current Auto strategy supports: text-only PDF pages can go through a faster path, while pages containing images/tables can be sent to higher-resolution or VLM processing.
For Docling, you can similarly configure OCR and table-structure processing independently, including accurate table reconstruction and multiple OCR engines.
For an enterprise-scale system, my stack would look like:
Object storage → queue → Docling → canonical JSON/Markdown → structure-aware chunker → embeddings → vector DB + Postgres/object store
With:
I'd also maintain two representations of tables:
That combination tends to work much better than asking one embedding to encode an entire complicated table.
| Requirement | Choice |
|---|---|
| Best open/self-hosted starting point | Docling |
| Flexible production document pipeline | Unstructured |
| Azure-native enterprise stack | Azure Document Intelligence |
| Simple PDFs | Native text extraction |
| Scanned PDFs | OCR |
| Complex tables | Dedicated table-structure extraction |
| Chunking | Structure/semantic-aware, not fixed characters |
| Retrieval | Hybrid vector + lexical + reranker |
| Tables | Structured representation plus textual summary |
If your PDFs are particularly nasty—financial reports, scientific papers, engineering drawings, legal documents, scanned forms, etc.—the exact pipeline changes quite a bit. I can lay out a production architecture (including Docling vs. Unstructured vs. LlamaParse, chunking strategy, embedding model, vector DB, and approximate throughput/cost) for a corpus of, say, 100k–10M PDFs.
For complex layouts, multi-column text, and intricate tables, traditional rule-based text extractors (like standard PyPDF or pdfminer) fail because they treat documents as flat walls of text, scrambling reading orders and destroying table cells.[](https://www.unsiloed.ai/blog/best-pdf-parser-rag-pipelines)…
For complex layouts, multi-column text, and intricate tables, traditional rule-based text extractors (like standard PyPDF or pdfminer) fail because they treat documents as flat walls of text, scrambling reading orders and destroying table cells.
The modern consensus for high-fidelity vector ingestion pipelines points toward vision-first or multimodal parsers that output structured Markdown or JSON, paired with hierarchical chunking.
text-embedding-3-small/large or Cohere Embed v3), and store them in a vector database like Qdrant, Milvus, or Chroma that supports hybrid search (dense + sparse/BM25) to catch specific numerical table queries.To help narrow down the best setup for your stack, tell me:
For a **large corpus of complex PDFs with tables, multi-column layouts, figures, footnotes, and scanned pages**, I’d build a **structure-first ingestion pipeline**, rather than extracting plain text and then embedding it. My default choice today would be **Docling + structure-aware chunking + hybrid retrieval**.…
For a large corpus of complex PDFs with tables, multi-column layouts, figures, footnotes, and scanned pages, I’d build a structure-first ingestion pipeline, rather than extracting plain text and then embedding it.
My default choice today would be Docling + structure-aware chunking + hybrid retrieval. Docling specifically preserves layout, reading order, tables, formulas, bounding boxes, and provenance, and has dedicated table-structure extraction and OCR support.
PDFs
│
▼
┌─────────────────────┐
│ Ingestion / Queue │ ← S3/GCS + job queue
└─────────┬───────────┘
▼
┌─────────────────────┐
│ PDF classification │
│ born-digital / scan │
│ text / tables / etc │
└─────────┬───────────┘
▼
┌─────────────────────────────┐
│ Docling document parsing │
│ • layout & reading order │
│ • OCR │
│ • tables → structured cells │
│ • figures/formulas │
│ • page/bbox provenance │
└────────────┬────────────────┘
▼
┌─────────────────────────────┐
│ Normalized document model │
│ │
│ sections │
│ paragraphs │
│ tables │
│ captions │
│ figures │
│ page + bbox + source │
└────────────┬────────────────┘
▼
┌─────────────────────────────┐
│ Structure-aware chunking │
│ │
│ section → subsection → │
│ paragraph/table │
└────────────┬────────────────┘
▼
┌──────┴───────┐
▼ ▼
Dense embeddings Sparse/BM25
│ │
└──────┬───────┘
▼
Vector + search
indexes
This is probably the most important design decision.
Avoid:
PDF → text extraction → split every 500 tokens → embeddings
That destroys relationships such as:
Instead, retain a structured intermediate representation. Docling's DoclingDocument explicitly represents text, tables, pictures, hierarchy, layout/bounding boxes, and provenance.
Don't embed a table simply as whatever text extraction happens to produce.
For example, preserve something like:
{
"type": "table",
"caption": "Revenue by region",
"page": 47,
"headers": ["Region", "2024", "2025", "Growth"],
"rows": [
["North America", "$12M", "$15M", "25%"],
["Europe", "$8M", "$9M", "12.5%"]
],
"source_bbox": [72, 312, 524, 681]
}
Then create a retrieval representation such as:
Table: Revenue by region.
Columns: Region | 2024 | 2025 | Growth
North America | $12M | $15M | 25%
Europe | $8M | $9M | 12.5%
You can also maintain the original structured table separately so that an answer can cite the exact page/table rather than relying solely on the embedding.
Docling's table pipeline reconstructs rows, columns, cells, headers and merged cells; its current pipeline options also expose an accurate table extraction mode intended for complex production tables.
I'd use chunks roughly like:
Document
└── Section
└── Subsection
├── paragraph chunk
├── paragraph chunk
├── table
└── paragraph chunk
rather than arbitrary token windows.
Each chunk should carry metadata such as:
{
"document_id": "...",
"chunk_id": "...",
"page_start": 47,
"page_end": 48,
"section": "3.2 Financial Results",
"content_type": "table",
"source_bbox": [...],
"parent_section": "Financial Results",
"document_version": "2025"
}
This gives you retrieval + provenance, instead of merely retrieval.
I wouldn't send everything through one embedding strategy.
| Content | Treatment |
|---|---|
| Normal prose | Structure-aware chunks → embeddings |
| Tables | Structured extraction + textual representation → embeddings |
| Table-heavy reports | Table-level + row/section representations |
| Figures | Caption + optional vision-generated description |
| Scanned PDFs | OCR → normal pipeline |
| Formulas | Preserve LaTeX/semantic representation |
| Headings | Metadata, not usually standalone embeddings |
| Footnotes | Keep attached to their parent context |
| Very long sections | Hierarchical/parent-child chunks |
Docling supports OCR, formulas, pictures, tables, reading order and provenance in the same document representation, which makes this kind of branching pipeline practical.
For serious PDF search, I'd use hybrid retrieval:
Query
│
┌────────┴────────┐
▼ ▼
Dense retrieval BM25/sparse
│ │
└────────┬────────┘
▼
Reranker
│
▼
Top N relevant chunks
│
▼
LLM / answerer
Dense vectors are excellent for semantic questions, but tables often contain exact identifiers, numbers, dates, product codes, account names, etc. Sparse retrieval catches those much better.
For a very large corpus, I'd also consider a two-stage index:
That reduces vector-search noise and makes it easier to preserve document context.
Open-source/self-hosted:
Docling is particularly attractive if privacy or on-prem processing matters because it can run locally and offline.
Managed alternative: LlamaParse is worth evaluating if you don't want to operate the document parsing infrastructure. Its main appeal is strong out-of-the-box handling of messy layouts and tables, at the cost of using a hosted service.
Build a quality-control/reprocessing loop.
Don't assume every PDF parsed correctly:
Parse
↓
Quality checks
├─ OCR confidence
├─ suspiciously empty pages
├─ table extraction anomalies
├─ reading-order anomalies
└─ text/table density
│
├── good → chunk/embed
│
└── bad → alternate parser/OCR/VLM
This is often more valuable than trying to find a single "perfect" PDF parser.
Bottom line: for your use case, I'd start with Docling → structured intermediate representation → structure-aware/table-aware chunking → hybrid dense+sparse retrieval → reranking, while preserving page/bounding-box provenance all the way through. That is substantially more robust than a conventional PDF-to-text-to-vector pipeline.
If you tell me roughly how many PDFs/pages you're processing, whether they're scanned, and what kind of tables they contain (financial, scientific, forms, etc.), I can sketch the concrete production architecture—including workers, storage schema, chunk format, and embedding/indexing strategy.
Handling complex PDF layouts, multi-column reading orders, and intricate tables requires moving past traditional regex or naive text-extractors (like PyPDF or pdfminer) which scramble table cells and bleed columns together.[](https://www.youtube.com/watch?v=V_-WNJgTvgg&t=1080)…
Handling complex PDF layouts, multi-column reading orders, and intricate tables requires moving past traditional regex or naive text-extractors (like PyPDF or pdfminer) which scramble table cells and bleed columns together.
The state-of-the-art approach relies on layout-aware vision-language parsers that convert pages into structure-preserving formats (like Markdown or structured JSON) before chunking and vectorizing.
A robust, modern ingestion pipeline looks like this:
[Complex PDFs]
│
▼
[Layout-Aware Parser: Docling / LlamaParse] ──(Outputs Clean Markdown w/ Tables)
│
▼
[Semantic/Hierarchical Chunking] ──(Respects Table boundaries & Section headers)
│
▼
[Embedding Model] ──(e.g., Hugging Face / OpenAI / Cohere)
│
▼
[Vector Database] ──(Milvus, Qdrant, Pinecone, etc.)
#, ## ) or use layout-aware semantic chunkers that keep whole tables intact as individual nodes/chunks.If you'd like to narrow this down, tell me:
I can provide a sample Python implementation snippet tailored to your stack.
When turning large sets of complex PDFs with dense layouts and intricate tables into vectors, traditional text-extraction tools (like standard PyPDF or pdfminer) usually fail because they jumble multi-column text and flatten tables into unreadable…
When turning large sets of complex PDFs with dense layouts and intricate tables into vectors, traditional text-extraction tools (like standard PyPDF or pdfminer) usually fail because they jumble multi-column text and flatten tables into unreadable strings.
An ideal data ingestion pipeline for this use case relies on a Multimodal / Layout-Aware Parsing Strategy , converting layout elements into structured representations (like HTML or Markdown) before chunking and embedding.
Top Pipeline Architectures & Tools
unstructured-io)
hi_res partitioning strategy with infer_table_structure=True , it uses layout models to segment text, headers, and tables. It can output tables directly into HTML, preserving row/column spans.Recommended Pipeline Blueprint
hi_res or Vision)by_title or LlamaIndex's hierarchical node parser) so that text preceding a table stays bound to that table's structural block rather than cutting off mid-context.To help narrow down the ideal stack, tell me:
For a **large corpus of complex PDFs**, I’d build the ingestion layer around **layout-aware document parsing first, embeddings second**. The biggest mistake is extracting PDFs into plain text and then embedding that text: once columns, tables, captions, and reading order are destroyed, the embedding stage cannot…
For a large corpus of complex PDFs, I’d build the ingestion layer around layout-aware document parsing first, embeddings second. The biggest mistake is extracting PDFs into plain text and then embedding that text: once columns, tables, captions, and reading order are destroyed, the embedding stage cannot recover them.
PDFs
│
▼
┌──────────────────────┐
│ File validation │
│ + deduplication │
│ + metadata │
└──────────┬───────────┘
▼
┌──────────────────────┐
│ Layout-aware parser │ ← Docling / LlamaParse
│ • reading order │
│ • tables │
│ • OCR │
│ • figures/captions │
│ • bounding boxes │
└──────────┬───────────┘
▼
┌──────────────────────┐
│ Structured document │
│ representation │
│ │
│ sections │
│ paragraphs │
│ tables │
│ figures │
│ page/region metadata │
└──────────┬───────────┘
▼
┌──────────────────────┐
│ Structure-aware │
│ chunking │
└──────────┬───────────┘
▼
┌─────┴─────┐
▼ ▼
text chunks table chunks
│ │
└─────┬─────┘
▼
embeddings
│
▼
┌──────────────────────┐
│ Vector DB + metadata │
│ page / section / │
│ bbox / document ID │
└──────────────────────┘
For your particular description—large set + complex layouts + tables—I'd start with Docling.
Docling preserves document structure, resolves multi-column reading order, treats tables as structured objects, supports OCR, and has a structure-aware HybridChunker. It can also retain page and bounding-box provenance, which is extremely useful when you eventually need to show users where an answer came from.
The important distinction is:
Don't do:
PDF → plaintext → fixed 500-token chunks → embeddings
Do:
PDF
→ layout analysis
→ structured document
→ semantic/structural chunks
→ contextualized chunks
→ embeddings
A table shouldn't simply become:
Revenue 2024 1,234 Revenue 2023 987 Revenue growth 25%
Ideally, preserve the table structure and add its surrounding context:
Section: Financial Results
Table: Revenue by Region
Period: FY2024
| Region | FY2024 | FY2023 | Growth |
|--------|-------:|-------:|-------:|
| North | 1,234 | 987 | 25% |
| South | 842 | 790 | 7% |
Then embed a contextualized representation of the table, while storing the original structured table separately.
That gives you two useful retrieval paths:
For financial/scientific PDFs in particular, table extraction quality is one of the most consequential parts of the pipeline. Docling has a dedicated table-structure model and represents tables as first-class document objects.
| Situation | Choice |
|---|---|
| Complex PDFs, tables, self-hosting | Docling |
| Want a managed API with minimal infrastructure | LlamaParse |
| PDFs + lots of other enterprise formats | Unstructured |
| Extremely difficult documents where maximum extraction quality matters more than cost/complexity | VLM/agentic parser + fallback pipeline |
LlamaParse is particularly attractive if you want a hosted service and already use the LlamaIndex ecosystem.
Unstructured is compelling when the corpus isn't predominantly PDFs and you need broad format support; its output is element-oriented (Title, Table, NarrativeText, etc.).
For the hardest PDFs, I'd actually use a fallback strategy rather than betting everything on one parser:
┌─ normal PDF ──→ Docling
PDF → classifier ─┼─ scanned ─────→ OCR pipeline
└─ low confidence
│
▼
high-accuracy VLM
The key is to measure extraction quality before embedding. Store parser confidence/validation results and reprocess pages where tables or reading order look suspicious.
Make ingestion asynchronous and idempotent:
Object storage
↓
Job queue
↓
PDF preprocessing
↓
Parser workers
↓
Validation / quality checks
↓
Chunking workers
↓
Embedding workers
↓
Vector DB
Use a stable identifier such as:
document_id
document_version
page_number
element_id
chunk_id
and keep the original PDF plus the parsed structured representation. Don't make your vector database the system of record.
For every vector, I'd retain metadata roughly like:
{
"document_id": "...",
"document_version": 3,
"page": 17,
"section": "4.2 Financial Results",
"element_type": "table",
"chunk_id": "...",
"bbox": [x1, y1, x2, y2],
"parser": "docling",
"source_uri": "..."
}
That provenance becomes incredibly valuable for citations, debugging retrieval, and displaying the exact page region containing an answer. Docling specifically supports this kind of provenance-oriented workflow.
Bottom line: for a new system today, I'd use Docling → structured document representation → structure-aware chunking → embeddings → vector DB, with table chunks handled separately and a VLM/second parser as a fallback for low-confidence pages. That architecture will generally outperform trying to find a magical embedding model that compensates for bad PDF extraction.
