Sdcreader

io.github.SemanticDataCharterPublished by GitHub account SemanticDataCharterv4.4.1Updated Nov 2, 2026

Read published Semantic Data Charter models: catalog search, record structure, codes, pinned schema.

Overview

AI-generated overview

Reads published Semantic Data Charter models from SDCStudio's public catalog or a local package: catalog search, structure, codes, pinned schema, and governed…

What you can do
  • Search the public catalog by text or list a public project's models
  • Describe one model: title, project, root record, leaf and component counts, Dublin Core, pinned schema URL
  • List a model's leaves in document order with path, type, constraints and identity links, paged
  • List one component's enumerated values with IRI, definition and code system
  • Check a package directory's integrity and return its SHA-256 and pinned schema URL
  • Read a Governed Data Record on disk against its model: attributes, values, context and Exceptional Values
When to use it
Useful when you work with Semantic Data Charter / SDC4 models and need an assistant to inspect published models, their structure and codes, or to read governed data records and verify a package before projecting them into other standards such as DCAT or CDIF.
Requirements
Runs locally over stdio, typically via uvx from the PyPI package sdcreader (Python). No account, API key or environment variable is needed. Network access to the SDCStudio public catalog host is required for catalog and ct_id lookups; the host can be set at start with a command-line option. Package-directory and record tools work on local files.
Before you install
All tools are read-only and need no account, and no tool accepts a URL, so the catalog host is fixed at startup. Records and packages are read from local disk paths you point it at. The reader does not type, validate or interpret values; that remains the caller's work.

Installation

In SourceWeft

  1. Open Sdcreader in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

sdcreader

Read a published Semantic Data Charter model's package for projection into other standards.

A projection describes a model's governed data records in another standard's terms: CDIF, DCAT-US 3.0, DCAT-AP 3.0.1, HealthDCAT-AP, and whatever comes next. What every projection describes is the same evidence, the model's package, and reads it into the same shape. sdcreader is that evidence and that shape, once, with nothing about any projection in it. The four projection writers (sdc_cdif, sdc_dcat3_us, sdc_dcat3_ap, sdc_healthdcat_ap) carried it as identical copies until this package.

pip install sdcreader            # the reader, with HTTP for fetching from the public catalog (since 4.1.0 no extra is needed)
python
from sdcreader import fetch_package, load_package, read_model
pkg = load_package("samples/nhanes-participant")          # a package on diskpkg = fetch_package("xy8upneajsb8vdcmnve01g6g", save_to="pkg/")   # or from SDCStudio's public catalog, no accountmodel = read_model(pkg)
pkg.schema_url_pinned        # https://sdcstudio.axius-sdc.com/dmlib/dm-xy8u...xsd?sha256=0df4...   the exact bytes the records are validated againstmodel.title, model.leaves    # 'NHANES Participant', 153 leaves in document order, each with its path of clustersmodel.codes[ct_id]           # the enumerated values of a component with the IRI, definition and code the schema annotates them withmodel.dc("publisher")        # what the modeler wrote, None where SDCStudio's default sits

What a package is

SDCStudio generates a package for every published model and serves it publicly for models in public projects:

GET /api/v1/catalog/dm/<ct>/the catalog record: title, description, project, the artifact list (catalog.json)
GET /api/v1/catalog/dm/<ct>/<artifact>/a storage pointer, {"download_url": ..., "filename": ..., "storage": "gcs"}, for jsonld, xsd and the rest; the reader follows it
dm-<ct>.jsonldthe model and its components: type, label, description, cardinality, constraints (enumerations, units, ranges, patterns), semantic links (dcterms:identifier the library slot, dcterms:source, dcterms:publisher, skos:exactMatch, rdfs:seeAlso, prov:wasRevisionOf), contains
GET /dmlib/dm-<ct>.xsdthe schema bytes: the Dublin Core header for the model, and for each enumerated value its definition and the code it is defined by (dm-<ct>.xsd)
GET /dmlib/dm-<ct>.versions.jsonevery published version of the schema by SHA-256, with the current one (versions.json)

A package directory holds those four files. The reader refuses a directory without the JSON-LD and the schema, a JSON-LD whose identifier is not the directory's model, and a schema whose bytes are not the published current version: a projection cites the schema by URL and SHA-256, so the bytes have to be the ones that URL serves.

Two gaps in the package are on SDCStudio's issue tracker: the JSON-LD metadata drops fields the schema header carries (#748), and the header omits dc:source (#749). The reader takes the model's Dublin Core from the header, which is complete.

