Keyword Extraction

Extract ranked keywords and key phrases from document text for search indexing, topic detection, and content summarization. Choose between YAKE (best for single terms and multilingual content) or RAKE (best for multi-word phrases in technical documents).

Algorithm	Scoring	Best for
YAKE	Higher score = more relevant (0.0–1.0)	General documents, single terms, multilingual
RAKE	Higher score = more relevant (0.0–1.0)	Multi-word phrases, technical docs

Quick Start

Python

Python

import asyncio
from xberg import ExtractInput, extract, ExtractionConfig, KeywordConfig, KeywordAlgorithm

async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        keywords=KeywordConfig(
            algorithm=KeywordAlgorithm.YAKE,
            max_keywords=10,
            min_score=0.3
        )
    )
    output = await extract(ExtractInput(uri="research_paper.pdf"), config)
    result = output.results[0]

    keywords: list = result.extracted_keywords or []
    for kw in keywords:
        score: float = kw.score or 0.0
        text: str = kw.text or ""
        print(f"{text}: {score:.3f}")

asyncio.run(main())

TypeScript

TypeScript

import { extract } from "@xberg-io/xberg";

const config = {
  keywords: {
    algorithm: "yake",
    maxKeywords: 10,
    minScore: 0.3,
  },
};

const output = await extract({ kind: "uri", uri: "research_paper.pdf" }, config);
const result = output.results![0];
console.log(`Content length: ${result.content.length}`);
console.log(`Metadata: ${JSON.stringify(result.metadata)}`);

Rust

Rust

use xberg::{extract, ExtractionConfig, ExtractInput, KeywordConfig, KeywordAlgorithm};

let config = ExtractionConfig {
    keywords: Some(KeywordConfig {
        algorithm: KeywordAlgorithm::Yake,
        max_keywords: 10,
        min_score: 0.3,
        ..Default::default()
    }),
    ..Default::default()
};

let output = extract(ExtractInput::from_uri("research_paper.pdf"), &config).await?;
let result = &output.results[0];

if let Some(keywords) = &result.extracted_keywords {
    println!("Keywords: {:?}", keywords);
}

Go

Go

package main

import (
  "fmt"
  "log"

  "github.com/xberg-io/xberg"
)

func main() {
  maxKeywords := uint(10)
  minScore := float32(0.3)
  kind := xberg.ExtractInputKindURI
  uri := "research_paper.pdf"

  config := xberg.ExtractionConfig{
    Keywords: &xberg.KeywordConfig{
      Algorithm:   xberg.KeywordAlgorithmYake,
      MaxKeywords: &maxKeywords,
      MinScore:    minScore,
    },
  }

  output, err := xberg.Extract(
    xberg.ExtractInput{Kind: &kind, URI: &uri},
    config,
  )
  if err != nil {
    log.Fatalf("extract failed: %v", err)
  }

  fmt.Printf("Keywords: %v\n", output.Results[0].ExtractedKeywords)
}

Java

Java

import io.xberg.ExtractInput;
import io.xberg.ExtractInputKind;
import io.xberg.ExtractedDocument;
import io.xberg.ExtractionConfig;
import io.xberg.ExtractionResult;
import io.xberg.Keyword;
import io.xberg.KeywordAlgorithm;
import io.xberg.KeywordConfig;
import io.xberg.Xberg;
import io.xberg.XbergRsException;

public class KeywordExtractionExample {
    public static void main(String[] args) {
        ExtractionConfig config = ExtractionConfig.builder()
            .withKeywords(KeywordConfig.builder()
                .withAlgorithm(KeywordAlgorithm.Yake)
                .withMaxKeywords(10L)
                .withMinScore(0.3f)
                .build())
            .build();

        ExtractInput input = ExtractInput.builder()
            .withKind(ExtractInputKind.Uri)
            .withUri("research_paper.pdf")
            .build();

        try {
            ExtractionResult output = Xberg.extract(input, config);
            ExtractedDocument result = output.results().get(0);

            if (result.extractedKeywords() == null) {
                System.out.println("No keywords met the configured minimum score.");
                return;
            }
            for (Keyword keyword : result.extractedKeywords()) {
                System.out.printf("%s: %.3f (%s)%n",
                    keyword.text(), keyword.score(), keyword.algorithm());
            }
        } catch (XbergRsException e) {
            System.err.println("Keyword extraction failed: " + e.getMessage());
        }
    }
}

C#

C#

using Xberg;
using System.Collections.Generic;

var config = new ExtractionConfig
{
    Keywords = new KeywordConfig
    {
        Algorithm = KeywordAlgorithm.Yake,
        MaxKeywords = 10,
        MinScore = 0.3
    }
};

var output = await XbergConverter.ExtractAsync(
    ExtractInput.FromUri("research_paper.pdf"),
    config
);
var result = output.Results[0];

foreach (var keyword in result.ExtractedKeywords ?? new List<Keyword>())
{
    Console.WriteLine($"{keyword.Text}: {keyword.Score:F3}");
}

Ruby

Ruby

require 'xberg'

config = Xberg::ExtractionConfig.new(
  keywords: Xberg::KeywordConfig.new(
    algorithm: Xberg::KeywordAlgorithm::YAKE,
    max_keywords: 10,
    min_score: 0.3
  )
)

input = Xberg::ExtractInput.new(uri: 'research_paper.pdf')
output = Xberg.extract(input, config)
result = output.results.first

keywords = result.extracted_keywords
keywords.each do |kw|
  puts "#{kw.text}: #{kw.score.round(3)}"
end

Keywords are returned in result.extracted_keywords as objects with text and score fields.

Configuration

See KeywordConfig reference for all configuration options.

Python

Python

import asyncio
from xberg import (
    ExtractInput,
    ExtractionConfig,
    KeywordConfig,
    KeywordAlgorithm,
    extract,
)

async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        keywords=KeywordConfig(
            algorithm=KeywordAlgorithm.YAKE,
            max_keywords=10,
            min_score=0.3,
            language="en"
        )
    )
    output = await extract(ExtractInput(uri="document.pdf"), config)
    result = output.results[0]
    print(f"Content extracted: {len(result.content)} chars")

asyncio.run(main())

TypeScript

TypeScript

import { extract } from "@xberg-io/xberg";

const config = {
  keywords: {
    algorithm: "yake",
    maxKeywords: 10,
    minScore: 0.3,
    language: "en",
  },
};

const output = await extract({ kind: "uri", uri: "document.pdf" }, config);
const result = output.results![0];
console.log(`Content: ${result.content}`);

Rust

Rust

use xberg::{extract, ExtractionConfig, ExtractInput};
use xberg::keywords::{KeywordConfig, KeywordAlgorithm};

#[tokio::main]
async fn main() -> xberg::Result<()> {
    let config = ExtractionConfig {
        keywords: Some(KeywordConfig {
            algorithm: KeywordAlgorithm::Yake,
            max_keywords: 10,
            min_score: 0.1,
            ngram_range: (1, 3),
            language: Some("en".to_string()),
            ..Default::default()
        }),
        ..Default::default()
    };

    let output = extract(ExtractInput::from_uri("document.pdf"), &config).await?;
    let result = &output.results[0];
    println!("Keywords: {:?}", result.extracted_keywords);
    Ok(())
}

Go

Go

package main

import (
  "fmt"

  "github.com/xberg-io/xberg"
)

func main() {
  maxKeywords := uint(10)
  language := "en"

  config := xberg.ExtractionConfig{
    Keywords: &xberg.KeywordConfig{
      Algorithm:   xberg.KeywordAlgorithmYake,
      MaxKeywords: &maxKeywords,
      MinScore:    0.3,
      Language:    &language,
    },
  }

  fmt.Printf("Keywords config: Algorithm=%s, MaxKeywords=%d, MinScore=%f\n",
    config.Keywords.Algorithm,
    *config.Keywords.MaxKeywords,
    config.Keywords.MinScore)
}

Ruby

Ruby

require 'xberg'

config = Xberg::ExtractionConfig.new(
  keywords: Xberg::KeywordConfig.new(
    algorithm: Xberg::KeywordAlgorithm::YAKE,
    max_keywords: 10,
    min_score: 0.3,
    language: 'en'
  )
)

C#

C#

using Xberg;

var config = new ExtractionConfig
{
    Keywords = new KeywordConfig
    {
        Algorithm = KeywordAlgorithm.Yake,
        MaxKeywords = 10,
        MinScore = 0.3,
        Language = "en"
    }
};

YAKE Score Tuning

Use min_score as a lower-bound cutoff. Higher YAKE scores = higher relevance:

min_score	Effect
0.1	Keeps most keywords
0.3	Main topics only
0.5	Core concepts only

yake_params.window_size controls co-occurrence context: 1–2 for narrow domains, 2–3 for general (default: 2), 3–4 for discussion-heavy content.

RAKE Score Tuning

Use min_score as a lower-bound cutoff. Higher RAKE scores = higher relevance:

min_score	Effect
0.1	Keeps most keywords
0.3	Main phrases only
0.5	Only highly specific phrases

rake_params.min_word_length (default: 1) and rake_params.max_words_per_phrase (default: 3) control phrase boundaries.

Troubleshooting

• Too few keywords — Lower min_score, check result.content is non-empty, set language to match the document or None to disable stopword filtering
• Too many irrelevant keywords — Raise min_score, set language for stopword filtering, reduce ngram_range upper bound
• Multi-word phrases missing (YAKE) — Switch to RAKE or confirm ngram_range upper bound is >= 2
• Keywords don’t match content — Verify text was extracted (result.content) and language matches the document

See the KeywordConfig reference for the full parameter list.