Xberg

High-performance document intelligence library for Rust. Extract text, metadata, transcripts, and structured information from PDFs, Office documents, images, audio/video, and 107 formats.

This is the core Rust library that powers the Python, TypeScript, and Ruby bindings.

Version 1.1.3

Installation

[dependencies]
xberg = "1.1.3"
tokio = { version = "1", features = ["rt", "macros"] }

Xberg uses a pure-Rust PDF backend (xberg-native-pdf) — no PDFium, no system libraries, and no linking configuration required. For the full list of Cargo feature flags, see the Xberg documentation.

System Requirements

ONNX Runtime (for embeddings)

If using embeddings functionality, ONNX Runtime must be installed:

# macOS
brew install onnxruntime

# Ubuntu/Debian
sudo apt install libonnxruntime libonnxruntime-dev

# Windows (MSVC)
scoop install onnxruntime
# OR download from https://github.com/microsoft/onnxruntime/releases

Without ONNX Runtime, embeddings will raise MissingDependencyError with installation instructions.

Quick Start

use xberg::{extract, ExtractInput, ExtractionConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig::default();
    let output = extract(ExtractInput::from_uri("document.pdf"), &config).await?;
    let document = &output.results[0];
    println!("{}", document.content);
    Ok(())
}

Async Extraction

use xberg::{extract, ExtractInput, ExtractionConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig::default();
    let output = extract(ExtractInput::from_uri("document.pdf"), &config).await?;
    let document = &output.results[0];
    println!("{}", document.content);
    Ok(())
}

Batch Processing

use xberg::{extract_batch, ExtractInput, ExtractionConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig::default();
    let inputs = vec![
        ExtractInput::from_uri("doc1.pdf"),
        ExtractInput::from_uri("doc2.pdf"),
        ExtractInput::from_uri("doc3.pdf"),
    ];
    let output = extract_batch(inputs, &config).await?;

    for document in output.results {
        println!("{}", document.content);
    }
    Ok(())
}

MIME Detection Policy

ExtractionConfig::mime_detection_policy defaults to MimeDetectionPolicy::PreferContent. Use TrustExtension to skip content sniffing when the filename has a supported extension, or ContentOnly to ignore filename extensions. A specific explicit ExtractInput::mime_type remains authoritative; application/octet-stream is treated as a generic placeholder and falls back to policy-based detection. A FileExtractionConfig override can select a different policy for one batch item. Because uploaded and downloaded filenames are attacker-controlled, use TrustExtension only for trusted sources; a misleading extension can otherwise route content to the wrong extractor.

OCR with Table Extraction

use xberg::{extract, ExtractInput, ExtractionConfig, OcrConfig, TesseractConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig {
        ocr: Some(OcrConfig {
            backend: "tesseract".to_string(),
            language: "eng".to_string(),
            tesseract_config: Some(TesseractConfig {
                enable_table_detection: true,
                ..Default::default()
            }),
        }),
        ..Default::default()
    };

    let output = extract(ExtractInput::from_uri("invoice.pdf"), &config).await?;
    let document = &output.results[0];

    for table in &document.tables {
        println!("{}", table.markdown);
    }
    Ok(())
}

Password-Protected PDFs

use xberg::{extract, ExtractInput, ExtractionConfig, PdfConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig {
        pdf_options: Some(PdfConfig {
            passwords: Some(vec!["password1".to_string(), "password2".to_string()]),
            ..Default::default()
        }),
        ..Default::default()
    };

    let output = extract(ExtractInput::from_uri("protected.pdf"), &config).await?;
    let document = &output.results[0];
    Ok(())
}

Extract from Bytes

use xberg::{extract, ExtractInput, ExtractionConfig};
use std::fs;

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let data = fs::read("document.pdf")?;
    let config = ExtractionConfig::default();
    let input = ExtractInput::from_bytes(data, "application/pdf", Some("document.pdf".to_string()));
    let output = extract(input, &config).await?;
    let document = &output.results[0];
    println!("{}", document.content);
    Ok(())
}

Code Intelligence

Xberg integrates tree-sitter-language-pack to parse and analyze source code files across 371 programming languages. When you extract a source code file, Xberg automatically detects the language and produces structured analysis including functions, classes, imports, exports, symbols, diagnostics, and semantic code chunks.

Code intelligence data is available via the metadata.format field as a FormatMetadata::Code variant containing a ProcessResult.

use xberg::{extract, ExtractInput, ExtractionConfig, TreeSitterConfig, TreeSitterProcessConfig};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig {
        tree_sitter: Some(TreeSitterConfig {
            process: TreeSitterProcessConfig {
                structure: true,
                imports: true,
                exports: true,
                comments: true,
                docstrings: true,
                ..Default::default()
            },
            ..Default::default()
        }),
        ..Default::default()
    };

    let output = extract(ExtractInput::from_uri("app.py"), &config).await?;
    let document = &output.results[0];

    // Access code intelligence from format metadata
    if let Some(xberg::types::FormatMetadata::Code(ref code)) = document.metadata.format {
        println!("Language: {}", code.language);
        println!("Functions/classes: {}", code.structure.len());
        println!("Imports: {}", code.imports.len());

        for item in &code.structure {
            println!("  {:?}: {:?} at line {}", item.kind, item.name, item.span.start_line);
        }

        for chunk in &code.chunks {
            println!("Chunk ({} bytes): {}...", chunk.content.len(), &chunk.content[..50.min(chunk.content.len())]);
        }
    }

    Ok(())
}

Requires the tree-sitter feature flag (included in full). See the Xberg docs for configuration details and examples in all languages.

Features

The crate uses feature flags for optional functionality:

[dependencies]
xberg = { version = "1.1.3", features = ["pdf", "excel", "ocr"] }

Available Features

Feature Bundles

xberg = { version = "1.1.3", features = ["full"] }
xberg = { version = "1.1.3", features = ["server"] }
xberg = { version = "1.1.3", features = ["cli"] }

PDF Support

Xberg uses xberg-native-pdf — a pure-Rust PDF library with no system dependencies. Enable PDF extraction with the pdf feature:

[dependencies]
xberg = { version = "1.1.3", features = ["pdf"] }

No native libraries required. Works on all platforms including musl, Docker, and WASM.

Documentation

API Documentation – Complete API reference with examples

https://docs.xberg.io – User guide and tutorials

License

MIT License (MIT) - see LICENSE for details.