Skip to content
PDF Oxide

Extração de PDF para pipelines RAG em Python

Transforme PDFs em Markdown estruturado para o seu pipeline de RAG:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
md = doc.to_markdown_all(detect_headings=True, include_images=False)
# Divida em chunks, gere embeddings e salve no seu banco vetorial

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

const doc = new WasmPdfDocument(bytes);
const md = doc.toMarkdownAll();
// Divida em chunks, gere embeddings e salve no seu banco vetorial
doc.free();

Rust

use pdf_oxide::PdfDocument;

let mut doc = PdfDocument::open("paper.pdf")?;
let md = doc.to_markdown_all(true)?;
// Divida em chunks, gere embeddings e salve no seu banco vetorial

Go

package main

import (
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    doc, err := pdfoxide.Open("paper.pdf")
    if err != nil { log.Fatal(err) }
    defer doc.Close()

    md, _ := doc.ToMarkdownAll()
    _ = md // Divida em chunks, gere embeddings e salve no seu banco vetorial
}

C#

using PdfOxide;

using var doc = PdfDocument.Open("paper.pdf");
var md = doc.ToMarkdownAll();
// Divida em chunks, gere embeddings e salve no seu banco vetorial

O PDF Oxide processa 3.830 PDFs em 3,1 segundos, a 0,8 ms por página e com taxa de sucesso de 100 %. Zero documentos faltando no seu índice.

Por que a qualidade da extração importa para RAG

O seu sistema de recuperação só vai tão longe quanto a extração que vem antes:

  • Texto ausente = respostas ausentes. Uma biblioteca com 98,4 % de sucesso (pypdf) perde em silêncio 61 documentos num corpus de 3.823 arquivos. O PDF Oxide passa 100 %.
  • Estrutura perdida = chunking ruim. O texto puro descarta cabeçalhos, tabelas e formatação, justamente o que viabiliza o chunking semântico. O Markdown preserva tudo isso.
  • Extração lenta = gargalo no pipeline. A 12,1 ms por página (pypdf) ou 23,2 ms (pdfplumber), processar 100 mil páginas leva minutos. A 0,8 ms, bastam 80 segundos.

Instalação

pip install pdf_oxide

Início rápido: do PDF ao banco vetorial

from pdf_oxide import PdfDocument, PdfError
from pathlib import Path

def extract_documents(pdf_dir: str) -> list[dict]:
    """Extrair todos os PDFs de um diretório em chunks estruturados."""
    documents = []
    for pdf_path in Path(pdf_dir).glob("*.pdf"):
        try:
            doc = PdfDocument(str(pdf_path))
            for i in range(doc.page_count()):
                md = doc.to_markdown(i,
                    detect_headings=True,
                    include_images=False
                )
                if md.strip():
                    documents.append({
                        "content": md,
                        "source": pdf_path.name,
                        "page": i,
                    })
        except PdfError as e:
            print(f"Ignorado {pdf_path.name}: {e}")
    return documents

docs = extract_documents("research-papers/")
print(f"Foram extraídos {len(docs)} chunks dos PDFs")
# Passe docs para o seu modelo de embeddings e para o seu vector store

Estratégias de chunking

Por cabeçalho (chunking semântico)

Quebre a saída Markdown nos cabeçalhos para obter chunks semanticamente significativos:

Python

import re
from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
md = doc.to_markdown_all(detect_headings=True, include_images=False)

# Quebrar nos cabeçalhos ##
chunks = re.split(r'\n(?=## )', md)
chunks = [c.strip() for c in chunks if c.strip()]

WASM

const doc = new WasmPdfDocument(bytes);
const md = doc.toMarkdownAll();

// Quebrar nos cabeçalhos ##
const chunks = md.split(/\n(?=## )/).filter(c => c.trim());
doc.free();

Rust

let mut doc = PdfDocument::open("paper.pdf")?;
let md = doc.to_markdown_all(true)?;

let chunks: Vec<&str> = md.split("\n## ")
    .map(|c| c.trim())
    .filter(|c| !c.is_empty())
    .collect();

Go

doc, _ := pdfoxide.Open("paper.pdf")
defer doc.Close()

md, _ := doc.ToMarkdownAll()

var chunks []string
for _, c := range strings.Split(md, "\n## ") {
    c = strings.TrimSpace(c)
    if c != "" { chunks = append(chunks, c) }
}

C#

using var doc = PdfDocument.Open("paper.pdf");
var md = doc.ToMarkdownAll();

var chunks = md.Split("\n## ")
    .Select(c => c.Trim())
    .Where(c => c.Length > 0)
    .ToList();

Por página

Um chunk por página — simples e preserva o contexto em nível de página:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("manual.pdf")
chunks = []
for i in range(doc.page_count()):
    md = doc.to_markdown(i, detect_headings=True, include_images=False)
    if md.strip():
        chunks.append({"content": md, "page": i})

WASM

const doc = new WasmPdfDocument(bytes);
const chunks = [];
for (let i = 0; i < doc.pageCount(); i++) {
    const md = doc.toMarkdown(i);
    if (md.trim()) {
        chunks.push({ content: md, page: i });
    }
}
doc.free();

Rust

let mut doc = PdfDocument::open("manual.pdf")?;
let mut chunks = Vec::new();
for i in 0..doc.page_count()? {
    let md = doc.to_markdown(i, true)?;
    if !md.trim().is_empty() {
        chunks.push((i, md));
    }
}

Go

doc, _ := pdfoxide.Open("manual.pdf")
defer doc.Close()

type Chunk struct{ Page int; Content string }
var chunks []Chunk

n, _ := doc.PageCount()
for i := 0; i < n; i++ {
    md, _ := doc.ToMarkdown(i)
    if strings.TrimSpace(md) != "" {
        chunks = append(chunks, Chunk{Page: i, Content: md})
    }
}

C#

using var doc = PdfDocument.Open("manual.pdf");
var chunks = Enumerable.Range(0, doc.PageCount)
    .Select(i => new { Page = i, Content = doc.ToMarkdown(i) })
    .Where(c => !string.IsNullOrWhiteSpace(c.Content))
    .ToList();

Tamanho fixo com sobreposição

Divida textos longos em chunks de tamanho fixo com sobreposição:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("book.pdf")
full_text = doc.to_markdown_all(detect_headings=True, include_images=False)

chunk_size = 1000  # caracteres
overlap = 200
chunks = []

for start in range(0, len(full_text), chunk_size - overlap):
    chunk = full_text[start:start + chunk_size]
    if chunk.strip():
        chunks.append(chunk)

WASM

const doc = new WasmPdfDocument(bytes);
const fullText = doc.toMarkdownAll();

const chunkSize = 1000;
const overlap = 200;
const chunks = [];

for (let start = 0; start < fullText.length; start += chunkSize - overlap) {
    const chunk = fullText.slice(start, start + chunkSize);
    if (chunk.trim()) chunks.push(chunk);
}
doc.free();

Rust

let mut doc = PdfDocument::open("book.pdf")?;
let full_text = doc.to_markdown_all(true)?;

let chunk_size = 1000;
let overlap = 200;
let mut chunks = Vec::new();
let mut start = 0;

while start < full_text.len() {
    let end = (start + chunk_size).min(full_text.len());
    let chunk = &full_text[start..end];
    if !chunk.trim().is_empty() {
        chunks.push(chunk.to_string());
    }
    start += chunk_size - overlap;
}

Go

doc, _ := pdfoxide.Open("book.pdf")
defer doc.Close()

full, _ := doc.ToMarkdownAll()

const chunkSize, overlap = 1000, 200
var chunks []string
for start := 0; start < len(full); start += chunkSize - overlap {
    end := start + chunkSize
    if end > len(full) { end = len(full) }
    chunk := full[start:end]
    if strings.TrimSpace(chunk) != "" {
        chunks = append(chunks, chunk)
    }
}

C#

using var doc = PdfDocument.Open("book.pdf");
var full = doc.ToMarkdownAll();

const int chunkSize = 1000, overlap = 200;
var chunks = new List<string>();
for (int start = 0; start < full.Length; start += chunkSize - overlap)
{
    var end = Math.Min(start + chunkSize, full.Length);
    var chunk = full[start..end];
    if (!string.IsNullOrWhiteSpace(chunk))
        chunks.Add(chunk);
}

Processando milhares de PDFs em lote

A 0,8 ms por página, o PDF Oxide varre grandes corpora num piscar de olhos:

from pdf_oxide import PdfDocument, PdfError
from pathlib import Path

pdf_files = list(Path("corpus/").glob("**/*.pdf"))
print(f"Processando {len(pdf_files)} PDFs...")

all_chunks = []
errors = 0

for pdf_path in pdf_files:
    try:
        doc = PdfDocument(str(pdf_path))
        md = doc.to_markdown_all(
            detect_headings=True,
            include_images=False
        )
        if md.strip():
            all_chunks.append({
                "content": md,
                "source": str(pdf_path),
                "pages": doc.page_count(),
            })
    except PdfError:
        errors += 1

print(f"Foram extraídos {len(all_chunks)} documentos, {errors} erros")

Lidando com PDFs escaneados no pipeline

Em qualquer corpus, alguns PDFs serão imagens escaneadas. Use OCR como fallback:

from pdf_oxide import PdfDocument

doc = PdfDocument("mixed-corpus-file.pdf")
text = doc.extract_text(0)

if len(text.strip()) < 50:
    # Provavelmente é uma página escaneada — usar OCR
    text = doc.extract_text_ocr(0)

Veja o guia de OCR para detalhes de configuração.

Por que Markdown em vez de texto puro

Característica Texto puro Markdown
Hierarquia de cabeçalhos Perdida Preservada (#, ##, ###)
Tabelas Achatadas Sintaxe de tabela GFM
Negrito/itálico Perdidos **negrito**, *itálico*
Chunking semântico Difícil Dividir por cabeçalhos
Compreensão do LLM Menor Maior (entrada estruturada)

O Markdown dá mais contexto ao LLM sobre a estrutura do documento, o que se traduz em melhor qualidade de recuperação e geração.

Desempenho em escala

Tamanho do corpus PDF Oxide pypdf pdfplumber
1.000 páginas 0,8 s 12,1 s 23,2 s
10.000 páginas 8 s 121 s 232 s
100.000 páginas 80 s 1.210 s 2.320 s
Taxa de sucesso 100 % 98,4 % 98,8 %

Com 100 % de sucesso, você nunca precisa investigar à mão por que há documentos ausentes no seu índice.

Páginas relacionadas