Kreuzberg

https://docs.kreuzberg.dev/reference
Admin
Kreuzberg is a high-performance document extraction library supporting 91+ file formats with native...
Tokens:239,319
Snippets:2,226
Trust Score:6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Asynchronous File Extraction Example

Source: https://docs.kreuzberg.dev/reference/api-php

Demonstrates starting an async file extraction and handling the result via polling or blocking.

```php

<?php


use Kreuzberg\Kreuzberg;


$kreuzberg = new Kreuzberg();


// Start async extraction
$deferred = $kreuzberg->extractFileAsync('large_document.pdf');


// Do other work while extraction runs in background...
processOtherTasks();


// Check if ready (non-blocking)
if ($deferred->isReady()) {
    $result = $deferred->getResult();
    echo $result->content;
}


// Or block until ready
$result = $deferred->getResult();
echo $result->content;

```

--------------------------------

### Initialize KeywordConfig

Source: https://docs.kreuzberg.dev/reference/api-php

Example of instantiating the KeywordConfig class.

```php
<?php


use Kreuzberg\Config\KeywordConfig;


$config = new KeywordConfig(
    enabled: true,
    algorithm: 'rake',
    maxKeywords: 15
);
```

--------------------------------

### Using Kreuzberg::MCPProxy

Source: https://docs.kreuzberg.dev/reference/api-ruby

Initializes and starts the MCP server.

```ruby

mcp = Kreuzberg::MCPProxy.new


# Start MCP server (blocks)
mcp.start

```

--------------------------------

### Initialize ImageExtractionConfig

Source: https://docs.kreuzberg.dev/reference/api-php

Example of instantiating the ImageExtractionConfig class.

```php
<?php


use Kreuzberg\Config\ImageExtractionConfig;
use Kreuzberg\Config\OcrConfig;


$config = new ImageExtractionConfig(
    extractImages: true,
    performOcr: true,
    minWidth: 200,
    minHeight: 200
);
```

--------------------------------

### Initialize PageConfig

Source: https://docs.kreuzberg.dev/reference/api-php

Example of instantiating the PageConfig class.

```php
<?php


use Kreuzberg\Config\PageConfig;


$config = new PageConfig(
    extractPages: true,
    insertPageMarkers: true,
    markerFormat: '=== Page {page_number} ==='
);
```

--------------------------------

### Initialize LanguageDetectionConfig

Source: https://docs.kreuzberg.dev/reference/api-php

Example of instantiating the LanguageDetectionConfig class.

```php
<?php


use Kreuzberg\Config\LanguageDetectionConfig;


$config = new LanguageDetectionConfig(
    enabled: true,
    maxLanguages: 5,
    confidenceThreshold: 0.9
);
```

--------------------------------

### HierarchyConfig Usage Examples

Source: https://docs.kreuzberg.dev/reference/types

Examples of initializing HierarchyConfig and integrating it into extraction configurations across different languages.

```rust
use kreuzberg::core::config::HierarchyConfig;


let hierarchy = HierarchyConfig {
    enabled: true,
    k_clusters: 6,
    include_bbox: true,
    ocr_coverage_threshold: Some(0.5),
};
```

```python
from kreuzberg import HierarchyConfig, ExtractionConfig, PdfConfig


hierarchy = HierarchyConfig(
    enabled=True,
    k_clusters=6,
    include_bbox=True,
    ocr_coverage_threshold=0.5
)


pdf_config = PdfConfig(hierarchy=hierarchy)
config = ExtractionConfig(pdf_options=pdf_config)
```

```typescript
const hierarchyConfig: HierarchyConfig = {
  enabled: true,
  kClusters: 6,
  includeBbox: true,
  ocrCoverageThreshold: 0.5,
};


const pdfConfig: PdfConfig = {
  hierarchy: hierarchyConfig,
};
```

```java
HierarchyConfig hierarchyConfig = HierarchyConfig.builder()
    .enabled(true)
    .kClusters(6)
    .includeBbox(true)
    .ocrCoverageThreshold(0.5)
    .build();


PdfConfig pdfConfig = PdfConfig.builder()
    .hierarchy(hierarchyConfig)
    .build();
```

```go
hierarchyConfig := &kreuzberg.HierarchyConfig{
    Enabled:              kreuzberg.BoolPtr(true),
    KClusters:           kreuzberg.IntPtr(6),
    IncludeBbox:         kreuzberg.BoolPtr(true),
    OcrCoverageThreshold: kreuzberg.FloatPtr(0.5),
}


pdfConfig := &kreuzberg.PdfConfig{
    Hierarchy: hierarchyConfig,
}
```

--------------------------------

### Initialize PdfConfig

Source: https://docs.kreuzberg.dev/reference/api-rust

Example instantiation of PdfConfig with custom extraction settings.

```rust
use kreuzberg::PdfConfig;


let pdf_config = PdfConfig {
    allow_single_column_tables: false,
    extract_images: true,
    passwords: Some(vec!["password1".to_string(), "password2".to_string()]),
    extract_metadata: true,
    hierarchy: None,
};
```

--------------------------------

### Configure Acceleration in Python

Source: https://docs.kreuzberg.dev/reference/configuration

Examples for setting up hardware acceleration using the Python SDK.

```python
from kreuzberg import ExtractionConfig, AccelerationConfig


# Force CUDA on GPU 0; falls back to CPU if CUDA isn't compiled in
config = ExtractionConfig(
    acceleration=AccelerationConfig(provider="cuda", device_id=0)
)


# macOS: explicitly use CoreML for ONNX inference
coreml_config = ExtractionConfig(
    acceleration=AccelerationConfig(provider="coreml")
)
```

--------------------------------

### ExtractFromFile() Usage Examples

Source: https://docs.kreuzberg.dev/reference/api-wasm

Examples for handling browser file inputs and applying extraction configurations.

```typescript

import { initWasm, extractFromFile } from '@kreuzberg/wasm';


await initWasm();


const fileInput = document.getElementById('file') as HTMLInputElement;
fileInput.addEventListener('change', async (e) => {
  const file = e.target.files?.[0];
  if (file) {
    const result = await extractFromFile(file);
    console.log(result.content);
  }
});

```

```typescript

import { extractFromFile } from '@kreuzberg/wasm';


const result = await extractFromFile(file, file.type, {
  chunking: { maxChars: 1000 },
  images: { extractImages: true }
});

```

--------------------------------

### Install @kreuzberg/wasm

Source: https://docs.kreuzberg.dev/reference/api-wasm

Installation commands for various package managers.

```bash
npm install @kreuzberg/wasm
```

```bash
# Yarn
yarn add @kreuzberg/wasm


# pnpm
pnpm add @kreuzberg/wasm
```

--------------------------------

### ExtractionConfig Usage Examples

Source: https://docs.kreuzberg.dev/reference/api-php

Basic and advanced instantiation examples for the ExtractionConfig class.

```php

<?php


use Kreuzberg\Config\ExtractionConfig;
use Kreuzberg\Config\OcrConfig;
use Kreuzberg\Config\PdfConfig;


// Basic configuration
$config = new ExtractionConfig(
    extractImages: true,
    extractTables: true
);


// Advanced configuration
$config = new ExtractionConfig(
    chunking: new ChunkingConfig(maxChunkSize: 1000),
    extractImages: true,
    extractTables: true,
    ocr: new OcrConfig(
        backend: 'tesseract',
        language: 'eng'
    ),
    pdf: new PdfConfig(
        extractImages: true,
        extractMetadata: true
    )
);

```

--------------------------------

### Install Kreuzberg

Source: https://docs.kreuzberg.dev/reference/api-python

Installation commands for the base package and various feature sets.

```bash
pip install kreuzberg
```

```bash
pip install "kreuzberg[easyocr]"
```

```bash
pip install "kreuzberg[api]"
```

```bash
pip install "kreuzberg[all]"
```

--------------------------------

### Install Core Dependency

Source: https://docs.kreuzberg.dev/reference/api-wasm

Install the required peer dependency for the WASM package.

```bash
npm install @kreuzberg/core
```

--------------------------------

### Install Tesseract OCR

Source: https://docs.kreuzberg.dev/reference/formats

System-level installation commands for Tesseract OCR across various operating systems.

```bash
# Install Tesseract OCR on macOS
brew install tesseract


# Install Tesseract OCR on Ubuntu/Debian
sudo apt-get install tesseract-ocr


# Install Tesseract OCR on RHEL/CentOS/Fedora
sudo dnf install tesseract


# Install Tesseract OCR on Windows (using Scoop)
scoop install tesseract
```

--------------------------------

### Install @kreuzberg/node package

Source: https://docs.kreuzberg.dev/reference/api-typescript

Use these commands to install the package via npm, yarn, or pnpm.

```bash

npm install @kreuzberg/node

```

```bash

# Yarn
yarn add @kreuzberg/node


# pnpm
pnpm add @kreuzberg/node

```

--------------------------------

### ExtractBytes() Usage Examples

Source: https://docs.kreuzberg.dev/reference/api-wasm

Examples demonstrating basic PDF extraction, extraction with custom configuration, and browser-based file processing.

```typescript

import { initWasm, extractBytes } from '@kreuzberg/wasm';


await initWasm();


const pdfBytes = new Uint8Array(buffer);
const result = await extractBytes(pdfBytes, 'application/pdf');
console.log(result.content);
console.log(`Found ${result.tables?.length ?? 0} tables`);

```

```typescript

import { initWasm, extractBytes } from '@kreuzberg/wasm';
import type { ExtractionConfig } from '@kreuzberg/wasm';


await initWasm();


const config: ExtractionConfig = {
  ocr: {
    backend: 'tesseract-wasm',
    language: 'deu' // German
  },
  images: {
    extractImages: true,
    targetDpi: 200
  }
};


const result = await extractBytes(pdfBytes, 'application/pdf', config);

```

```typescript

import { initWasm, extractBytes } from '@kreuzberg/wasm';
import { fileToUint8Array } from '@kreuzberg/wasm/adapters/wasm-adapter';


await initWasm();


const file = inputEvent.target.files[0];
const bytes = await fileToUint8Array(file);
const result = await extractBytes(bytes, file.type);
console.log(result.content);

```

--------------------------------

### ExtractFile() Usage Examples

Source: https://docs.kreuzberg.dev/reference/api-wasm

Examples for extracting files with auto-detection, explicit MIME types, and custom configuration.

```typescript

import { extractFile } from '@kreuzberg/wasm';


const result = await extractFile('./document.pdf');
console.log(result.content);

```

```typescript

import { extractFile } from '@kreuzberg/wasm';


const result = await extractFile('./document.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
console.log(result.content);

```

```typescript

import { extractFile } from '@kreuzberg/wasm';


const result = await extractFile('./report.xlsx', null, {
  chunking: {
    maxChars: 1000
  }
});

```

--------------------------------

### Initialize LayoutDetectionConfig

Source: https://docs.kreuzberg.dev/reference/api-php

Example of instantiating the LayoutDetectionConfig within an ExtractionConfig.

```php
<?php


use Kreuzberg\Config\LayoutDetectionConfig;
use Kreuzberg\Config\ExtractionConfig;


$config = new ExtractionConfig(
    layout: new LayoutDetectionConfig(
        confidenceThreshold: 0.5,
        applyHeuristics: true
    )
);
```

--------------------------------

### OcrConfig Usage Example

Source: https://docs.kreuzberg.dev/reference/api-rust

Basic initialization of the OcrConfig structure using the tesseract backend.

```rust
use kreuzberg::OcrConfig;


// Configure OCR backend and language settings
let ocr_config = OcrConfig {
    backend: "tesseract".to_string(),
    language: "eng".to_string(),
    tesseract_config: None,
    ..Default::default()
};
```

--------------------------------

### Configure Language Detection

Source: https://docs.kreuzberg.dev/reference/configuration

Examples of initializing language detection settings for various programming environments.

