Skip to content
PDF Oxide

Извлечение PDF для RAG-пайплайнов в Python

Преобразуйте PDF в структурированный Markdown для вашего RAG-пайплайна:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("paper.pdf")
md = doc.to_markdown_all(detect_headings=True, include_images=False)
# Разбейте на чанки, вычислите эмбеддинги и сохраните в векторную БД

WASM

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

const doc = new WasmPdfDocument(bytes);
const md = doc.toMarkdownAll();
// Разбейте на чанки, вычислите эмбеддинги и сохраните в векторную БД
doc.free();

Rust

use pdf_oxide::PdfDocument;

let mut doc = PdfDocument::open("paper.pdf")?;
let md = doc.to_markdown_all(true)?;
// Разбейте на чанки, вычислите эмбеддинги и сохраните в векторную БД

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 // Разбейте на чанки, вычислите эмбеддинги и сохраните в векторную БД
}

C#

using PdfOxide;

using var doc = PdfDocument.Open("paper.pdf");
var md = doc.ToMarkdownAll();
// Разбейте на чанки, вычислите эмбеддинги и сохраните в векторную БД

PDF Oxide обрабатывает 3 830 PDF за 3,1 секунды — 0,8 мс на страницу при 100 % успехе. В индексе нет ни одного потерянного документа.

Почему качество извлечения важно для RAG

Ваша система поиска не лучше, чем извлечение, которое идёт до неё:

  • Пропущенный текст = пропущенные ответы. Библиотека с 98,4 % успеха (pypdf) молча теряет 61 документ в корпусе из 3 823 файлов. PDF Oxide проходит на 100 %.
  • Утраченная структура = плохой чанкинг. Обычный текст теряет заголовки, таблицы и форматирование — именно то, что делает возможным семантическое разбиение. Markdown всё это сохраняет.
  • Медленное извлечение = узкое место пайплайна. При 12,1 мс на страницу (pypdf) или 23,2 мс (pdfplumber) обработка 100 000 страниц занимает минуты. При 0,8 мс — 80 секунд.

Установка

pip install pdf_oxide

Быстрый старт: от PDF к векторной БД

from pdf_oxide import PdfDocument, PdfError
from pathlib import Path

def extract_documents(pdf_dir: str) -> list[dict]:
    """Извлечь все PDF из каталога в структурированные чанки."""
    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"Пропущен {pdf_path.name}: {e}")
    return documents

docs = extract_documents("research-papers/")
print(f"Извлечено чанков: {len(docs)}")
# Передайте docs в модель эмбеддингов и в векторное хранилище

Стратегии чанкинга

По заголовкам (семантический чанкинг)

Режьте Markdown по заголовкам — получатся осмысленные чанки:

Python

import re
from pdf_oxide import PdfDocument

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

# Разделить по заголовкам ##
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();

// Разделить по заголовкам ##
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();

По страницам

Одна страница — один чанк, просто и сохраняется контекст страницы:

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();

Фиксированный размер с перекрытием

Длинный текст разбивают на чанки фиксированной длины с перекрытием:

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  # символов
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);
}

Пакетная обработка тысяч PDF

При 0,8 мс на страницу PDF Oxide справляется с большими корпусами влёт:

from pdf_oxide import PdfDocument, PdfError
from pathlib import Path

pdf_files = list(Path("corpus/").glob("**/*.pdf"))
print(f"Обрабатывается PDF: {len(pdf_files)}...")

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"Извлечено документов: {len(all_chunks)}, ошибок: {errors}")

Сканированные PDF в пайплайне

В любом корпусе попадаются PDF, собранные из сканов. Для таких случаев используйте OCR как резерв:

from pdf_oxide import PdfDocument

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

if len(text.strip()) < 50:
    # Скорее всего, сканированная страница — включить OCR
    text = doc.extract_text_ocr(0)

Детали настройки — в руководстве по OCR.

Почему Markdown, а не обычный текст

Свойство Обычный текст Markdown
Иерархия заголовков Теряется Сохраняется (#, ##, ###)
Таблицы Сводятся в строку Синтаксис таблиц GFM
Жирный/курсив Теряются **жирный**, *курсив*
Семантический чанкинг Затруднён Разделение по заголовкам
Понимание LLM Ниже Выше (структурированный ввод)

Markdown даёт LLM больше контекста о структуре документа и тем самым повышает качество поиска и генерации.

Производительность на масштабе

Размер корпуса PDF Oxide pypdf pdfplumber
1 000 страниц 0,8 с 12,1 с 23,2 с
10 000 страниц 8 с 121 с 232 с
100 000 страниц 80 с 1 210 с 2 320 с
Доля успеха 100 % 98,4 % 98,8 %

При 100 % успешной обработке не приходится вручную выяснять, почему в индексе не хватает документов.

Связанные страницы