Config reference

This page is an exhaustive, field-by-field reference for rudof.toml (the file read by --config/-c and the config discovery process). For an introduction to how configuration is loaded and merged, see Configuration; this page only documents what can be set.

Note on how this page is generated: this reference is hand-written from the Rust source of RudofConfig and the per-subsystem config structs it aggregates (see the "Source" line under each section below). rudof doesn't currently have tooling that extracts doc comments from these structs automatically (no schemars/documented-style derive is used for this purpose — schemars is used elsewhere, for the MCP server's tool schemas), so if a field is added, renamed, or its default changes, this page needs a matching manual update rather than being regenerated.

rudof config prints the effective configuration (defaults merged with whatever files were discovered) as plain TOML, which is useful as a starting template — but the TOML crate doesn't carry Rust doc comments into that output, so it isn't self-documenting. This page is the missing piece.

Top-level keys

Source: rudof_lib/src/config/rudof.rs, rudof_lib/src/config/common.rs

Every other key is a [table] for one subsystem, listed below.

Base IRI propagation

After loading, RudofConfig resolves cross-section values (RudofConfig::resolve()):

• Any section with its own base_iri unset ([rdf], [shex], [service], [tap2shex]) inherits the top-level base_iri (or http://base if auto_base = true).
• A handful of fields exist in the Rust structs only because a section embeds another section's config (e.g. [shex_validator] embeds a copy of [rdf] and [shex], [shacl] embeds a copy of [rdf], [tap2shex] embeds a copy of [tap], [shex2uml]/[shex2html]/[shex2sparql] embed a copy of [shex]). These embedded copies are always overwritten with the real top-level section on resolve, so they aren't independently configurable — setting them directly in TOML has no effect. They're omitted from the tables below; only the tables actually worth setting are listed.

There is no [pgschema] table — PGSchema loading is controlled entirely through CLI flags / the rudof_lib API, not through rudof.toml.

[logging] — diagnostic output

Source: rudof_lib/src/config/logging.rs

level accepts either a bare level name — "error", "warn", "info", "debug", or "trace" — or a full tracing_subscriber::EnvFilter directive string such as "rudof_rdf=debug,info".

A bare level is automatically scoped to rudof's own crates, with everything else — HTTP and TLS libraries, the shell's line editor, etc. — capped at warn. This is what keeps debug/trace readable: without it, turning up verbosity to see what rudof itself is doing also dumps per-keystroke tracing from the line editor and every dependency's own internals. Write a filter containing = or , yourself (e.g. "debug,reqwest=trace") to opt back into a dependency's logs — a filter like that is passed to EnvFilter unscoped, exactly as written.

[logging]
level = "debug"

Inside the shell, this can also be changed for the rest of the session without restarting:

rudof> config set logging.level debug
logging.level = debug

RUST_LOG, when set, takes precedence over a persisted logging.level at startup (both go through the same bare-level scoping above) — but $RUST_LOG can only be read once, at process start, so it's config set logging.level alone that can change the filter live once the shell is already running.

[rdf] — RDF data

Source: rudof_rdf/src/rdf_core/rdf_data_config.rs

[rdf.endpoints.<name>]

Each key under endpoints names one registered endpoint. The registered name is actually the endpoint's own name field — the <name> in the table header is just where it lives in the TOML tree, and should match name for a given endpoint to make sense, though nothing enforces that. -e NAME/--endpoint NAME and the shell's endpoint NAME command match NAME against name case-insensitively — wikidata, Wikidata and WikiData all resolve the same endpoint. rudof pre-registers three by default — Wikidata, DBpedia, UniProt — which you can override or add to.

[rdf.endpoints.Wikidata]
name = "Wikidata"
query_url = "https://query.wikidata.org/sparql"

[rdf.endpoints.Wikidata.prefixmap]
wd = "http://www.wikidata.org/entity/"
wdt = "http://www.wikidata.org/prop/direct/"

The default endpoints are themselves defined this same way, as standalone files — name, query_url, and [prefixmap], without the [rdf.endpoints.<name>] wrapper — under rudof_rdf/endpoints/, embedded into rudof at compile time. Every *.toml file in that folder is registered automatically, so adding a new default endpoint (or changing an existing one) is just adding or editing a file there and opening a pull request — no Rust code change needed. The same file shape can also be loaded at runtime: RdfDataConfig::load_endpoint_description(path) registers an endpoint from such a file under its own name field, which is what the shell's endpoint FILE.toml command (see shell) uses.

[rdf.visualization]

Controls the appearance of --result-format svg/png/plantuml graph output.

Note: unasserted_triple_shape/asserted_triple_shape take the values "Cloud" or "Rectangle" capitalized as shown — unlike most other enum-valued settings on this page, this one isn't lowercased/snake_case.

Node-style fields

Each *_style above (except the arrow ones) is a table with these keys:

Valid color names (snake_case): white, black, cyan, gray, red, green, blue, yellow, light_blue, light_green, light_coral.

Arrow-style fields

[rdf.visualization.uri_style]
line_color = "blue"
line_thickness = 1
background_color = "white"
round_corner = 25

[rdf.qlever]

Only relevant when running RDF data through a QLever Docker container backend (--backend qlever). Every field is optional; rudof only sets a --flag on the QLever process when you set the corresponding key.

[shex] — ShEx schema handling

Source: shex_validation/src/shex_config.rs

[shex_validator] — ShEx validation

Source: shex_validation/src/validator_config.rs

External-shape resolvers (used to resolve EXTERNAL shape declarations) are configured programmatically (add_external_resolver) or via CLI flags, not through rudof.toml.

[shex_validator.shapemap]

[shacl] — SHACL validation

Source: shacl/src/validator/config.rs

Not compiled in on the wasm target.

This section currently has no independently-settable keys of its own — its only field is an embedded copy of [rdf], which is always overwritten by the top-level [rdf] on resolve. It's included here for completeness / forward compatibility (e.g. rudof config will still show a [shacl] table).

[shex2uml] — ShEx → UML/PlantUML conversion

Source: shapes_converter/src/shex_to_uml/shex2uml_config.rs

[shex2html] — ShEx → HTML conversion

Source: shapes_converter/src/shex_to_html/shex2html_config.rs

[shacl2shex] — SHACL → ShEx conversion

Source: shapes_converter/src/shacl_to_shex/shacl2shex_config.rs

Unlike the other embedded-subsystem fields described in Base IRI propagation, [shacl2shex].shacl (an embedded copy of [shacl]) is not overwritten by resolve() — if you need to point shacl2shex at different SHACL settings than the top-level [shacl], you can set [shacl2shex.shacl] directly.

[tap] — DCTAP (CSV) handling

Source: dctap/src/tap_config.rs

Placeholder resolvers are tables of the form { stem = "..." } (currently the only kind is stem, which generates "<stem><row number>"-style values):

[tap.property_placeholders.x]
stem = "pending"

[tap2shex] — DCTAP → ShEx conversion

Source: shapes_converter/src/tap_to_shex/tap2shex_config.rs

[shex2sparql] — ShEx → SPARQL conversion

Source: shapes_converter/src/shex_to_sparql/shex2sparql_config.rs

[service] — SPARQL service description

Source: sparql_service/src/service_config.rs

[comparator] — shape comparison

Source: shapes_comparator/src/comparator_config.rs

Full example

Combining several sections above into one file (based on bindings/python/examples/example.toml):

base_iri = "http://example.org/"
auto_base = false

[logging]
level = "info"

[rdf]
base_iri = "http://example.org/"

[rdf.endpoints.Wikidata]
name = "Wikidata"
query_url = "https://query.wikidata.org/sparql"

[rdf.endpoints.Wikidata.prefixmap]
wd = "http://www.wikidata.org/entity/"
wdt = "http://www.wikidata.org/prop/direct/"

[shex]
show_imports = true
show_dependencies = true

[shex_validator]
max_steps = 100
check_negation = true

[tap]
delimiter = ","
flexible = true

[tap2shex]
base_iri = "http://example.org/"

[tap2shex.prefixmap]
dc = "http://purl.org/dc/terms/"

Generate a real starting point for your own project with rudof config -o rudof.toml, then edit in the keys you need from the tables above — you only ever need to set what you want to override.