```csharp
using Kreuzberg;


var config = new ExtractionConfig
{
    LanguageDetection = new LanguageDetectionConfig
    {
        Enabled = true,
        MinConfidence = 0.9m,
        DetectMultiple = true
    }
};


var result = await KreuzbergClient.ExtractFileAsync("document.pdf", config);
Console.WriteLine($"Languages: {string.Join(", ", result.DetectedLanguages ?? new List<string>())}");
```

```go
package main


import (
  "fmt"


  "github.com/kreuzberg-dev/kreuzberg-lts/v4"
)


func main() {
  minConfidence := 0.8
  config := &kreuzberg.ExtractionConfig{
    LanguageDetection: &kreuzberg.LanguageDetectionConfig{
      Enabled:        true,
      MinConfidence:  &minConfidence,
      DetectMultiple: false,
    },
  }


  fmt.Printf("Language detection enabled: %v\n", config.LanguageDetection.Enabled)
  fmt.Printf("Min confidence: %f\n", *config.LanguageDetection.MinConfidence)
}
```

```java
import dev.kreuzberg.config.ExtractionConfig;
import dev.kreuzberg.config.LanguageDetectionConfig;


ExtractionConfig config = ExtractionConfig.builder()
    .languageDetection(LanguageDetectionConfig.builder()
        .enabled(true)
        .minConfidence(0.8)
        .build())
    .build();
```

```python
import asyncio
from kreuzberg import ExtractionConfig, LanguageDetectionConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        language_detection=LanguageDetectionConfig(
            enabled=True,
            min_confidence=0.85,
            detect_multiple=False
        )
    )
    result = await extract_file("document.pdf", config=config)
    if result.detected_languages:
        print(f"Primary language: {result.detected_languages[0]}")
    print(f"Content length: {len(result.content)} chars")


asyncio.run(main())
```

```ruby
require 'kreuzberg'


config = Kreuzberg::Config::Extraction.new(
  language_detection: Kreuzberg::Config::LanguageDetection.new(
    enabled: true,
    min_confidence: 0.8,
    detect_multiple: false
  )
)
```

```r
library(kreuzberg)


config <- extraction_config(
  language_detection = list(enabled = TRUE)
)


result <- extract_file_sync("document.pdf", "application/pdf", config)


cat(sprintf("Detected language: %s\n", result$detected_language))
cat(sprintf("Content preview: %.60s...\n", result$content))
```

```rust
use kreuzberg::{ExtractionConfig, LanguageDetectionConfig};


let config = ExtractionConfig {
    language_detection: Some(LanguageDetectionConfig {
        enabled: true,
        min_confidence: 0.8,
        detect_multiple: false,
    }),
    ..Default::default()
};
```

```typescript
import { extractFile } from '@kreuzberg/node';


const config = {
  languageDetection: {
    enabled: true,
    minConfidence: 0.8,
    detectMultiple: false,
  },
};


const result = await extractFile('document.pdf', null, config);
if (result.detectedLanguages) {
  console.log(`Detected languages: ${result.detectedLanguages.join(', ')}`);
}
```

--------------------------------

### Initialize WASM Module

Source: https://docs.kreuzberg.dev/reference/api-wasm

Examples for basic initialization and initialization with error handling.

```typescript
import { initWasm } from '@kreuzberg/wasm';


async function main() {
  await initWasm();
  // Now you can use extraction functions
}


main().catch(console.error);
```

```typescript
import { initWasm, getWasmCapabilities } from '@kreuzberg/wasm';


async function initializeKreuzberg() {
  const caps = getWasmCapabilities();
  if (!caps.hasWasm) {
    throw new Error('WebAssembly is not supported in this environment');
  }


  try {
    await initWasm();
    console.log('Kreuzberg initialized successfully');
  } catch (error) {
    console.error('Failed to initialize Kreuzberg:', error);
    throw error;
  }
}


initializeKreuzberg().catch(console.error);
```

--------------------------------

### Define StructuredExtractionConfig in YAML

Source: https://docs.kreuzberg.dev/reference/configuration

Configuration file example using YAML format.

```yaml
structured_extraction:
  llm:
    model: openai/gpt-4o-mini
  schema:
    type: object
    properties:
      invoice_number:
        type: string
      total_amount:
        type: number
    required:
      - invoice_number
      - total_amount
  temperature: 0.0
```

--------------------------------

### Install Kreuzberg via Mix

Source: https://docs.kreuzberg.dev/reference/api-elixir

Add the dependency to your mix.exs file to include the library in your project.

```elixir

def deps do
  [
    {:kreuzberg, "~> 4.10.2"}
  ]
end

```

```elixir

def deps do
  [
    {:kreuzberg, git: "https://github.com/kreuzberg-dev/kreuzberg-lts.git"}
  ]
end

```

--------------------------------

### Define StructuredExtractionConfig in TOML

Source: https://docs.kreuzberg.dev/reference/configuration

Configuration file example using TOML format.

```toml
[structured_extraction]
prompt = "Extract invoice data from the document."
max_tokens = 4096
temperature = 0.0


[structured_extraction.llm]
model = "openai/gpt-4o-mini"


[structured_extraction.schema]
type = "object"


[structured_extraction.schema.properties.invoice_number]
type = "string"


[structured_extraction.schema.properties.total_amount]
type = "number"
```

--------------------------------

### Configure Python Extraction

Source: https://docs.kreuzberg.dev/reference/configuration

Examples for setting up semantic and markdown-based chunking configurations in Python.

```python
import asyncio
from kreuzberg import ExtractionConfig, ChunkingConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        chunking=ChunkingConfig(chunker_type="semantic")
    )
    result = await extract_file("document.pdf", config=config)
    for chunk in result.chunks or []:
        print(f"Content: {chunk.content[:100]}...")


asyncio.run(main())
```

```python
import asyncio
from kreuzberg import ExtractionConfig, ChunkingConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        chunking=ChunkingConfig(
            chunker_type="markdown",
            max_chars=500,
            max_overlap=50,
            prepend_heading_context=True,
        )
    )
    result = await extract_file("document.md", config=config)
    for chunk in result.chunks or []:
        # Each chunk's content is prefixed with its heading breadcrumb
        print(f"Content: {chunk.content[:100]}...")


asyncio.run(main())
```

