Document Summarisation

Generate a one-paragraph summary of extracted documents for search snippets, indexing, or quick reviews. Choose extractive summarization for deterministic, network-free local processing, or abstractive for fluent, AI-generated prose.

Backends

Strategy	Cargo feature	Network	Quality	Latency
`Extractive` (default)	`summarization`	None — fully local	Sentence-level selection from source	< 100 ms typical
`Abstractive`	`summarization-llm`	LLM provider	Generates novel prose, can summarise across sentences	Provider-dependent

When to Use

You need a one-paragraph TL;DR for indexing or search snippets.
You need a deterministic, network-free summary (extractive only).
You need a fluent abstractive summary for downstream LLM consumption.

When Not to Use

You need full per-section summaries. Chunk the document first and summarise each chunk separately.
You need cross-document summarisation. Summarise per document, then summarise the summaries with the LLM backend.

Configuration

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import asyncio
from xberg import extract, ExtractInput, ExtractInputKind
from xberg._xberg import ExtractionConfig

async def main() -> None:
    input = ExtractInput(kind=ExtractInputKind("uri"), uri="https://example.com/text/book_war_and_peace_1p.txt")
    config = ExtractionConfig.from_json("{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}")
    result = await extract(input, config)
    print(result.results[0].summary)

asyncio.run(main())

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import { ExtractInput, ExtractInputKind, ExtractionConfig, SummaryStrategy, extract } from "@xberg-io/xberg";
async function main() {
  const input: ExtractInput = { kind: ExtractInputKind.Uri, uri: "https://example.com/text/book_war_and_peace_1p.txt" };
  const config: ExtractionConfig = { summarization: { maxTokens: 80, strategy: SummaryStrategy.Extractive } };
  const result = await extract(input, config);
  console.log(result.results?.[0]?.summary);
}

void main();

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import { WasmExtractInput, WasmExtractInputKind, extract } from "@xberg-io/xberg-wasm";
async function main() {
  const input: WasmExtractInput = (() => { const _u0 = WasmExtractInput.default(); _u0.kind = WasmExtractInputKind.Uri; _u0.uri = "https://example.com/text/book_war_and_peace_1p.txt"; return _u0; })();
  const result = await extract(input, { summarization: { maxTokens: 80, strategy: "extractive" } });
  console.log(result.results[0].summary);
}

void main();

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

use xberg::extract;
use xberg::ExtractInput;

#[tokio::main]
async fn main() {
    let input_json: serde_json::Value = serde_json::from_str(r#"{"kind":"uri","uri":"https://example.com/text/book_war_and_peace_1p.txt"}"#).unwrap();
    let input = serde_json::from_value::<ExtractInput>(input_json).unwrap();
    let config_json: serde_json::Value = serde_json::from_str(r#"{"summarization":{"max_tokens":80,"strategy":"extractive"}}"#).unwrap();
    let config = serde_json::from_value(config_json).unwrap();
    let result = extract(input, &config).await.expect("call failed");
    println!("{:?}", result.results[0].summary);
}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

package main

import (
  "fmt"
  xberg "github.com/xberg-io/xberg/packages/go"
)

func ptr[T any](value T) *T { return &value }
func main() {
  input := xberg.ExtractInput{
    Kind: ptr(xberg.ExtractInputKindURI),
    URI:  ptr(`https://example.com/text/book_war_and_peace_1p.txt`),
  }
  config := xberg.ExtractionConfig{
    Summarization: &xberg.SummarizationConfig{
    Strategy:  ptr(xberg.SummaryStrategyExtractive),
    MaxTokens: ptr(uint32(80)),
  },
  }
  result, err := xberg.Extract(input, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Results[0].Summary)
}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import io.xberg.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var inputJson = "{\"kind\":\"uri\",\"uri\":\"https://example.com/text/book_war_and_peace_1p.txt\"}";
        var input = JsonUtil.fromJson(inputJson, ExtractInput.class);
        var configJson = "{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}";
        var config = JsonUtil.fromJson(configJson, ExtractionConfig.class);
        var result = Xberg.extract(input, config);
        System.out.println(result.results().get(0).summary());
    }
}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import io.xberg.*
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

