Kreuzberg

https://docs.kreuzberg.dev
Admin
Kreuzberg is a document intelligence platform with a Rust core that extracts text, tables, and...
Tokens:642,140
Snippets:4,606
Trust Score:6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Go: install with go get

Source: https://docs.kreuzberg.dev/getting-started/installation

Install the Go binding via go get. On Windows, it links against ONNX Runtime dynamically and requires onnxruntime.dll on PATH.

```go

go get github.com/kreuzberg-dev/kreuzberg-lts/v4@latest

```

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

### Set up development environment with task setup

Source: https://docs.kreuzberg.dev/contributing

Run `task setup` to install all toolchains and dependencies. Safe to re-run anytime.

```shell
task setup
```

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

### Install Go SDK

Source: https://docs.kreuzberg.dev/cli/usage

Fetches the Kreuzberg Go SDK module using go get.

```bash
go get github.com/kreuzberg-dev/kreuzberg-lts/v4@latest
```

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

### Install Kreuzberg with MCP support and start the server

Source: https://docs.kreuzberg.dev/guides/mcp-integration

Installs the full Kreuzberg package and starts the MCP server over stdio. Requires Python and pip.

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

```

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

### Get OCR backend example

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

Example of retrieving a backend by name and logging its supported languages if found.

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


const backend = getOcrBackend('tesseract-wasm');
if (backend) {
  console.log('Available languages:', backend.supportedLanguages());
}
```

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

### Install Kreuzberg with all features

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

Installation command that includes all optional features.

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

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

### Load JSON configuration example

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

Example of loading a JSON configuration string.

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


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

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

### ListPostProcessors() example

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

Example of listing registered post-processors and printing their names.

```csharp
var processors = KreuzbergClient.ListPostProcessors();
Console.WriteLine($"Registered processors: {string.Join(", ", processors)}");
```

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

### Install via install script (Linux/macOS)

Source: https://docs.kreuzberg.dev/cli/usage

Downloads and runs the official install script from the kreuzberg-lts repository.

```bash
curl -fsSL https://raw.githubusercontent.com/kreuzberg-dev/kreuzberg-lts/main/scripts/install.sh | bash
```

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

### Standard text output examples

Source: https://docs.kreuzberg.dev/cli/usage

Shows three ways to get text output: print to stdout, redirect to a file, and batch extract as text.

```bash
# Extract and print content to stdout
kreuzberg extract document.pdf
```

```bash
# Extract and redirect output to file
kreuzberg extract document.pdf > output.txt
```

```bash
# Batch extract as text
kreuzberg batch documents/*.pdf --format text
```

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

### Kreuzberg::MCPProxy - Start MCP server

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

Shows how to use the Kreuzberg::MCPProxy wrapper to start the Kreuzberg MCP server. The start method blocks.

```ruby
mcp = Kreuzberg::MCPProxy.new


# Start MCP server (blocks)
mcp.start
```

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

### Check Kreuzberg Installation

Source: https://docs.kreuzberg.dev/cli/usage

Display the installed version and help for the Kreuzberg CLI.

```bash
# Display installed version
kreuzberg --version


# Display help for commands
kreuzberg --help

```

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

### from_file() usage example

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

Example of loading configuration from a TOML file and using it in extract_file_sync().

```r
config <- from_file("kreuzberg.toml")
result <- extract_file_sync("document.pdf", config = config)
```

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

### Start Kreuzberg server in Go

Source: https://docs.kreuzberg.dev/guides/api-server

Start the Kreuzberg server from Go by executing the CLI with exec.Command. Logger outputs to stdout and stderr; the program logs a fatal error if the server fails to start.

```go
package main


import (
    "log"
    "os/exec"
)


func main() {
    cmd := exec.Command("kreuzberg", "serve", "-H", "0.0.0.0", "-p", "8000")
    cmd.Stdout = log.Writer()
    cmd.Stderr = log.Writer()
    if err := cmd.Run(); err != nil {
        log.Fatalf("failed to start server: %v", err)
    }
}
```

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

### LibraryVersion usage example

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

Example of using LibraryVersion to print the Kreuzberg version.

