Xberg

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

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

Version 5.0.0-rc.17 Release This is a pre-release version. We invite you to test the library and report any issues you encounter.

Note: The Rust crate is not currently published to crates.io for this RC. Use git dependencies or language bindings (Python, TypeScript, Ruby) instead.

Installation

[dependencies]
xberg = "5.0.0-rc.17"
tokio = { version = "1", features = ["rt", "macros"] }

PDFium Linking Options

Xberg offers flexible PDFium linking strategies for different deployment scenarios. Note: Language bindings (Python, TypeScript, Ruby, Java, Go, C#, PHP, Elixir) automatically bundle PDFium—no configuration needed. This section applies only to the Rust crate.

Example Cargo.toml configurations:

# Default (dynamic linking)
[dependencies]
xberg = "5.0.0-rc.17"

# Static linking
[dependencies]
xberg = { version = "5.0.0-rc.17", features = ["pdf-static"] }

# Bundled in binary
[dependencies]
xberg = { version = "5.0.0-rc.17", features = ["pdf-bundled"] }

# System library (requires PDFium installed)
[dependencies]
xberg = { version = "5.0.0-rc.17", features = ["pdf-system"] }

For more details on feature flags and configuration options, 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(())
}

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 306 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 = "5.0.0-rc.17", features = ["pdf", "excel", "ocr"] }

Available Features

Feature Bundles

xberg = { version = "5.0.0-rc.17", features = ["full"] }
xberg = { version = "5.0.0-rc.17", features = ["server"] }
xberg = { version = "5.0.0-rc.17", features = ["cli"] }

PDF Support

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

[dependencies]
xberg = { version = "5.0", 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.