fun main() = kotlinx.coroutines.runBlocking {
    val mapper = jacksonObjectMapper().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
    val input = mapper.readValue("{\"kind\":\"uri\",\"uri\":\"https://example.com/text/book_war_and_peace_1p.txt\"}", ExtractInput::class.java)
    val config = mapper.readValue("{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"},\"url\":{\"crawl\":{\"ssrf\":{}}}}", ExtractionConfig::class.java)
    val result = Xberg.extract(input, config)
    println(result.results.first().summary)
}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

using System;
using System.Text.Json;
using Xberg;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var result = await XbergConverter.ExtractAsync(new ExtractInput { Kind = JsonSerializer.Deserialize<ExtractInputKind>("\"uri\"", ConfigOptions)!, Uri = "https://example.com/text/book_war_and_peace_1p.txt" }, new ExtractionConfig { Summarization = new SummarizationConfig { MaxTokens = 80, Strategy = JsonSerializer.Deserialize<SummaryStrategy>("\"extractive\"", ConfigOptions)! } });
Console.WriteLine(result.Results[0].Summary);

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import Xberg

let result = try await Xberg.extract("{\"kind\":\"uri\",\"uri\":\"https://example.com/text/book_war_and_peace_1p.txt\"}", "{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}")
debugPrint(result.results()[0].summary() as Any)

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

require "xberg"
result = Xberg.extract(Xberg::ExtractInput.new(kind: 'uri', uri: 'https://example.com/text/book_war_and_peace_1p.txt'), { 'summarization' => { 'max_tokens' => 80, 'strategy' => 'extractive' } })
puts result.results[0].summary.inspect

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Xberg\Xberg;
use Xberg\ExtractInput;
$input = \Xberg\ExtractInput::from_json(json_encode(["kind" => "uri", "uri" => "https://example.com/text/book_war_and_peace_1p.txt"]));
$result = Xberg::extract($input, ["summarization" => ["max_tokens" => 80, "strategy" => "extractive"]]);
var_dump($result->getResults()[0]->getSummary());

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

input_value = %Xberg.ExtractInput{kind: "uri", uri: "https://example.com/text/book_war_and_peace_1p.txt"}
result = Xberg.extract_async(input_value, "{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}")
IO.inspect(Enum.at(result.results, 0).summary)

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

import 'dart:io';
import 'package:xberg/xberg.dart';
import 'package:xberg/src/xberg_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final input = await createExtractInputFromJson(json: '{"kind":"uri","uri":"https://example.com/text/book_war_and_peace_1p.txt"}');
    final config = await createExtractionConfigFromJson(json: '{"summarization":{"max_tokens":80,"strategy":"extractive"}}');
    final result = await XbergBridge.extract(input, config: config);
    stdout.writeln(result.results[0].summary);
  } finally {
    RustLib.dispose();
  }
}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

const std = @import("std");
const xberg = @import("xberg");

pub fn main() !void {
    const _result_json = try xberg.extract("{\"kind\":\"uri\",\"uri\":\"https://example.com/text/book_war_and_peace_1p.txt\"}", "{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

TextRank extractive summary over a multi-paragraph plain text document. Pure-Rust, deterministic, no external services required.

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xberg.h"

int main(void) {
    XBERGAlefHandle input_handle = xberg_extract_input_from_json("{\"kind\":\"uri\",\"uri\":\"https://example.com/text/book_war_and_peace_1p.txt\"}");
    XBERGAlefHandle config_handle = xberg_extraction_config_from_json("{\"summarization\":{\"max_tokens\":80,\"strategy\":\"extractive\"}}");
    XBERGAlefHandle result = xberg_extract(input_handle, config_handle);
    xberg_extract_input_free(input_handle);
    xberg_extraction_config_free(config_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}

For CLI and server configuration, add the same settings to xberg.toml:

[summarization]
strategy = "extractive"
max_tokens = 200