What the reader gives

  • ModelPackage: the four files, the SHA-256, the schema URL and its pinned form (?sha256=), the public catalog URL, and check().
  • Model: title, description, root (the governed record's cluster), components by identifier, leaves in document order (each a Leaf with its component, its path of clusters and a slug of that path, unique in the record), codes (the enumerated values per component as Code: value, IRI, definition, the code it is defined by), metadata (the JSON-LD's) and header (the schema's Dublin Core).
  • Model.dc(name): what the modeler wrote, the header first and the JSON-LD second, with SDCStudio's field defaults as unset: "Universal" for coverage, "None" for relation, "SDC Data Model (DM)" for type, blanks. A projection never publishes a default as a fact. contributors, subjects (the semicolon list), rights_url and rights_statement derive from it.
  • Component: sdc_type, label, description, data_type, constraints, links by predicate (link(p) for the first), contains, iri.
  • Constants: the leaf, numeric and quantified types; the predicate IRIs IDENTIFIER, SOURCE, PUBLISHER, EXACT, CLOSE, SEE_ALSO, HAS_UNIT; DC_DEFAULTS.

Reading a record (4.3.0)

read_record(source, model) reads a Governed Data Record, the XML instance, and joins each value to the component that defines it. source is the record's bytes, its text or a path; a record of another model is refused (RecordError), as is anything that is not an sdc4:dm-<ct_id> record.

  • Record: attributes (instance_id, instance_version, creation_timestamp, current-state, ...), values in document order, and exceptional, the values that carry an Exceptional Value.
  • RecordValue: the component, its path of clusters (root first), instances parallel to the path (which occurrence each cluster is among the same cluster's repeats under the same parent; instance_key pairs them with the clusters' identifiers, one key per cluster instance), an occurrence index for a component repeated within its cluster instance, its position, its elements as the record holds them (a quantity's units nested: {"xdquantity-value": "1", "xdquantity-units": {"label": "Trade Units", "xdstring-value": "EA"}}), and its context (act, vtb, vte, tr, modified, latitude, longitude).
  • ExceptionalValue: the ISO 21090 null flavor (code, name) and its origin: source when it stands in place of the value, recovery when sdcvalidator's recovery inserted it beside a value that failed its constraint. For recovery, RecordValue.rejected is that value, kept so a person can see it.

Cluster members sit inside adapter elements that are not components of the model; the reader passes through them. It does not type, validate or interpret values: that is the caller's work (a mapper, an exporter, a checker).

MCP server

sdcreader is also an MCP server, registered as io.github.SemanticDataCharter/sdcreader, so an assistant can read a published model the way sdcvalidator, sdcgovernance and sdcreceipt let it validate, govern and settle a record. stdio, no SDK, no account, read-only.

uvx sdcreader                    # or: sdcreader-mcp, or python -m sdcreader.mcp_serveruvx sdcreader --host https://your-sdcstudio.example   # a sovereign SDCStudio's public catalog
ToolDoes
find_modelssearch the public catalog by text, or list a public project's models by name
describe_modelone model: title, project, root record, leaf and component counts by type, Dublin Core with SDCStudio's defaults as null, the schema URL pinned to its SHA-256
list_leavesthe leaves in document order with path, type, constraints, code count and identity links, paged
list_codesone component's enumerated values with IRI, definition and code system
check_packagethe reader's integrity check on a package directory
read_recorda Governed Data Record on disk read against its model: attributes, then each value with its component, path, elements, context and Exceptional Value, paged; the model is the one the record names unless a source is given

Each model tool takes a ct_id (fetched from the host the server was started with) or a package directory on disk. No tool takes a URL: the host is fixed at start, so a caller cannot point the server elsewhere. Every tool calls the same functions as the library; the two interfaces describe one model the same way.

Tests

pip install -e ".[dev]"python -m pytest tests -q                    # includes one fetch against productionpython -m pytest tests -q -m "not network"   # offline, as CI runs it

The fixture is the NHANES Participant package of the FAIR Data Demo, the record every projection is proven on.

Versioning

The leading 4 is the SDC4 reference model, as with every Semantic Data Charter package. An addition to what the reader exposes is a minor version, a fix a patch; the major changes only when the reference model does.

License

Apache-2.0 (see LICENSE, NOTICE).

Source: README.md at commit 743f9a4

Tools

6

find_models

Search SDCStudio's public catalog of published models by text, or list the models of one public project by name. Needs no account. Returns identifiers, titles and projects; pass an identifier to describe_model.

Parameterspagesearchprojectpage_size

describe_model

Describe one published model: title, description, project, the root record, how many leaves and components it has and of which types, its Dublin Core as the modeler wrote it (defaults reported as null), its semantic links, and the schema URL pinned to the SHA-256 of the bytes every record is validated against.

Parametersct_iddirectory

list_leaves

The model's leaves in document order, each with its path of clusters, its SDC4 type, its constraints, how many enumerated values it has and its identity links. Paged: a model can have more than a thousand leaves.

Parametersct_idlimitoffsetdirectory

list_codes

The enumerated values of one component in a model: each value with the IRI, definition and code system the published schema annotates it with.

Parametersct_idcomponentrequireddirectory

read_record

Read a Governed Data Record (an XML file on disk) against its model: the record's attributes and each value in document order with its component, path of clusters, elements, context and any Exceptional Value (ISO 21090 code, name, and whether it was written at the source or inserted by recovery beside a rejected value). The model is the one the record names, fetched by its identifier unless ct_id or directory is given. Paged. Does not validate the record.

Parametersct_idlimitoffsetrecordrequireddirectory

check_package

Run the reader's integrity check on a package directory: the JSON-LD names the directory's model, it has components, the schema is an XML Schema, and its bytes are the published current version when versions.json is present. Returns the SHA-256 and the pinned schema URL.

Parametersdirectoryrequired

Version history

4
  1. v4.4.1LatestOct 26, 2026
  2. v4.4.0Oct 25, 2026
  3. v4.3.1Oct 25, 2026
  4. v4.2.0Oct 13, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts
  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts