fabricatio-tagging

MIT

LLM-powered tag generation for text content. Part of the Fabricatio agent framework.

Installation

This package is part of the fabricatio monorepo and can be installed as an optional dependency using either pip or uv:

pip install fabricatio[tagging]
# or
uv pip install fabricatio[tagging]

For a full installation that includes this package and all other components of fabricatio:

pip install fabricatio[full]
# or
uv pip install fabricatio[full]

Overview

fabricatio-tagging provides a Tagging mixin class that uses LLMs to generate descriptive tags from text. It accepts a single string or a list of strings and returns corresponding tag lists, driven by a configurable Handlebars template.

The package extends Propose from fabricatio-core, so any role class that mixes in Tagging gains the tagging() method alongside existing proposal capabilities.

Key Classes

Tagging (fabricatio_tagging.capabilities.tagging)

A mixin extending Propose that adds the tagging() async method.

Parameters:

Raises TypeError if text is neither a str nor a List[str].

TaggingConfig (fabricatio_tagging.config)

Frozen dataclass controlling which Handlebars template is used for tag generation.

Access via the singleton:

from fabricatio_tagging.config import tagging_config
print(tagging_config.tagging_template)

Usage

Mixin Tagging into a role class and call tagging():

import asyncio
from fabricatio_core.capabilities.propose import Propose
from fabricatio_tagging.capabilities.tagging import Tagging


class MyRole(Propose, Tagging):
    """A role that can generate tags."""
    pass


async def main():
    role = MyRole(name="tagger")

    # Tag a single string
    tags = await role.tagging("Python is a high-level programming language.")
    print(tags)  # e.g. ["python", "programming", "language"]

    # Tag with requirements and a cap
    tags = await role.tagging(
        "Rust is a systems language.",
        requirement="use lowercase technical tags only",
        k=3,
    )
    print(tags)  # e.g. ["rust", "systems", "memory-safety"]

    # Tag multiple strings in a batch
    batch_tags = await role.tagging([
        "Django is a Python web framework.",
        "Tokio is an async runtime for Rust.",
    ])
    print(batch_tags)  # e.g. [["python", "web", "django"], ["rust", "async", "tokio"]]


asyncio.run(main())

The requirement parameter provides natural-language guidance to the LLM (e.g. "use single words only", "tag by topic and difficulty level"). The k parameter limits the number of tags returned per text.

Configuration

All options below are read through the fabricatio configuration chain (see the Configuration Guide). Set them under the [ext.tagging] table in fabricatio.toml, equivalently under [tool.fabricatio.ext.tagging] in pyproject.toml, or via FABRICATIO_EXT__TAGGING__<FIELD_UPPER> environment variables.

[ext.tagging]
tagging_template = "built-in/tagging"

Access at runtime: from fabricatio_tagging.config import tagging_config.

Dependencies

• fabricatio-core — Core interfaces, Propose capability, template manager, and configuration system.

No additional dependencies.

License

MIT – see LICENSE