```go
fmt.Printf("Kreuzberg version: %s\n", kreuzberg.LibraryVersion())
```

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

### Start MCP server

Source: https://docs.kreuzberg.dev/guides/docker

Starts the MCP server mode.

```bash
# Start MCP server
docker run ghcr.io/kreuzberg-dev/kreuzberg-full:latest mcp
```

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

### KREUZBERG_PORT examples

Source: https://docs.kreuzberg.dev/reference/environment-variables

Examples of setting the server port via the KREUZBERG_PORT environment variable.

```bash
export KREUZBERG_PORT=3000
export KREUZBERG_PORT=8080
```

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

### Install via Homebrew (macOS/Linux)

Source: https://docs.kreuzberg.dev/cli/usage

Installs the Kreuzberg CLI using the Homebrew tap.

```bash
brew install kreuzberg-dev/tap/kreuzberg
```

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

### Install Kreuzberg with API server extra

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

Installation command that includes the API server extra.

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

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

### ListEmbeddingPresets() usage example

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

Example that calls ListEmbeddingPresets and prints the available preset names.

```csharp
var presets = KreuzbergClient.ListEmbeddingPresets();
Console.WriteLine($"Available: {string.Join(", ", presets)}");
```

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

### Build and serve documentation locally

Source: https://docs.kreuzberg.dev/guides/development

Commands to build and serve the documentation locally.

```bash
task docs:build
task docs:serve
```

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

### Example: Get embedding preset details with Kreuzberg.get_embedding_preset/1

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

Get details about the "fast" embedding preset using Kreuzberg.get_embedding_preset/1. The example prints the preset name and dimensions from the returned map.

```elixir
{:ok, preset} = Kreuzberg.get_embedding_preset("fast")
IO.puts("Preset: #{preset["name"]}")
IO.puts("Dimensions: #{preset["dimensions"]}")
```

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

### Complete code migration example

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

Shows the full before and after code for migrating from 3.x to 4.x, including namespace, configuration, and method call changes.

```php
// Before
use Kreuzberg\Config\Config;


$config = new Config();
$config->extractImages = true;
$result = $kreuzberg->extract('file.pdf', $config);


// After
use Kreuzberg\Config\ExtractionConfig;


$config = new ExtractionConfig(extractImages: true);
$result = $kreuzberg->extractFile('file.pdf', config: $config);
```

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

### Examples: Get extensions for MIME types with Kreuzberg.get_extensions_for_mime/1

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

Get file extensions associated with MIME types using Kreuzberg.get_extensions_for_mime/1. The examples show that PDF maps to ["pdf"] and JPEG maps to ["jpg", "jpeg"].

```elixir
{:ok, exts} = Kreuzberg.get_extensions_for_mime("application/pdf")
IO.inspect(exts)
# => ["pdf"]
```

```elixir
{:ok, exts} = Kreuzberg.get_extensions_for_mime("image/jpeg")
IO.inspect(exts)
# => ["jpg", "jpeg"]
```

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

### GetExtensionsForMime() usage examples

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

Examples showing how to get file extensions for PDF and JPEG MIME types. Note that multiple extensions may be returned.

```java
// Get file extensions for PDF files
List<String> extensions = Kreuzberg.getExtensionsForMime("application/pdf");
System.out.println(extensions); // ["pdf"]


// Get file extensions for JPEG images (multiple extensions possible)
List<String> extensions = Kreuzberg.getExtensionsForMime("image/jpeg");
System.out.println(extensions); // ["jpg", "jpeg"]
```

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

### Plugin Management Example

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

Lists available OCR backends and demonstrates unregistering a post-processor by name.

```ruby
# List available OCR backends
puts "OCR Backends: #{Kreuzberg.list_ocr_backends.join(', ')}"

# Register and unregister
Kreuzberg.unregister_post_processor('word_count')
```

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

### Iterate embedding presets

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

Example of listing and getting embedding presets.

```python
from kreuzberg import get_embedding_preset, list_embedding_presets


for name in list_embedding_presets():
    preset = get_embedding_preset(name)
    print(f"{preset.name}: {preset.chunk_size}")

```

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

### Example getting extensions for MIME type

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

Example retrieving extensions for application/pdf. Prints the comma-separated list (here ["pdf"]) and frees it with kreuzberg_free_string after checking for NULL.

```c
char *exts = kreuzberg_get_extensions_for_mime("application/pdf");
if (exts != NULL) {
    printf("Extensions: %s\n", exts); /* ["pdf"] */
    kreuzberg_free_string(exts);
}
```

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

### Go: load config from file and extract

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

Go example using LoadExtractionConfigFromFile("") to discover config and ExtractFileSync to extract a PDF. Logs fatal errors if config discovery or extraction fails.

```go
package main


import (
  "log"


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


func main() {
  config, err := kreuzberg.LoadExtractionConfigFromFile("")
  if err != nil {
    log.Fatalf("discover config failed: %v", err)
  }


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


  log.Printf("Content length: %d", len(result.Content))
}
```

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

### LlmConfig Configuration File Examples in TOML and YAML

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

Configuration file examples for setting LlmConfig in TOML and YAML formats. Both include commented optional api_key and base_url fields.

```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://...
```

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

### Example: list OCR backends

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

Loads kreuzberg, lists OCR backends, and prints them. Output is a comma-separated list of backend names.

```R
library(kreuzberg)


backends <- list_ocr_backends()
cat("Available OCR backends:", paste(backends, collapse = ", "), "\n")
```

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

### Example: Get and print Kreuzberg version

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

Calls Kreuzberg.getVersion() and prints the version to standard output.

```java
// Get the Kreuzberg library version
String version = Kreuzberg.getVersion();
System.out.println("Kreuzberg version: " + version);
```

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

### Basic Configuration Example

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

Basic configuration example: enables caching and sets tesseract as the OCR backend. The config is passed to extract_file to process a PDF.

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


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

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

### get_extensions_for_mime() example

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

Gets file extensions for a given MIME type. Prints the extensions as a comma-separated list.

```R
library(kreuzberg)


extensions <- get_extensions_for_mime("application/pdf")
cat("PDF extensions:", paste(extensions, collapse = ", "), "\n")
```

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

### Programmatic configuration in Go

Source: https://docs.kreuzberg.dev/reference/file-size-limits

Shows how to create ApiSizeLimits in Go using NewApiSizeLimits or the convenience method ApiSizeLimitsFromMB.

```go
import "kreuzberg"


// Create limits: 200 MB for both request body and individual files
limits := kreuzberg.NewApiSizeLimits(
    200 * 1024 * 1024,  // max_request_body_bytes
    200 * 1024 * 1024,  // max_multipart_field_bytes
)


// Or use convenience method with MB values
limits := kreuzberg.ApiSizeLimitsFromMB(200, 200)

```

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

### Async file extraction example

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

Shows how to start an async extraction from a file, poll with isReady(), and block with getResult().

```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;
```

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

### Text annotation example

Source: https://docs.kreuzberg.dev/guides/output-formats

Example of an annotation object marking a character span in a paragraph's text. The `start` and `end` fields are character offsets, and `kind` contains the annotation type (e.g., bold, italic, link).

```json
{ "start": 0, "end": 16, "kind": { "annotation_type": "bold" } }
```

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

### Programmatic configuration in Java

Source: https://docs.kreuzberg.dev/reference/file-size-limits

Shows how to create ApiSizeLimits in Java using the constructor or the fromMB convenience method.

```java
import com.kreuzberg.api.ApiSizeLimits;


// Create limits: 200 MB for both request body and individual files
ApiSizeLimits limits = new ApiSizeLimits(
    200 * 1024 * 1024,  // maxRequestBodyBytes
    200 * 1024 * 1024   // maxMultipartFieldBytes
);


// Or use convenience method with MB values
ApiSizeLimits limits = ApiSizeLimits.fromMB(200, 200);

```

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

### Rust: discover config and extract file

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

Rust example using ExtractionConfig::discover() and extract_file. Falls back to default config if none found, prints content.

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


#[tokio::main]
async fn main() -> kreuzberg::Result<()> {
    let config = ExtractionConfig::discover()?.unwrap_or_default();
    let result = extract_file("document.pdf", None, &config).await?;
    println!("{}", result.content);
    Ok(())
}
```

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

### GetExtensionsForMime() usage example

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

Gets the file extensions for the 'application/pdf' MIME type and prints them joined by commas. The expected output is '.pdf'.

```csharp
var extensions = KreuzbergClient.GetExtensionsForMime("application/pdf");
Console.WriteLine(string.Join(", ", extensions)); // ".pdf"
```

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

### JSON output examples

Source: https://docs.kreuzberg.dev/cli/usage

Shows how to get JSON output for a single file and for batch extraction (JSON is the default batch format).

```bash
# Output as JSON
kreuzberg extract document.pdf --format json
```

```bash
# Batch extract as JSON (default format)
kreuzberg batch documents/*.pdf --format json
```

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

### Async batch file extraction example

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

Shows how to start an async batch extraction from multiple files and wait with a timeout using waitBatch().

```php
<?php


use Kreuzberg\Kreuzberg;


$kreuzberg = new Kreuzberg();


$files = ['doc1.pdf', 'doc2.docx', 'doc3.xlsx'];
$deferred = $kreuzberg->batchExtractFilesAsync($files);


// Wait with timeout (5 seconds)
$results = $deferred->waitBatch(5000);


if ($results !== null) {
    foreach ($results as $i => $result) {
        echo "{$files[$i]}: {$result->content}\n";
    }
} else {
    echo "Extraction timed out\n";
}
```

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

### Run API Server with Config File

Source: https://docs.kreuzberg.dev/guides/docker

Starts the API server using a configuration file mounted from the host. The `serve` command is used with the `--config` flag pointing to the mounted file.

```bash
# With config file
docker run -p 8000:8000 \
  -v $(pwd)/kreuzberg.toml:/config/kreuzberg.toml \
  ghcr.io/kreuzberg-dev/kreuzberg-full:latest \
  serve --config /config/kreuzberg.toml
```

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

### Example: set output format to markdown and run kreuzberg

Source: https://docs.kreuzberg.dev/reference/environment-variables

Shows setting KREUZBERG_OUTPUT_FORMAT to markdown and then running the kreuzberg command.

```bash
export KREUZBERG_OUTPUT_FORMAT=markdown
kreuzberg
```

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

### Java async extraction with Kreuzberg.extractFileAsync

Source: https://docs.kreuzberg.dev/getting-started/quickstart

Use Kreuzberg.extractFileAsync to get a CompletableFuture<ExtractionResult>. The example prints content and table count after the future completes.

```java
import dev.kreuzberg.Kreuzberg;
import dev.kreuzberg.ExtractionResult;
import java.nio.file.Path;
import java.util.concurrent.CompletableFuture;


public class Example {
    public static void main(String[] args) {
        CompletableFuture<ExtractionResult> future =
            Kreuzberg.extractFileAsync(Path.of("document.pdf"), null);


        future.thenAccept(result -> {
            System.out.println(result.getContent());
            System.out.println("Tables: " + result.getTables().size());
        }).join();
    }
}
```

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

### ExtractionResult usage example

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

Shows how to use extract_file() to get an ExtractionResult and access its content, MIME type, page count, tables, and detected languages.

```php
<?php


use function Kreuzberg\extract_file;


$result = extract_file('document.pdf');


echo "Content: {$result->content}\n";
echo "MIME type: {$result->mimeType}\n";
echo "Page count: {$result->metadata->pageCount}\n";
echo "Tables: " . count($result->tables) . "\n";


if ($result->detectedLanguages !== null) {
    echo "Languages: " . implode(', ', $result->detectedLanguages) . "\n";
}
```

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

### Complex configuration example with all options

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

Builds a comprehensive extraction configuration with caching, quality processing, OCR (tesseract, eng+fra), PDF options, image preprocessing, chunking for RAG, language detection, and registers custom post-processors and validators. Then extracts a document and prints results.

```java
import dev.kreuzberg.*;
import dev.kreuzberg.config.*;
import java.nio.file.Path;


public class ComplexExample {
    public static void main(String[] args) throws Exception {
        // Build comprehensive extraction configuration with all options
        ExtractionConfig config = ExtractionConfig.builder()
            .useCache(true)
            .enableQualityProcessing(true)
            .forceOcr(false)


            // Configure OCR for multi-language support
            .ocr(OcrConfig.builder()
                .backend("tesseract")
                .language("eng+fra")
                .build())


            // Configure PDF extraction options
            .pdfOptions(PdfConfig.builder()
                .extractImages(true)
                .extractMetadata(true)
                .build())


            // Configure image preprocessing for better OCR results
            .imagePreprocessing(ImagePreprocessingConfig.builder()
                .targetDpi(300)
                .denoise(true)
                .deskew(true)
                .contrastEnhance(true)
                .build())


            // Configure chunking for RAG workflows
            .chunking(ChunkingConfig.builder()
                .maxChars(1000)
                .maxOverlap(200)
                .enabled(true)
                .build())


            // Configure automatic language detection
            .languageDetection(LanguageDetectionConfig.builder()
                .enabled(true)
                .minConfidence(0.8)
                .build())


            .build();


        // Register custom post-processor for content transformation
        PostProcessor uppercaser = result -> new ExtractionResult(
            result.getContent().toUpperCase(),
            result.getMimeType(),
            result.getMetadata(),
            result.getTables(),
            result.getDetectedLanguages(),
            result.getChunks(),
            result.getImages(),
            result.isSuccess()
        );


        // Register custom validator for quality checks
        Validator minLength = result -> {
            if (result.getContent().length() < 100) {
                throw new ValidationException("Content too short");
            }
        };


        Kreuzberg.registerPostProcessor("uppercase", uppercaser, 100, ProcessingStage.EARLY);
        Kreuzberg.registerValidator("min-length", minLength);


        // Extract document with all configurations applied
        ExtractionResult result = Kreuzberg.extractFile("document.pdf", config);


        // Display extraction results
        System.out.println("Content: " + result.getContent().substring(0, 100));
        System.out.println("Tables: " + result.getTables().size());
        System.out.println("Images: " + result.getImages().size());
        System.out.println("Chunks: " + result.getChunks().size());
        System.out.println("Language: " + result.getLanguage());
        System.out.println("MIME: " + result.getMimeType());
    }
}
```

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

### discover() usage

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

Example of using discover() to load a configuration file and pass it to extract_file_sync().

```R
config <- discover()
if (!is.null(config)) {
  result <- extract_file_sync("document.pdf", config = config)
}
```

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

### Get cache statistics

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

Example of calling cache_stats and printing the total entries and size in bytes. Note: cache statistics are currently not implemented in the FFI layer (TODO).

```ruby
stats = Kreuzberg.cache_stats
puts "Cache entries: #{stats[:total_entries]}"
puts "Cache size: #{stats[:total_size_bytes]} bytes"
```

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

### Load YAML configuration example

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

Example of loading a YAML configuration string and using it with extractBytes to process a PDF.

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

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

### TOML configuration example for multiple settings

Source: https://docs.kreuzberg.dev/reference/environment-variables

Shows a TOML configuration file for setting OCR and chunking options, recommended for complex configurations with many settings.

```toml
# kreuzberg.toml is cleaner for multiple settings
[ocr]
language = "eng"
backend = "tesseract"


[chunking]
max_chars = 2000
max_overlap = 300
```

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

### Python MCP Client Example

Source: https://docs.kreuzberg.dev/guides/mcp-integration

Uses the official `mcp` Python SDK to connect to the Kreuzberg MCP server, list available tools, and call `extract_file` on a document. Requires the `mcp` package installed.

```python
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


async def main() -> None:
    server_params = StdioServerParameters(
        command="kreuzberg", args=["mcp"]
    )


    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()


            tools = await session.list_tools()
            print(f"Available: {[t.name for t in tools.tools]}")


            result = await session.call_tool(
                "extract_file",
                arguments={"path": "document.pdf"},
            )
            print(result)


asyncio.run(main())
```

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

### ApiSizeLimits usage examples across languages

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

Each language shows how to instantiate ApiSizeLimits with default 100 MB limits, use the convenience from_mb/fromMB method for 200 MB limits, or specify byte values directly.

```csharp
using Kreuzberg;
using Kreuzberg.Api;


// Default limits: 100 MB for both request body and individual files
var limits = new ApiSizeLimits();


// Custom limits: 200 MB for both request body and individual files
var customLimits = ApiSizeLimits.FromMB(200, 200);


// Or specify byte values directly
var customLimits2 = new ApiSizeLimits
{
    MaxRequestBodyBytes = 200 * 1024 * 1024,
    MaxMultipartFieldBytes = 200 * 1024 * 1024
};

```

```go
import "kreuzberg"


// Default limits: 100 MB for both request body and individual files
limits := kreuzberg.NewApiSizeLimits(
    100 * 1024 * 1024,
    100 * 1024 * 1024,
)


// Or use convenience method for custom limits
limits := kreuzberg.ApiSizeLimitsFromMB(200, 200)

```

```java
import com.kreuzberg.api.ApiSizeLimits;


// Default limits: 100 MB for both request body and individual files
ApiSizeLimits limits = new ApiSizeLimits();


// Custom limits via convenience method
ApiSizeLimits limits = ApiSizeLimits.fromMB(200, 200);


// Or specify byte values
ApiSizeLimits limits = new ApiSizeLimits(
    200 * 1024 * 1024,
    200 * 1024 * 1024
);

```

```python
from kreuzberg.api import ApiSizeLimits


# Default limits: 100 MB for both request body and individual files
limits = ApiSizeLimits()


# Custom limits via convenience method
limits = ApiSizeLimits.from_mb(200, 200)


# Or specify byte values
limits = ApiSizeLimits(
    max_request_body_bytes=200 * 1024 * 1024,
    max_multipart_field_bytes=200 * 1024 * 1024
)

```

```ruby
require 'kreuzberg'


# Default limits: 100 MB for both request body and individual files
limits = Kreuzberg::Api::ApiSizeLimits.new


# Custom limits via convenience method
limits = Kreuzberg::Api::ApiSizeLimits.from_mb(200, 200)


# Or specify byte values
limits = Kreuzberg::Api::ApiSizeLimits.new(
  max_request_body_bytes: 200 * 1024 * 1024,
  max_multipart_field_bytes: 200 * 1024 * 1024
)

```

```rust
use kreuzberg::api::ApiSizeLimits;


// Default limits: 100 MB for both request body and individual files
let limits = ApiSizeLimits::default();


// Custom limits via convenience method
let limits = ApiSizeLimits::from_mb(200, 200);


// Or specify byte values
let limits = ApiSizeLimits::new(
    200 * 1024 * 1024,  // max_request_body_bytes
    200 * 1024 * 1024,  // max_multipart_field_bytes
);

```

```typescript
import { ApiSizeLimits } from 'kreuzberg';


// Default limits: 100 MB for both request body and individual files
const limits = new ApiSizeLimits();


// Custom limits via convenience method
const limits = ApiSizeLimits.fromMb(200, 200);


// Or specify byte values
const limits = new ApiSizeLimits({
    maxRequestBodyBytes: 200 * 1024 * 1024,
    maxMultipartFieldBytes: 200 * 1024 * 1024
});

```

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

### Handle missing OCR dependency with MissingDependencyError

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

Configures OCR with the tesseract backend and English language, then handles a MissingDependencyError by logging the missing dependency name. Useful for guiding users to install required OCR libraries.

```go
cfg := &kreuzberg.ExtractionConfig{
  OCR: &kreuzberg.OCRConfig{
    Backend:  "tesseract",
    Language: stringPtr("eng"),
  },
}


result, err := kreuzberg.ExtractFileSync("scanned.pdf", cfg)
if err != nil {
  var missingDep *kreuzberg.MissingDependencyError
  if errors.As(err, &missingDep) {
    log.Printf("Install %s to use OCR\n", missingDep.Dependency)
    return
  }
  log.Fatalf("extraction failed: %v\n", err)
}
```

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

### Registry lookup for application/pdf extractor

Source: https://docs.kreuzberg.dev/concepts/extraction-pipeline

Retrieves the extractor for a specific MIME type from the registry. The `get` call returns a `Result`; the `?` operator propagates errors if the MIME type is not registered. This example shows how to obtain an extractor after MIME resolution, before performing format extraction.

```rust
let registry = get_document_extractor_registry();
let extractor = registry.get("application/pdf")?;

```

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

### Hybrid extraction with extract_bytes and output_format

Source: https://docs.kreuzberg.dev/migration/from-unstructured

Use this hybrid approach to get both element-based and page-based output in a single call. The `output_format` key enables element extraction, while `pages.extract_pages` enables per-page content. The example then shows how to iterate over `result.elements` and `result.pages` to process headings and blocks.

```python
from kreuzberg import extract_bytes


result = extract_bytes(pdf_bytes, "application/pdf", {
    "output_format": "element_based",  # Get elements
    "pages": {"extract_pages": true}   # Also get per-page content
})


# Element-based processing
for element in result.elements:
    if element.element_type == "title":
        index_heading(element.text)


# Page-based processing
for page in result.pages:
    if page.hierarchy:
        for block in page.hierarchy.blocks:
            if block.level == "h1":
                process_section(block.text)
```

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

### Example: Define and register an OCR backend

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

Shows how to define an OCR backend module implementing recognize/2 and supported_languages/0, then register it using Kreuzberg.Plugin.register_ocr_backend/1.

```elixir
defmodule MyApp.CustomOCRBackend do
  def recognize(image_data, language) do
    # Custom OCR logic
    {:ok, "Extracted text"}
  end

  def supported_languages do
    ["en", "de", "fr"]
  end
end

:ok = Kreuzberg.Plugin.register_ocr_backend(MyApp.CustomOCRBackend)

```

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

### Load TOML configuration example

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

Example of loading a TOML configuration string. Note the comment about OCR configuration via config.ocr.backend.

```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');
```

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

### Kreuzberg Class Usage Example

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

Shows how to create a Kreuzberg instance with default or custom configuration, and how to override configuration 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 Tesseract language packs and verify with --list-langs

Source: https://docs.kreuzberg.dev/guides/ocr

Commands for installing additional Tesseract language packs on macOS and Ubuntu/Debian, then verifying installed languages. Note the comment markers and installation syntax.

```bash
# macOS — all languages
brew install tesseract-lang


# Ubuntu/Debian — individual languages
sudo apt-get install tesseract-ocr-deu  # German
sudo apt-get install tesseract-ocr-fra  # French


# Verify installed languages
tesseract --list-langs
```

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

### Get Go package: go get .../kreuzberg-lts/v4

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

Fetch the Go binding of Kreuzberg using go get.

```bash
go get .../kreuzberg-lts/v4
```

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

### Programmatic configuration in Ruby

Source: https://docs.kreuzberg.dev/reference/file-size-limits

Shows how to create ApiSizeLimits in Ruby using from_mb or the constructor with custom byte values.

```ruby
require 'kreuzberg'


# Create limits: 200 MB for both request body and individual files
limits = Kreuzberg::Api::ApiSizeLimits.from_mb(200, 200)


# Or create with custom byte values
limits = Kreuzberg::Api::ApiSizeLimits.new(
  max_request_body_bytes: 200 * 1024 * 1024,
  max_multipart_field_bytes: 200 * 1024 * 1024
)

```

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

### Install Python package with pip

Source: https://docs.kreuzberg.dev/getting-started/installation

Installs the Kreuzberg Python library via pip. This is the primary installation method for Python users.

```bash
pip install kreuzberg
```

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

### Install Tesseract OCR

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

Commands to install Tesseract OCR on Ubuntu/Debian, macOS, and Windows. The Windows installation requires downloading from the provided URL.

```bash
# Ubuntu/Debian
sudo apt-get install tesseract-ocr


# macOS
brew install tesseract


# Windows
# Download from https://github.com/UB-Mannheim/tesseract/wiki
```
Tokens:
Raw