--------------------------------

### Configure Concurrency Limits

Source: https://docs.kreuzberg.dev/reference/configuration

Examples showing how to set the max_threads limit across different programming languages.

```python
from kreuzberg import ExtractionConfig, ConcurrencyConfig


# Limit to 4 threads for constrained hardware
config = ExtractionConfig(
    concurrency=ConcurrencyConfig(max_threads=4)
)
```

```typescript
import { extract } from "kreuzberg";


const result = await extract("document.pdf", {
  concurrency: { maxThreads: 4 },
});
```

```rust
use kreuzberg::core::{ExtractionConfig, ConcurrencyConfig};


let config = ExtractionConfig {
    concurrency: Some(ConcurrencyConfig {
        max_threads: Some(4),
    }),
    ..Default::default()
};
```

```go
package main


import "kreuzberg"


config := &kreuzberg.ExtractionConfig{
    Concurrency: &kreuzberg.ConcurrencyConfig{
        MaxThreads: intPtr(4),
    },
}
```

```java
ConcurrencyConfig concurrency = new ConcurrencyConfig(4);
ExtractionConfig config = new ExtractionConfig(
    /* ... other fields ... */
    Optional.of(concurrency)
);
```

```csharp
using Kreuzberg;


var config = new ExtractionConfig
{
    Concurrency = new ConcurrencyConfig { MaxThreads = 4 }
};
```

--------------------------------

### Configure basic extraction

Source: https://docs.kreuzberg.dev/reference/api-elixir

Basic setup for file extraction using cache and Tesseract OCR.

```elixir
config = %Kreuzberg.ExtractionConfig{
  use_cache: true,
  ocr: %Kreuzberg.OcrConfig{backend: "tesseract"}
}


{:ok, result} = Kreuzberg.extract_file("document.pdf", nil, config)
```

--------------------------------

### Kreuzberg Configuration Examples

Source: https://docs.kreuzberg.dev/reference/api-php

Shows how to initialize the Kreuzberg class with default or custom configurations and override them per call.

```php

<?php


use Kreuzberg\Kreuzberg;
use Kreuzberg\Config\ExtractionConfig;


// Create with default config
$kreuzberg = new Kreuzberg();
$result = $kreuzberg->extractFile('document.pdf');


// Create with custom config
$config = new ExtractionConfig(extractTables: true);
$kreuzberg = new Kreuzberg($config);
$result = $kreuzberg->extractFile('document.pdf');


// Override config per call
$overrideConfig = new ExtractionConfig(extractImages: true);
$result = $kreuzberg->extractFile('document.pdf', config: $overrideConfig);

```

--------------------------------

### Install Kreuzberg Gem

Source: https://docs.kreuzberg.dev/reference/api-ruby

Methods for adding the gem to a project or installing it directly.

```ruby
gem 'kreuzberg'
```

```bash
gem install kreuzberg
```

--------------------------------

### Configure Acceleration in Rust

Source: https://docs.kreuzberg.dev/reference/configuration

Example for defining acceleration configuration using the Rust struct.

```rust
use kreuzberg::core::{ExtractionConfig, AccelerationConfig};


let config = ExtractionConfig {
    acceleration: Some(AccelerationConfig {
        provider: "cuda".to_string(),
        device_id: 0,
    }),
    ..Default::default()
};
```

--------------------------------

### Initialize and Verify OCR Backends

Source: https://docs.kreuzberg.dev/reference/api-wasm

Enable the OCR functionality and list available backends to verify successful initialization.

```javascript
import { enableOcr, listOcrBackends } from '@kreuzberg/wasm';


try {
  await enableOcr();
  const backends = listOcrBackends();
  console.log('Available OCR backends:', backends);
  // Expected: ['kreuzberg-tesseract'] (native) or ['tesseract-wasm'] (browser fallback)
} catch (error) {
  console.warn('OCR not available:', error);
}
```

--------------------------------

### BatchExtractFilesAsync Example

Source: https://docs.kreuzberg.dev/reference/api-csharp

Usage example for processing multiple file paths asynchronously.

```csharp
var files = new[] { "doc1.pdf", "doc2.pdf", "doc3.pdf" };
var results = await KreuzbergClient.BatchExtractFilesAsync(files);
```

--------------------------------

### BatchExtractBytesSync Example

Source: https://docs.kreuzberg.dev/reference/api-csharp

Usage example for processing multiple byte arrays synchronously.

```csharp
var items = new[]
{
    new BytesWithMime(File.ReadAllBytes("doc1.pdf"), "application/pdf"),
    new BytesWithMime(File.ReadAllBytes("doc2.docx"), "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
};
var results = KreuzbergClient.BatchExtractBytesSync(items);
foreach (var result in results)
{
    Console.WriteLine($"MIME: {result.MimeType}");
}
```

--------------------------------

### Configure Extraction in Go

Source: https://docs.kreuzberg.dev/reference/configuration

Demonstrates setting up the extraction configuration with a character whitelist and Tesseract parameters.

```go
package main


import (
  "log"


  "github.com/kreuzberg-dev/kreuzberg-lts/v4"
)


func main() {
  psm := 6
  oem := 1
  minConf := 0.8
  lang := "eng+fra+deu"
  whitelist := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 .,!?"


  config := &kreuzberg.ExtractionConfig{
    OCR: &kreuzberg.OCRConfig{
      Backend:  "tesseract",
      Language: &lang,
      Tesseract: &kreuzberg.TesseractConfig{
        PSM:              &psm,
        OEM:              &oem,
        MinConfidence:    &minConf,
        EnableTableDetection: kreuzberg.BoolPtr(true),
        TesseditCharWhitelist: whitelist,
      },
    },
  }


  result, err := kreuzberg.ExtractFileSync("document.pdf", config)
  if err != nil {
    log.Fatalf("extract failed: %v", err)
  }


  log.Println("content length:", len(result.Content))
}
```

--------------------------------

### Configure Acceleration in TypeScript

Source: https://docs.kreuzberg.dev/reference/configuration

Example for passing acceleration settings during the extraction process in TypeScript.

```typescript
import { extract } from "kreuzberg";


const result = await extract("document.pdf", {
  acceleration: { provider: 'cuda', deviceId: 0 },
});
```

--------------------------------

### Configure Layout Detection via Files

Source: https://docs.kreuzberg.dev/reference/configuration

Examples for defining layout detection settings in external configuration files.

```toml
[layout]
confidence_threshold = 0.5
apply_heuristics = true
# table_model = "slanet_auto"
```

```yaml
layout:
  confidence_threshold: 0.5
  apply_heuristics: true
  # table_model: slanet_auto
```

--------------------------------

### BatchExtractBytesAsync Example

Source: https://docs.kreuzberg.dev/reference/api-csharp

Usage example for processing multiple byte arrays asynchronously.

```csharp
var items = new[]
{
    new BytesWithMime(File.ReadAllBytes("doc1.pdf"), "application/pdf"),
    new BytesWithMime(File.ReadAllBytes("doc2.docx"), "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
};
var results = await KreuzbergClient.BatchExtractBytesAsync(items);
```

--------------------------------

### Initialize EasyOCRBackend

Source: https://docs.kreuzberg.dev/reference/api-python

Instantiate the built-in EasyOCR backend with custom configuration parameters.

```python
from kreuzberg.ocr.easyocr import EasyOCRBackend


backend = EasyOCRBackend(
    languages=["en", "de"],
    use_gpu=True,
    model_storage_directory="/tmp/easyocr_models",
    beam_width=10,
)
```

--------------------------------

### Install Kreuzberg package

Source: https://docs.kreuzberg.dev/reference/api-r

Installation methods for the Kreuzberg R package from R-universe or GitHub.

```R
install.packages("kreuzberg", repos = "https://kreuzberg-dev.r-universe.dev")
```

```R
remotes::install_github("kreuzberg-dev/kreuzberg-lts", subdir = "packages/r")
```

--------------------------------

### Configure OCR settings

Source: https://docs.kreuzberg.dev/reference/api-elixir

Example of passing OCR settings as a map to the extraction configuration.

```elixir
config = %Kreuzberg.ExtractionConfig{
  ocr: %{
    "enabled" => true,
    "language" => "eng",
    "backend" => "tesseract"
  }
}


{:ok, result} = Kreuzberg.extract_file("scanned.pdf", nil, config)
```

--------------------------------

### Initialize ExtractionConfig with Tesseract

Source: https://docs.kreuzberg.dev/reference/api-go

Example of initializing an ExtractionConfig with a Tesseract OCR backend and specific tuning parameters.

```go
cfg := &kreuzberg.ExtractionConfig{
  OCR: &kreuzberg.OCRConfig{
    Backend:  "tesseract",
    Language: stringPtr("eng"),
    Tesseract: &kreuzberg.TesseractConfig{
      PSM:           intPtr(3),
      MinConfidence: float64Ptr(0.5),
    },
  },
}
```

--------------------------------

### Configure via YAML Format

Source: https://docs.kreuzberg.dev/reference/configuration

Equivalent configuration using YAML syntax.

```yaml
chunking:
  max_characters: 1000
  overlap: 200
  embedding:
    model:
      type: preset
      name: balanced
    batch_size: 32
    normalize: true
```

--------------------------------

### TesseractConfig Usage Example

Source: https://docs.kreuzberg.dev/reference/api-rust

Example of integrating TesseractConfig within an ExtractionConfig for numeric character extraction.

```rust
use kreuzberg::{ExtractionConfig, OcrConfig, TesseractConfig};


// Configure Tesseract with custom settings for numeric extraction
let config = ExtractionConfig {
    ocr: Some(OcrConfig {
        backend: "tesseract".to_string(),
        language: "eng".to_string(),
        tesseract_config: Some(TesseractConfig {
            psm: 6,
            enable_table_detection: true,
            tessedit_char_whitelist: "0123456789".to_string(),
            tessedit_char_blacklist: String::new(),
            ..Default::default()
        }),
    }),
    ..Default::default()
};
```

--------------------------------

### Validate Tesseract OCR Installation

Source: https://docs.kreuzberg.dev/reference/api-php

Verifies Tesseract availability and checks for installed language data files.

```php
<?php


// Check if Tesseract is available
$output = shell_exec('tesseract --version 2>&1');


if ($output === null) {
    echo "Tesseract not found in PATH!\n";
    echo "Install: brew install tesseract (macOS) or apt install tesseract-ocr (Linux)\n";
} else {
    echo "Tesseract version:\n{$output}\n";
}


// Check for language data
$langDataPaths = [
    '/usr/local/share/tessdata/',  // macOS Homebrew
    '/usr/share/tesseract-ocr/4.00/tessdata/',  // Ubuntu/Debian
    '/usr/share/tessdata/',  // Alternative Linux path
];


foreach ($langDataPaths as $path) {
    if (is_dir($path)) {
        echo "\nLanguage data found in: {$path}\n";
        $files = glob($path . '*.traineddata');
        echo "Available languages: " . count($files) . "\n";
        foreach ($files as $file) {
            $lang = basename($file, '.traineddata');
            echo "- {$lang}\n";
        }
        break;
    }
}
```

--------------------------------

### Configure PDF Extraction

Source: https://docs.kreuzberg.dev/reference/configuration

Examples demonstrating how to initialize PdfConfig and pass it to the extraction client across multiple supported languages.

```csharp
using Kreuzberg;


var config = new ExtractionConfig
{
    PdfOptions = new PdfConfig
    {
        ExtractImages = true,
        ExtractMetadata = true,
        Passwords = new List<string> { "password1", "password2" },
        Hierarchy = new HierarchyConfig
        {
            Enabled = true,
            KClusters = 6,
            IncludeBbox = true,
            OcrCoverageThreshold = 0.5f
        }
    }
};


var result = await KreuzbergClient.ExtractFileAsync("document.pdf", config);
Console.WriteLine($"Content: {result.Content[..Math.Min(100, result.Content.Length)]}");
```

```go
package main


import (
  "log"


  "github.com/kreuzberg-dev/kreuzberg-lts/v4"
)


func main() {
  pw := []string{"password1", "password2"}
  result, err := kreuzberg.ExtractFileSync("document.pdf", &kreuzberg.ExtractionConfig{
    PdfOptions: &kreuzberg.PdfConfig{
      ExtractImages:   kreuzberg.BoolPtr(true),
      ExtractMetadata: kreuzberg.BoolPtr(true),
      Passwords:       pw,
      Hierarchy:       &kreuzberg.HierarchyConfig{},
    },
  })
  if err != nil {
    log.Fatalf("extract failed: %v", err)
  }


  log.Println("content length:", len(result.Content))
}
```

```java
import dev.kreuzberg.config.ExtractionConfig;
import dev.kreuzberg.config.PdfConfig;
import dev.kreuzberg.config.HierarchyConfig;
import java.util.Arrays;


ExtractionConfig config = ExtractionConfig.builder()
    .pdfOptions(PdfConfig.builder()
        .extractImages(true)
        .extractMetadata(true)
        .passwords(Arrays.asList("password1", "password2"))
        .hierarchyConfig(HierarchyConfig.builder().build())
        .build())
    .build();
```

```python
import asyncio
from kreuzberg import ExtractionConfig, PdfConfig, HierarchyConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        pdf_options=PdfConfig(
            extract_images=True,
            extract_metadata=True,
            passwords=["password1", "password2"],
            hierarchy=HierarchyConfig(enabled=True, k_clusters=6)
        )
    )
    result = await extract_file("document.pdf", config=config)
    print(f"Content: {result.content[:100]}")


asyncio.run(main())
```

```ruby
require 'kreuzberg'


config = Kreuzberg::Config::Extraction.new(
  pdf_options: Kreuzberg::Config::PDF.new(
    extract_images: true,
    extract_metadata: true,
    passwords: ['password1', 'password2'],
    hierarchy: Kreuzberg::Config::Hierarchy.new(
      enabled: true,
      k_clusters: 6,
      include_bbox: true
    )
  )
)
```

```r
library(kreuzberg)


config <- extraction_config(
  pdf_options = list(extract_tables = TRUE)
)


result <- extract_file_sync("document.pdf", "application/pdf", config)


cat(sprintf("Tables extracted: %d\n", length(result$tables)))
cat(sprintf("Total elements: %d\n", length(result$elements)))
cat(sprintf("Content preview: %.50s...\n", result$content))
```

```rust
use kreuzberg::{ExtractionConfig, PdfConfig};


fn main() {
    let config = ExtractionConfig {
        pdf_options: Some(PdfConfig {
            extract_images: Some(true),
            extract_metadata: Some(true),
            passwords: Some(vec!["password1".to_string(), "password2".to_string()]),
        }),
        ..Default::default()
    };
    println!("{:?}", config.pdf_options);
}
```

```typescript
import { extractFile } from '@kreuzberg/node';


const config = {
  pdfOptions: {
    extractImages: true,
    extractMetadata: true,
    passwords: ['password1', 'password2'],
    hierarchy: { enabled: true, kClusters: 6, includeBbox: true }
  },
};


const result = await extractFile('document.pdf', null, config);
console.log(result.content);
```

--------------------------------

### Configure OCR Extraction

Source: https://docs.kreuzberg.dev/reference/configuration

Examples of initializing OCR configuration across multiple programming languages.

```csharp
using Kreuzberg;


var config = new ExtractionConfig
{
    Ocr = new OcrConfig
    {
        Backend = "tesseract",
        Language = "eng+fra",
        TesseractConfig = new TesseractConfig { Psm = 3 }
    }
};


var result = await KreuzbergClient.ExtractFileAsync("document.pdf", config);
Console.WriteLine(result.Content);
```

```go
package main


import "github.com/kreuzberg-dev/kreuzberg-lts/v4"


func main() {
  language := "eng+fra"
  psm := 3


  _ = &kreuzberg.ExtractionConfig{
    OCR: &kreuzberg.OCRConfig{
      Backend:  "tesseract",
      Language: &language,
      Tesseract: &kreuzberg.TesseractConfig{
        PSM: &psm,
      },
    },
  }
}
```

```java
import dev.kreuzberg.config.ExtractionConfig;
import dev.kreuzberg.config.OcrConfig;
import dev.kreuzberg.config.TesseractConfig;


ExtractionConfig config = ExtractionConfig.builder()
    .ocr(OcrConfig.builder()
        .backend("tesseract")
        .language("eng+fra")
        .tesseractConfig(TesseractConfig.builder()
            .psm(3)
            .build())
        .build())
    .build();
```

```python
import asyncio
from kreuzberg import ExtractionConfig, OcrConfig, TesseractConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        ocr=OcrConfig(
            backend="tesseract", language="eng+fra",
            tesseract_config=TesseractConfig(psm=3)
        )
    )
    result = await extract_file("document.pdf", config=config)
    print(result.content)


asyncio.run(main())
```

```ruby
require 'kreuzberg'


config = Kreuzberg::Config::Extraction.new(
  ocr: Kreuzberg::Config::OCR.new(
    backend: 'tesseract',
    language: 'eng+fra',
    tesseract_config: Kreuzberg::Config::Tesseract.new(psm: 3)
  )
)
```

```r
library(kreuzberg)


ocr_cfg <- ocr_config(backend = "tesseract", language = "eng", dpi = 300L)
config <- extraction_config(force_ocr = TRUE, ocr = ocr_cfg)


result <- extract_file_sync("document.pdf", "application/pdf", config)
cat(sprintf("Extracted content length: %d\n", nchar(result$content)))
cat(sprintf("Detected language: %s\n", result$detected_language))
```

