Kreuzberg Document Extraction
Kreuzberg is a high-performance document intelligence library with a Rust core and native bindings for Python, Node.js/TypeScript, Ruby, Go, Java, C#, PHP, and Elixir. It extracts text, tables, metadata, and images from 91+ file formats including PDF, Office documents, images (with OCR), HTML, email, archives, and academic formats.
Use this skill when writing code that:
- Extracts text or metadata from documents
- Performs OCR on scanned documents or images
- Batch-processes multiple files
- Configures extraction options (output format, chunking, OCR, language detection)
- Implements custom plugins (post-processors, validators, OCR backends)
Installation
Python
pip install kreuzberg
# Optional OCR backends:
pip install kreuzberg[easyocr] # EasyOCR
Node.js
npm install @kreuzberg/node
Rust
# Cargo.toml
[dependencies]
kreuzberg = { version = "4", features = ["tokio-runtime"] }
# features: tokio-runtime (required for sync + batch), pdf, ocr, chunking,
# embeddings, language-detection, keywords-yake, keywords-rake
CLI
# Download from GitHub releases, or:
cargo install kreuzberg-cli
Quick Start
Python (Async)
from kreuzberg import extract_file
result = await extract_file("document.pdf")
print(result.content) # extracted text
print(result.metadata) # document metadata
print(result.tables) # extracted tables
Python (Sync)
from kreuzberg import extract_file_sync
result = extract_file_sync("document.pdf")
print(result.content)
Node.js
import { extractFile } from "@kreuzberg/node";
const result = await extractFile("document.pdf");
console.log(result.content);
console.log(result.metadata);
console.log(result.tables);
Node.js (Sync)
import { extractFileSync } from "@kreuzberg/node";
const result = extractFileSync("document.pdf");
Rust (Async)
use kreuzberg::{extract_file, ExtractionConfig};
#[tokio::main]
async fn main() -> kreuzberg::Result<()> {
let config = ExtractionConfig::default();
let result = extract_file("document.pdf", None, &config).await?;
println!("{}", result.content);
Ok(())
}
Rust (Sync) — requires tokio-runtime feature
use kreuzberg::{extract_file_sync, ExtractionConfig};
fn main() -> kreuzberg::Result<()> {
let config = ExtractionConfig::default();
let result = extract_file_sync("document.pdf", None, &config)?;
println!("{}", result.content);
Ok(())
}
CLI
kreuzberg extract document.pdf
kreuzberg extract document.pdf --format json
kreuzberg extract document.pdf --output-format markdown
Configuration
All languages use the same configuration structure with language-appropriate naming conventions.
Python (snake_case)
from kreuzberg import (
ExtractionConfig, OcrConfig, TesseractConfig,
PdfConfig, ChunkingConfig,
)
config = ExtractionConfig(
ocr=OcrConfig(
backend="tesseract",
language="eng",
tesseract_config=TesseractConfig(psm=6, enable_table_detection=True),
),
pdf_options=PdfConfig(passwords=["secret123"]),
chunking=ChunkingConfig(max_chars=1000, max_overlap=200),
output_format="markdown",
)
result = await extract_file("document.pdf", config=config)
Node.js (camelCase)
import { extractFile, type ExtractionConfig } from "@kreuzberg/node";
const config: ExtractionConfig = {
ocr: { backend: "tesseract", language: "eng" },
pdfOptions: { passwords: ["secret123"] },
chunking: { maxChars: 1000, maxOverlap: 200 },
outputFormat: "markdown",
};
const result = await extractFile("document.pdf", null, config);
Rust (snake_case)
use kreuzberg::{ExtractionConfig, OcrConfig, ChunkingConfig, OutputFormat};
let config = ExtractionConfig {
ocr: Some(OcrConfig {
backend: "tesseract".into(),
language: "eng".into(),
..Default::default()
}),
chunking: Some(ChunkingConfig {
max_characters: 1000,
overlap: 200,
..Default::default()
}),
output_format: OutputFormat::Markdown,
..Default::default()
};
let result = extract_file("document.pdf", None, &config).await?;
Config File (TOML)
output_format = "markdown"
[ocr]
backend = "tesseract"
language = "eng"
[chunking]
max_chars = 1000
max_overlap = 200
[pdf_options]
passwords = ["secret123"]
# CLI: auto-discovers kreuzberg.toml in current/parent directories
kreuzberg extract doc.pdf
# or explicit:
kreuzberg extract doc.pdf --config kreuzberg.toml
kreuzberg extract doc.pdf --config-json '{"ocr":{"backend":"tesseract","language":"deu"}}'
Batch Processing
Python
from kreuzberg import batch_extract_files, batch_extract_files_sync
# Async
results = await batch_extract_files(["doc1.pdf", "doc2.docx", "doc3.xlsx"])
# Sync
results = batch_extract_files_sync(["doc1.pdf", "doc2.docx"])
for result in results:
print(f"{len(result.content)} chars extracted")
Node.js
import { batchExtractFiles } from "@kreuzberg/node";
const results = await batchExtractFiles(["doc1.pdf", "doc2.docx"]);
Rust — requires tokio-runtime feature
use kreuzberg::{batch_extract_file, ExtractionConfig};
let config = ExtractionConfig::default();
let paths = vec!["doc1.pdf", "doc2.docx"];
let results = batch_extract_file(paths, &config).await?;
CLI
kreuzberg batch *.pdf --format json
kreuzberg batch docs/*.docx --output-format markdown
OCR
OCR runs automatically for images and scanned PDFs. Tesseract is the default backend (native binding, no external install required).
Backends
- Tesseract (default): Built-in native binding. All Tesseract languages supported.
- EasyOCR (Python only):
pip install kreuzberg[easyocr]. Pass easyocr_kwargs={"gpu": True}.
- PaddleOCR (Python only): Bundled since 4.8.5, no extra install needed. Pass
paddleocr_kwargs={"use_angle_cls": True}.
- Guten (Node.js only): Built-in OCR backend via
GutenOcrBackend.
Language Codes
config = ExtractionConfig(ocr=OcrConfig(language="eng")) # English
config = ExtractionConfig(ocr=OcrConfig(language="eng+deu")) # Multiple
config = ExtractionConfig(ocr=OcrConfig(language="all")) # All installed
Force OCR
config = ExtractionConfig(force_ocr=True) # OCR even if text is extractable
ExtractionResult Fields
| Field |
Python |
Node.js |
Rust |
Description |
| Text content |
result.content |
result.content |
result.content |
Extracted text (str/String) |
| MIME type |
result.mime_type |
result.mimeType |
result.mime_type |
Input document MIME type |
| Metadata |
result.metadata |
result.metadata |
result.metadata |
Document metadata (dict/object/HashMap) |
| Tables |
result.tables |
result.tables |
result.tables |
Extracted tables with cells + markdown |
| Languages |
result.detected_languages |
result.detectedLanguages |
result.detected_languages |
Detected languages (if enabled) |
| Chunks |
result.chunks |
result.chunks |
result.chunks |
Text chunks (if chunking enabled) |
| Images |
result.images |
result.images |
result.images |
Extracted images (if enabled) |
| Elements |
result.elements |
result.elements |
result.elements |
Semantic elements (if element_based format) |
| Pages |
result.pages |
result.pages |
result.pages |
Per-page content (if page extraction enabled) |
| Keywords |
result.keywords |
result.keywords |
result.keywords |
Extracted keywords (if enabled) |
Error Handling
Python
from kreuzberg import (
extract_file_sync, KreuzbergError, ParsingError,
OCRError, ValidationError, MissingDependencyError,
)
try:
result = extract_file_sync("file.pdf")
except ParsingError as e:
print(f"Failed to parse: {e}")
except OCRError as e:
print(f"OCR failed: {e}")
except ValidationError as e:
print(f"Invalid input: {e}")
except MissingDependencyError as e:
print(f"Missing dependency: {e}")
except KreuzbergError as e:
print(f"Extraction failed: {e}")
Node.js
import {
extractFile,
KreuzbergError,
ParsingError,
OcrError,
ValidationError,
MissingDependencyError,
} from "@kreuzberg/node";
try {
const result = await extractFile("file.pdf");
} catch (e) {
if (e instanceof ParsingError) {
/* ... */
} else if (e instanceof OcrError) {
/* ... */
} else if (e instanceof ValidationError) {
/* ... */
} else if (e instanceof KreuzbergError) {
/* ... */
}
}
Rust
use kreuzberg::{extract_file, ExtractionConfig, KreuzbergError};
let config = ExtractionConfig::default();
match extract_file("file.pdf", None, &config).await {
Ok(result) => println!("{}", result.content),
Err(KreuzbergError::Parsing(msg)) => eprintln!("Parse error: {msg}"),
Err(KreuzbergError::Ocr(msg)) => eprintln!("OCR error: {msg}"),
Err(e) => eprintln!("Error: {e}"),
}
Common Pitfalls
- Python ChunkingConfig fields: Use
max_chars and max_overlap, NOT max_characters or overlap.
- Rust extract_file signature: Third argument is
&ExtractionConfig (a reference), not Option. Use &ExtractionConfig::default() for defaults.
- Rust feature gates:
extract_file_sync, batch_extract_file, and batch_extract_file_sync all require features = ["tokio-runtime"] in Cargo.toml.
- Rust async context:
extract_file is async. Use #[tokio::main] or call from an async context.
- CLI --format vs --output-format:
--format controls CLI output (text/json). --output-format controls content format (plain/markdown/djot/html).
- Node.js extractFile signature:
extractFile(path, mimeType?, config?) — mimeType is the second arg (pass null to skip).
- Python detect_mime_type: The function for detecting from bytes is
detect_mime_type(data). For paths use detect_mime_type_from_path(path).
- Config file field names: Use snake_case in TOML/YAML/JSON config files (e.g.,
max_chars, max_overlap, pdf_options).
Supported Formats (Summary)
| Category |
Extensions |
| PDF |
.pdf |
| Word |
.docx, .odt |
| Spreadsheets |
.xlsx, .xlsm, .xlsb, .xls, .xla, .xlam, .xltm, .ods |
| Presentations |
.pptx, .ppt, .ppsx |
| eBooks |
.epub, .fb2 |
| Images |
.png, .jpg, .jpeg, .gif, .webp, .bmp, .tiff, .tif, .jp2, .jpx, .jpm, .mj2, .jbig2, .jb2, .pnm, .pbm, .pgm, .ppm, .svg |
| Markup |
.html, .htm, .xhtml, .xml |
| Data |
.json, .yaml, .yml, .toml, .csv, .tsv |
| Text |
.txt, .md, .markdown, .djot, .rst, .org, .rtf |
| Email |
.eml, .msg |
| Archives |
.zip, .tar, .tgz, .gz, .7z |
| Academic |
.bib, .biblatex, .ris, .nbib, .enw, .csl, .tex, .latex, .typ, .jats, .ipynb, .docbook, .opml, .pod, .mdoc, .troff |
See references/supported-formats.md for the complete format reference with MIME types.
Additional Resources
Detailed reference files for specific topics:
- Python API Reference — All functions, config classes, plugin protocols, exact signatures
- Node.js API Reference — All functions, TypeScript interfaces, worker pool APIs
- Rust API Reference — All functions with feature gates, structs, Cargo.toml examples
- CLI Reference — All commands, flags, config precedence, exit codes
- Configuration Reference — TOML/YAML/JSON formats, auto-discovery, env vars, full schema
- Supported Formats — All 85+ formats with file extensions and MIME types
- Advanced Features — Plugins, embeddings, MCP server, API server, security limits
- Other Language Bindings — Go, Ruby, Java, C#, PHP, Elixir, WASM, Docker
Full documentation: https://docs.kreuzberg.dev
GitHub: https://github.com/kreuzberg-dev/kreuzberg
1---2name: kreuzberg3description: >-4 Extract text, tables, metadata, and images from 91+ document formats5 (PDF, Office, images, HTML, email, archives, academic) using Kreuzberg.6 Use when writing code that calls Kreuzberg APIs in Python, Node.js/TypeScript,7 Rust, or CLI. Covers installation, extraction (sync/async), configuration8 (OCR, chunking, output format), batch processing, error handling, and plugins.9license: Elastic-2.010metadata:11 source: https://skillmd.com/skills/zuoguyoupan2023/kreuzberg12 author: kreuzberg-dev13 version: "1.0"14 repository: https://github.com/kreuzberg-dev/kreuzberg15---1617# Kreuzberg Document Extraction1819Kreuzberg is a high-performance document intelligence library with a Rust core and native bindings for Python, Node.js/TypeScript, Ruby, Go, Java, C#, PHP, and Elixir. It extracts text, tables, metadata, and images from 91+ file formats including PDF, Office documents, images (with OCR), HTML, email, archives, and academic formats.2021Use this skill when writing code that:2223- Extracts text or metadata from documents24- Performs OCR on scanned documents or images25- Batch-processes multiple files26- Configures extraction options (output format, chunking, OCR, language detection)27- Implements custom plugins (post-processors, validators, OCR backends)2829## Installation3031### Python3233```bash34pip install kreuzberg35# Optional OCR backends:36pip install kreuzberg[easyocr] # EasyOCR37```3839### Node.js4041```bash42npm install @kreuzberg/node43```4445### Rust4647```toml48# Cargo.toml49[dependencies]50kreuzberg = { version = "4", features = ["tokio-runtime"] }51# features: tokio-runtime (required for sync + batch), pdf, ocr, chunking,52# embeddings, language-detection, keywords-yake, keywords-rake53```5455### CLI5657```bash58# Download from GitHub releases, or:59cargo install kreuzberg-cli60```6162## Quick Start6364### Python (Async)6566```python67from kreuzberg import extract_file6869result = await extract_file("document.pdf")70print(result.content) # extracted text71print(result.metadata) # document metadata72print(result.tables) # extracted tables73```7475### Python (Sync)7677```python78from kreuzberg import extract_file_sync7980result = extract_file_sync("document.pdf")81print(result.content)82```8384### Node.js8586```typescript87import { extractFile } from "@kreuzberg/node";8889const result = await extractFile("document.pdf");90console.log(result.content);91console.log(result.metadata);92console.log(result.tables);93```9495### Node.js (Sync)9697```typescript98import { extractFileSync } from "@kreuzberg/node";99100const result = extractFileSync("document.pdf");101```102103### Rust (Async)104105```rust106use kreuzberg::{extract_file, ExtractionConfig};107108#[tokio::main]109async fn main() -> kreuzberg::Result<()> {110 let config = ExtractionConfig::default();111 let result = extract_file("document.pdf", None, &config).await?;112 println!("{}", result.content);113 Ok(())114}115```116117### Rust (Sync) — requires `tokio-runtime` feature118119```rust120use kreuzberg::{extract_file_sync, ExtractionConfig};121122fn main() -> kreuzberg::Result<()> {123 let config = ExtractionConfig::default();124 let result = extract_file_sync("document.pdf", None, &config)?;125 println!("{}", result.content);126 Ok(())127}128```129130### CLI131132```bash133kreuzberg extract document.pdf134kreuzberg extract document.pdf --format json135kreuzberg extract document.pdf --output-format markdown136```137138## Configuration139140All languages use the same configuration structure with language-appropriate naming conventions.141142### Python (snake_case)143144```python145from kreuzberg import (146 ExtractionConfig, OcrConfig, TesseractConfig,147 PdfConfig, ChunkingConfig,148)149150config = ExtractionConfig(151 ocr=OcrConfig(152 backend="tesseract",153 language="eng",154 tesseract_config=TesseractConfig(psm=6, enable_table_detection=True),155 ),156 pdf_options=PdfConfig(passwords=["secret123"]),157 chunking=ChunkingConfig(max_chars=1000, max_overlap=200),158 output_format="markdown",159)160161result = await extract_file("document.pdf", config=config)162```163164### Node.js (camelCase)165166```typescript167import { extractFile, type ExtractionConfig } from "@kreuzberg/node";168169const config: ExtractionConfig = {170 ocr: { backend: "tesseract", language: "eng" },171 pdfOptions: { passwords: ["secret123"] },172 chunking: { maxChars: 1000, maxOverlap: 200 },173 outputFormat: "markdown",174};175176const result = await extractFile("document.pdf", null, config);177```178179### Rust (snake_case)180181```rust182use kreuzberg::{ExtractionConfig, OcrConfig, ChunkingConfig, OutputFormat};183184let config = ExtractionConfig {185 ocr: Some(OcrConfig {186 backend: "tesseract".into(),187 language: "eng".into(),188 ..Default::default()189 }),190 chunking: Some(ChunkingConfig {191 max_characters: 1000,192 overlap: 200,193 ..Default::default()194 }),195 output_format: OutputFormat::Markdown,196 ..Default::default()197};198199let result = extract_file("document.pdf", None, &config).await?;200```201202### Config File (TOML)203204```toml205output_format = "markdown"206207[ocr]208backend = "tesseract"209language = "eng"210211[chunking]212max_chars = 1000213max_overlap = 200214215[pdf_options]216passwords = ["secret123"]217```218219```bash220# CLI: auto-discovers kreuzberg.toml in current/parent directories221kreuzberg extract doc.pdf222# or explicit:223kreuzberg extract doc.pdf --config kreuzberg.toml224kreuzberg extract doc.pdf --config-json '{"ocr":{"backend":"tesseract","language":"deu"}}'225```226227## Batch Processing228229### Python230231```python232from kreuzberg import batch_extract_files, batch_extract_files_sync233234# Async235results = await batch_extract_files(["doc1.pdf", "doc2.docx", "doc3.xlsx"])236237# Sync238results = batch_extract_files_sync(["doc1.pdf", "doc2.docx"])239240for result in results:241 print(f"{len(result.content)} chars extracted")242```243244### Node.js245246```typescript247import { batchExtractFiles } from "@kreuzberg/node";248249const results = await batchExtractFiles(["doc1.pdf", "doc2.docx"]);250```251252### Rust — requires `tokio-runtime` feature253254```rust255use kreuzberg::{batch_extract_file, ExtractionConfig};256257let config = ExtractionConfig::default();258let paths = vec!["doc1.pdf", "doc2.docx"];259let results = batch_extract_file(paths, &config).await?;260```261262### CLI263264```bash265kreuzberg batch *.pdf --format json266kreuzberg batch docs/*.docx --output-format markdown267```268269## OCR270271OCR runs automatically for images and scanned PDFs. Tesseract is the default backend (native binding, no external install required).272273### Backends274275- **Tesseract** (default): Built-in native binding. All Tesseract languages supported.276- **EasyOCR** (Python only): `pip install kreuzberg[easyocr]`. Pass `easyocr_kwargs={"gpu": True}`.277- **PaddleOCR** (Python only): Bundled since 4.8.5, no extra install needed. Pass `paddleocr_kwargs={"use_angle_cls": True}`.278- **Guten** (Node.js only): Built-in OCR backend via `GutenOcrBackend`.279280### Language Codes281282```python283config = ExtractionConfig(ocr=OcrConfig(language="eng")) # English284config = ExtractionConfig(ocr=OcrConfig(language="eng+deu")) # Multiple285config = ExtractionConfig(ocr=OcrConfig(language="all")) # All installed286```287288### Force OCR289290```python291config = ExtractionConfig(force_ocr=True) # OCR even if text is extractable292```293294## ExtractionResult Fields295296| Field | Python | Node.js | Rust | Description |297| ------------ | --------------------------- | -------------------------- | --------------------------- | --------------------------------------------- |298| Text content | `result.content` | `result.content` | `result.content` | Extracted text (str/String) |299| MIME type | `result.mime_type` | `result.mimeType` | `result.mime_type` | Input document MIME type |300| Metadata | `result.metadata` | `result.metadata` | `result.metadata` | Document metadata (dict/object/HashMap) |301| Tables | `result.tables` | `result.tables` | `result.tables` | Extracted tables with cells + markdown |302| Languages | `result.detected_languages` | `result.detectedLanguages` | `result.detected_languages` | Detected languages (if enabled) |303| Chunks | `result.chunks` | `result.chunks` | `result.chunks` | Text chunks (if chunking enabled) |304| Images | `result.images` | `result.images` | `result.images` | Extracted images (if enabled) |305| Elements | `result.elements` | `result.elements` | `result.elements` | Semantic elements (if element_based format) |306| Pages | `result.pages` | `result.pages` | `result.pages` | Per-page content (if page extraction enabled) |307| Keywords | `result.keywords` | `result.keywords` | `result.keywords` | Extracted keywords (if enabled) |308309## Error Handling310311### Python312313```python314from kreuzberg import (315 extract_file_sync, KreuzbergError, ParsingError,316 OCRError, ValidationError, MissingDependencyError,317)318319try:320 result = extract_file_sync("file.pdf")321except ParsingError as e:322 print(f"Failed to parse: {e}")323except OCRError as e:324 print(f"OCR failed: {e}")325except ValidationError as e:326 print(f"Invalid input: {e}")327except MissingDependencyError as e:328 print(f"Missing dependency: {e}")329except KreuzbergError as e:330 print(f"Extraction failed: {e}")331```332333### Node.js334335```typescript336import {337 extractFile,338 KreuzbergError,339 ParsingError,340 OcrError,341 ValidationError,342 MissingDependencyError,343} from "@kreuzberg/node";344345try {346 const result = await extractFile("file.pdf");347} catch (e) {348 if (e instanceof ParsingError) {349 /* ... */350 } else if (e instanceof OcrError) {351 /* ... */352 } else if (e instanceof ValidationError) {353 /* ... */354 } else if (e instanceof KreuzbergError) {355 /* ... */356 }357}358```359360### Rust361362```rust363use kreuzberg::{extract_file, ExtractionConfig, KreuzbergError};364365let config = ExtractionConfig::default();366match extract_file("file.pdf", None, &config).await {367 Ok(result) => println!("{}", result.content),368 Err(KreuzbergError::Parsing(msg)) => eprintln!("Parse error: {msg}"),369 Err(KreuzbergError::Ocr(msg)) => eprintln!("OCR error: {msg}"),370 Err(e) => eprintln!("Error: {e}"),371}372```373374## Common Pitfalls3753761. **Python ChunkingConfig fields**: Use `max_chars` and `max_overlap`, NOT `max_characters` or `overlap`.3772. **Rust extract_file signature**: Third argument is `&ExtractionConfig` (a reference), not `Option`. Use `&ExtractionConfig::default()` for defaults.3783. **Rust feature gates**: `extract_file_sync`, `batch_extract_file`, and `batch_extract_file_sync` all require `features = ["tokio-runtime"]` in Cargo.toml.3794. **Rust async context**: `extract_file` is async. Use `#[tokio::main]` or call from an async context.3805. **CLI --format vs --output-format**: `--format` controls CLI output (text/json). `--output-format` controls content format (plain/markdown/djot/html).3816. **Node.js extractFile signature**: `extractFile(path, mimeType?, config?)` — mimeType is the second arg (pass `null` to skip).3827. **Python detect_mime_type**: The function for detecting from bytes is `detect_mime_type(data)`. For paths use `detect_mime_type_from_path(path)`.3838. **Config file field names**: Use snake_case in TOML/YAML/JSON config files (e.g., `max_chars`, `max_overlap`, `pdf_options`).384385## Supported Formats (Summary)386387| Category | Extensions |388| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |389| **PDF** | `.pdf` |390| **Word** | `.docx`, `.odt` |391| **Spreadsheets** | `.xlsx`, `.xlsm`, `.xlsb`, `.xls`, `.xla`, `.xlam`, `.xltm`, `.ods` |392| **Presentations** | `.pptx`, `.ppt`, `.ppsx` |393| **eBooks** | `.epub`, `.fb2` |394| **Images** | `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`, `.bmp`, `.tiff`, `.tif`, `.jp2`, `.jpx`, `.jpm`, `.mj2`, `.jbig2`, `.jb2`, `.pnm`, `.pbm`, `.pgm`, `.ppm`, `.svg` |395| **Markup** | `.html`, `.htm`, `.xhtml`, `.xml` |396| **Data** | `.json`, `.yaml`, `.yml`, `.toml`, `.csv`, `.tsv` |397| **Text** | `.txt`, `.md`, `.markdown`, `.djot`, `.rst`, `.org`, `.rtf` |398| **Email** | `.eml`, `.msg` |399| **Archives** | `.zip`, `.tar`, `.tgz`, `.gz`, `.7z` |400| **Academic** | `.bib`, `.biblatex`, `.ris`, `.nbib`, `.enw`, `.csl`, `.tex`, `.latex`, `.typ`, `.jats`, `.ipynb`, `.docbook`, `.opml`, `.pod`, `.mdoc`, `.troff` |401402See [references/supported-formats.md](references/supported-formats.md) for the complete format reference with MIME types.403404## Additional Resources405406Detailed reference files for specific topics:407408- **[Python API Reference](references/python-api.md)** — All functions, config classes, plugin protocols, exact signatures409- **[Node.js API Reference](references/nodejs-api.md)** — All functions, TypeScript interfaces, worker pool APIs410- **[Rust API Reference](references/rust-api.md)** — All functions with feature gates, structs, Cargo.toml examples411- **[CLI Reference](references/cli-reference.md)** — All commands, flags, config precedence, exit codes412- **[Configuration Reference](references/configuration.md)** — TOML/YAML/JSON formats, auto-discovery, env vars, full schema413- **[Supported Formats](references/supported-formats.md)** — All 85+ formats with file extensions and MIME types414- **[Advanced Features](references/advanced-features.md)** — Plugins, embeddings, MCP server, API server, security limits415- **[Other Language Bindings](references/other-bindings.md)** — Go, Ruby, Java, C#, PHP, Elixir, WASM, Docker416417Full documentation: <https://docs.kreuzberg.dev>418GitHub: <https://github.com/kreuzberg-dev/kreuzberg>