```rust
use kreuzberg::{extract_file_sync, ExtractionConfig, OcrConfig};


fn main() -> kreuzberg::Result<()> {
    let config = ExtractionConfig {
        ocr: Some(OcrConfig {
            backend: "tesseract".to_string(),
            language: "eng+deu+fra".to_string(),
            ..Default::default()
        }),
        ..Default::default()
    };


    let result = extract_file_sync("multilingual.pdf", None, &config)?;
    println!("{}", result.content);
    Ok(())
}
```

```typescript
import { extractFile } from '@kreuzberg/node';


const config = {
  ocr: {
    backend: 'tesseract',
    language: 'eng+fra',
    tesseractConfig: {
      psm: 3,
    },
  },
};


const result = await extractFile('document.pdf', null, config);
console.log(result.content);
```

--------------------------------

### Configure ExtractionConfig instance

Source: https://docs.kreuzberg.dev/reference/api-rust

Example of initializing an ExtractionConfig instance with custom OCR and PDF-specific settings.

```rust
use kreuzberg::{ExtractionConfig, OcrConfig, PdfConfig};


// Configure extraction with OCR and PDF-specific options
let config = ExtractionConfig {
    ocr: Some(OcrConfig::default()),
    force_ocr: false,
    pdf_options: Some(PdfConfig {
        passwords: Some(vec!["password1".to_string(), "password2".to_string()]),
        extract_images: true,
        extract_metadata: true,
        hierarchy: None,
    }),
    ..Default::default()
};
```

--------------------------------

### Configure Acceleration via Configuration Files

Source: https://docs.kreuzberg.dev/reference/configuration

Examples for defining acceleration settings in TOML and YAML configuration files.

```toml
[acceleration]
provider = "cpu"
device_id = 0
```

```yaml
acceleration:
  provider: cpu
  device_id: 0
```

--------------------------------

### from_file(path)

Source: https://docs.kreuzberg.dev/reference/api-r

Loads configuration settings from a specified TOML, YAML, or JSON file.

```APIDOC
## from_file(path)

### Description
Load configuration from a TOML, YAML, or JSON file.

### Signature
from_file(path) -> list

### Parameters
- **path** (character) - Required - Path to configuration file (TOML, YAML, or JSON)

### Returns
- Named list with configuration

### Example
config <- from_file("kreuzberg.toml")
```

--------------------------------

### Batch Extract Multiple PDFs Example

Source: https://docs.kreuzberg.dev/reference/api-go

Demonstrates how to perform a batch extraction and handle individual file results and errors.

```go
files := []string{"doc1.pdf", "doc2.pdf", "doc3.pdf"}


results, err := kreuzberg.BatchExtractFilesSync(files, nil)
if err != nil {
  log.Fatalf("batch extraction setup failed: %v", err)
}


for i, result := range results {
  if result == nil {
    fmt.Printf("File %d: extraction failed\n", i)
    continue
  }


  if result.Metadata.Error != nil {
    fmt.Printf("File %d: %s (%s)\n", i, result.Metadata.Error.ErrorType, result.Metadata.Error.Message)
    continue
  }


  fmt.Printf("File %d: extracted %d chars\n", i, len(result.Content))
}
```

--------------------------------

### Install Tesseract OCR Dependency

Source: https://docs.kreuzberg.dev/reference/api-typescript

Commands to install the Tesseract OCR engine required for OCR support on macOS and Ubuntu systems.

```bash
brew install tesseract
```

```bash
apt-get install tesseract-ocr
```

--------------------------------

### Configure Post-Processing Pipeline

Source: https://docs.kreuzberg.dev/reference/configuration

Examples of initializing the post-processing configuration across multiple supported programming languages.

```csharp
using Kreuzberg;


var config = new ExtractionConfig
{
    Postprocessor = new PostProcessorConfig
    {
        Enabled = true,
        EnabledProcessors = new List<string> { "deduplication" }
    }
};


var result = await KreuzbergClient.ExtractFileAsync("document.pdf", config);
Console.WriteLine($"Content: {result.Content[..Math.Min(100, result.Content.Length)]}");
```

```go
package main


import "github.com/kreuzberg-dev/kreuzberg-lts/v4"


func main() {
  enabled := true
  cfg := &kreuzberg.ExtractionConfig{
    Postprocessor: &kreuzberg.PostProcessorConfig{
      Enabled:            &enabled,
      EnabledProcessors:  []string{"deduplication", "whitespace_normalization"},
      DisabledProcessors: []string{"mojibake_fix"},
    },
  }


  _ = cfg
}
```

```java
import dev.kreuzberg.config.ExtractionConfig;
import dev.kreuzberg.config.PostProcessorConfig;
import java.util.Arrays;


ExtractionConfig config = ExtractionConfig.builder()
    .postprocessor(PostProcessorConfig.builder()
        .enabled(true)
        .enabledProcessors(Arrays.asList("deduplication", "whitespace_normalization"))
        .disabledProcessors(Arrays.asList("mojibake_fix"))
        .build())
    .build();
```

```python
import asyncio
from kreuzberg import ExtractionConfig, PostProcessorConfig, extract_file


async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        postprocessor=PostProcessorConfig(
            enabled=True,
            enabled_processors=["deduplication"],
        )
    )
    result = await extract_file("document.pdf", config=config)
    print(f"Content: {result.content[:100]}")


asyncio.run(main())
```

```ruby
require 'kreuzberg'


config = Kreuzberg::Config::Extraction.new(
  postprocessor: Kreuzberg::Config::PostProcessor.new(
    enabled: true,
    enabled_processors: ['deduplication', 'whitespace_normalization'],
    disabled_processors: ['mojibake_fix']
  )
)
```

```r
library(kreuzberg)


config <- extraction_config(
  postprocessor = list(enabled = TRUE)
)


result <- extract_file_sync("document.pdf", "application/pdf", config)


cat(sprintf("Content length: %d characters\n", nchar(result$content)))
cat(sprintf("Mime type: %s\n", result$mime_type))
```

```rust
use kreuzberg::{ExtractionConfig, PostProcessorConfig};


fn main() {
    let config = ExtractionConfig {
        postprocessor: Some(PostProcessorConfig {
            enabled: Some(true),
            enabled_processors: Some(vec![
                "deduplication".to_string(),
                "whitespace_normalization".to_string(),
            ]),
            disabled_processors: Some(vec!["mojibake_fix".to_string()]),
        }),
        ..Default::default()
    };
    println!("{:?}", config.postprocessor);
}
```

```typescript
import { extractFile } from '@kreuzberg/node';


const config = {
  postprocessor: {
    enabled: true,
    enabledProcessors: ['deduplication', 'whitespace_normalization'],
    disabledProcessors: ['mojibake_fix'],
  },
};


const result = await extractFile('document.pdf', null, config);
console.log(result.content);
```

--------------------------------

### GetEmbeddingPreset()

Source: https://docs.kreuzberg.dev/reference/api-csharp

Gets an embedding preset by name.

```APIDOC
## GetEmbeddingPreset(string name)

### Description
Gets an embedding preset by name.

### Signature
`public static EmbeddingPreset? GetEmbeddingPreset(string name)`

### Parameters
- **name** (string): The name of the embedding preset. Must not be empty.

### Returns
- **EmbeddingPreset?**: The EmbeddingPreset with matching name, or null if not found.

### Throws
- **KreuzbergValidationException**: If name is null or empty.
- **KreuzbergException**: If preset retrieval fails.

### Example
```csharp
var preset = KreuzbergClient.GetEmbeddingPreset("default");
if (preset != null)
{
    Console.WriteLine($"Model: {preset.ModelName}");
    Console.WriteLine($"Dimensions: {preset.Dimensions}");
    Console.WriteLine($"Chunk Size: {preset.ChunkSize}");
}
```
```

--------------------------------

### Generate and open local Rust documentation

Source: https://docs.kreuzberg.dev/reference/api-rust

Use this command to build and view the project's documentation locally in your default browser.

```bash
cargo doc --open --no-deps
```

--------------------------------

### Load Configuration from String

Source: https://docs.kreuzberg.dev/reference/api-wasm

Demonstrates parsing configuration strings in YAML, JSON, and TOML formats.

```javascript

import { loadConfigFromString, extractBytes } from '@kreuzberg/wasm';


const yamlConfig = `
extractTables: true
ocr:
  backend: tesseract
  languages: [eng, deu]
`;


const config = loadConfigFromString(yamlConfig, 'yaml');
const result = await extractBytes(data, 'application/pdf', config);

```

```javascript

import { loadConfigFromString } from '@kreuzberg/wasm';


const jsonConfig = '{"extractTables":true}';
const config = loadConfigFromString(jsonConfig, 'json');

```

```javascript

import { loadConfigFromString } from '@kreuzberg/wasm';


const tomlConfig = `
extract_tables = true
// OCR now configured via config.ocr.backend


[ocr_config]
languages = ["eng", "deu"]
`;


const config = loadConfigFromString(tomlConfig, 'toml');

```

--------------------------------

### Verify and Build Static Library

Source: https://docs.kreuzberg.dev/reference/api-go

Commands to verify the existence of the static library and build the FFI crate or link it manually for external projects.

```bash
# Verify static library exists
ls -la target/release/libkreuzberg_ffi.a


# For monorepo development, just build the FFI crate:
cargo build -p kreuzberg-ffi --release


# For external projects, provide the path via CGO_LDFLAGS:
CGO_LDFLAGS="-L$HOME/kreuzberg/lib -lkreuzberg_ffi" go build
```

--------------------------------

### Configure via JSON Format

Source: https://docs.kreuzberg.dev/reference/configuration

Equivalent configuration using JSON syntax.

```json
{
  "chunking": {
    "max_characters": 1000,
    "overlap": 200,
    "embedding": {
      "model": {
        "type": "preset",
        "name": "balanced"
      },
      "batch_size": 32,
      "normalize": true
    }
  }
}
```

--------------------------------

### getVersion()

Source: https://docs.kreuzberg.dev/reference/api-java

Get the current version of the Kreuzberg library.

```APIDOC
## getVersion()

### Description
Get the current version of the Kreuzberg library.

### Signature
`public static String getVersion()`
```

--------------------------------

### Configure LlmConfig via Files

Source: https://docs.kreuzberg.dev/reference/configuration

Examples of defining LLM configuration using TOML and YAML formats.

```toml
[llm]
model = "openai/gpt-4o-mini"
# api_key = "sk-..."       # Optional: falls back to OPENAI_API_KEY
# base_url = "https://..."  # Optional: uses provider default
```

```yaml
llm:
  model: openai/gpt-4o-mini
  # api_key: sk-...
  # base_url: https://...
```

--------------------------------

### Kreuzberg.get_embedding_preset/1

Source: https://docs.kreuzberg.dev/reference/api-elixir

Get detailed information about a specific embedding preset.

```APIDOC
## Kreuzberg.get_embedding_preset/1

### Description
Get detailed information about a specific embedding preset.

### Signature
`@spec get_embedding_preset(String.t()) :: {:ok, map()} | {:error, String.t()}`

### Parameters
- **preset_name** (String) - Required - Name of the embedding preset

### Returns
- **{:ok, preset_info}** - Map containing preset details (name, chunk_size, overlap, dimensions, description)
- **{:error, reason}** - Error if preset not found
```

--------------------------------

### Implement and Register OCR Backend

Source: https://docs.kreuzberg.dev/reference/api-c

Example implementation of an OCR backend callback and usage of language support queries.

```c
char *my_ocr(const uint8_t *image_bytes, size_t image_length,
             const char *config_json) {
    /* Run custom OCR on image data */
    return strdup("Recognized text from image");
}


kreuzberg_register_ocr_backend("my-ocr", my_ocr);


/* Check language support */
char *langs = kreuzberg_get_ocr_languages("tesseract");
if (langs != NULL) {
    printf("Tesseract languages: %s\n", langs);
    kreuzberg_free_string(langs);
}
```
Tokens:
Raw