| GETA | Retrieves RDF data from a named graph using HTTP GET. The URL serves as both the resource identifier and the named graph address in systems with direct graph identification. Returns the RDF graph describing the resource at that URL. |
| PATCHA | Updates RDF data in a named graph using HTTP PATCH with SPARQL Update.
The URL serves as both the resource identifier and the named graph address in systems with direct graph identification.
Updates the RDF graph at that URL using the SPARQL update payload provided in the `update` argument.
Only INSERT/WHERE and DELETE WHERE forms of SPARQL Update are supported by PATCH! Only a single update operation is allowed.
Returns True if the operation was successful, False otherwise.
Note: This operation does not return the updated graph, it only confirms the success of the operation.
|
| POSTA | Creates or appends RDF data to a named graph using HTTP POST.
The URL serves as both the resource identifier and the named graph address in systems with direct graph identification.
Creates or adds to the RDF graph (provided as JSON-LD payload) at that URL.
Returns True if the operation was successful, False otherwise.
Note: This operation does not return the updated graph, it only confirms the success of the operation.
|
| PUTA | Replaces RDF data in a named graph using HTTP PUT.
The URL serves as both the resource identifier and the named graph address in systems with direct graph identification.
Completely replaces the RDF graph (provided as JSON-LD payload) at that URL.
Returns True if the operation was successful, False otherwise.
Note: This operation does not return the updated graph, it only confirms the success of the operation.
|
| ldh-AddConstructB | Creates a SPARQL CONSTRUCT query resource in a document. This tool creates a SPARQL CONSTRUCT query that can be executed and referenced within LinkedDataHub.
The query can be used for charts, views, or other data processing operations.
This tool:
- Creates a sp:Construct resource with the SPARQL query text
- Posts the new CONSTRUCT query resource to the target document
- Supports optional title, description, fragment identifier, and service URI
Note: the service URI is _not_ the SPARQL endpoint URL but an instance of `sd:Service` that describes the SPARQL service capabilities (and contains the endpoint URL).
The service URI can be used to reference the SPARQL service in other operations.
|
| ldh-AddFileA | Adds a file to a LinkedDataHub document via multipart RDF/POST. Appends `a nfo:FileDataObject ; nfo:fileName ; dct:title ; ...`
to the target document and stores the file bytes at
`<base>/uploads/{sha1}` (LDH's built-in upload namespace).
The file is a resource the document holds, not one of its content blocks: to show it in the content mode,
place it with ldh-AddObjectBlock, the returned `url` as its value.
Arguments:
- `url` — URI of the target document to add the file's description to.
- `file` — absolute local file path. The bytes are read and streamed
to the server.
- `title` — human-readable title (`dct:title`).
- `description` — optional description (`dct:description`).
- `content_type` — optional MIME-type override; auto-detected from
the file path if absent.
Returns a result with `url` (the uploaded file's URI, as the document
describes it after the upload: `<base>/uploads/{sha1}`, `<base>` being
the application's base URI) and `status` (HTTP status code) bindings.
Place the file in the content with ldh-AddObjectBlock, `url` as value.
|
| ldh-AddGenericServiceB | Writes a generic SPARQL service description to a LinkedDataHub document. This tool creates a SPARQL service description that can be referenced and used within LinkedDataHub.
The service description includes endpoint information and supported capabilities.
This tool:
- Creates an sd:Service resource with endpoint URI and supported languages
- Posts the new service description to the target document
- Supports optional title, description, fragment identifier, graph store, and authentication
- Automatically sets SPARQL 1.1 Query and Update support
|
| ldh-AddResultSetChartA | Writes a chart of SPARQL SELECT query results to a LinkedDataHub document.
The chart is a resource the document holds, not one of its content blocks: to show it in the content mode,
place it with ldh-AddObjectBlock, the chart's URI as its value - so give the chart a fragment identifier. A chart shows values: the query's bindings themselves, as a table or a plot, the way a spreadsheet would.
It is the fit for aggregates and measurements - totals, counts, sums per shop or per month. A resource in
a chart is a bare cell, with no image, label or links of its own: to show resources themselves (things,
people, places), use ldh-AddView, whose modes render each one as itself.
A query that returns a row per resource, with the resource's URI among its variables, is a list of
resources and belongs in a view, however many values from related resources it joins in (a thing with
its shop, price and date of purchase; a message with its sender). A chart of it shows each resource as
its address. Chart only what is not one row per resource: totals, counts, sums by shop or by month.
This tool:
- Creates an ldh:ResultSetChart resource linked to an existing sp:Select query resource
- Configures chart type and variable mappings for visualization
- Posts the new chart resource to the target document
- Supports optional title, description, and fragment identifier
Possible chart types include:
- https://w3id.org/atomgraph/client#Table: Table visualization of results
- https://w3id.org/atomgraph/client#BarChart: Bar chart visualization
- https://w3id.org/atomgraph/client#LineChart: Line chart visualization
- https://w3id.org/atomgraph/client#ScatterChart: Scatter chart visualization
- https://w3id.org/atomgraph/client#Timeline: Timeline visualization
Note: The query parameter must be a URI of an existing sp:Select resource, not a SPARQL query string.
|
| ldh-AddSelectB | Creates a SPARQL SELECT query resource in a document. This tool creates a SPARQL SELECT query that can be executed and referenced within LinkedDataHub.
The query can be used for charts, views, or other data processing operations.
This tool:
- Creates a sp:Select resource with the SPARQL query text
- Posts the new SELECT query resource to the target document
- Supports optional title, description, fragment identifier, and service URI
Note: the service URI is _not_ the SPARQL endpoint URL but an instance of `sd:Service` that describes the SPARQL service capabilities (and contains the endpoint URL).
The service URI can be used to reference the SPARQL service in other operations.
|
| ldh-AddViewA | Writes a view of SPARQL SELECT query results to a LinkedDataHub document.
The view is a resource the document holds, not one of its content blocks: to show it in the content mode,
place it with ldh-AddObjectBlock, the view's URI as its value - so give the view a fragment identifier. A view shows resources - things, people, places, documents - each as itself: its label, its image,
its links. LinkedDataHub DESCRIBEs the resources the query's first projected variable binds and renders
those descriptions in the view's mode, so that variable must bind resources (SELECT ?thing WHERE { ... }).
One that binds values - a name, a price, a computed total - describes nothing. To show values or
aggregates (totals, counts, sums by month), use ldh-AddResultSetChart instead.
A list of resources is a view even when what matters about them lives on related resources - a thing's
shop and price on the order it came from, a message's sender on a person. Do not join those values into
one table to show them beside each resource: select the resources, and let each one's own page show
what it links to. Put values that summarise the related resources (spend per shop) in a chart beside it.
This tool:
- Creates an ldh:View resource linked to an existing sp:Select query resource
- Configures optional display mode for the view
- Posts the new view resource to the target document
- Supports optional title, description, fragment identifier, and display mode
Pick the mode by what the resources carry:
- https://w3id.org/atomgraph/client#GridMode: a card per resource, led by its image. The fit for resources
that have one (foaf:img, foaf:depiction, foaf:logo, schema:image, schema:logo, schema:thumbnailUrl):
products, possessions, people, organizations
- https://w3id.org/atomgraph/client#MapMode: a pin per resource that has geo:lat and geo:long. The fit for
places, addresses, venues, shops
- https://w3id.org/atomgraph/client#GraphMode: the resources and the links between them, as a network. The
fit for showing how things connect (who owns what, what came from where)
- https://w3id.org/atomgraph/client#ListMode: a labelled list; the default, for resources with no image or
coordinates
- https://w3id.org/atomgraph/client#TableMode: a row per resource, a column per property, for comparing
many resources property by property
- https://w3id.org/atomgraph/client#ReadMode: each resource's full description, for a few resources
- https://w3id.org/atomgraph/client#ChartMode: the resources' properties charted
Note: The query parameter must be a URI of an existing sp:Select resource, not a SPARQL query string.
|
| ldh-AddObjectBlockA | Appends an object block to a LinkedDataHub document content mode using sequence properties.
Only XHTML blocks and object blocks are shown in the content mode. Other resources can still be added to the document, but they will not be displayed in the content mode. Object blocks reference external resources via URI and can have different display modes.
Only RDF Linked Data objects can be rendered by using display modes, so if you think you're using an RDF URI value, make sure it returns a valid RDF resource (e.g. use the GET operation to verify).
Non-RDF resources (for example images) will be embedded using HTML <object> element.
Possible display modes include:
- https://w3id.org/atomgraph/client#ReadMode: Default mode for displaying the object.
- https://w3id.org/atomgraph/client#GraphMode: Displays the object as a graph.
- https://w3id.org/atomgraph/client#MapMode: Displays the object as a map.
- https://w3id.org/atomgraph/client#ChartMode: Displays the object as a chart.
This tool:
- Fetches the current document to find the next sequence number (rdf:_1, rdf:_2, etc.)
- Creates an ldh:Object resource with rdf:value pointing to the target resource URI
- Posts the new object block to the target document
- Supports optional title, description, fragment identifier, and display mode
Returns True if the operation was successful, False otherwise.
Note: This operation does not return the updated graph, it only confirms the success of the operation.
|
| ldh-AddXHTMLBlockA | Appends an XHTML block to a LinkedDataHub document using sequence properties.
Only XHTML blocks and object blocks are shown in the content mode. Other resources can still be added to the document, but they will not be displayed in the content mode. IMPORTANT: The value parameter must be canonical XML literal - well-formed XHTML content
that will be stored as rdf:XMLLiteral datatype.
The top-level XHTML element must be <div xmlns="http://www.w3.org/1999/xhtml"></div>.
The XHTML can use CSS classes for inline elements from Bootstrap 2.3.2, but no inline CSS styles.
Canonical XML Rules (TL;DR):
✅ Well-formed XML - proper opening/closing tags, escaped special chars (< > &)
✅ Attributes alphabetically ordered - <tag attr1="x" attr2="y"> not <tag attr2="y" attr1="x">
✅ No comments or processing instructions - strip <!-- --> and <?xml ?>
✅ Consistent encoding - UTF-8, normalized whitespace
Bottom line: Valid XML + deterministic formatting = canonical XML.
This tool:
- Fetches the current document to find the next sequence number (rdf:_1, rdf:_2, etc.)
- Creates an ldh:XHTML resource with rdf:value containing the XML literal
- Posts the new XHTML block to the target document
- Supports optional title, description, and fragment identifier
Returns True if the operation was successful, False otherwise.
Note: This operation does not return the updated graph, it only confirms the success of the operation.
|
| ldh-RemoveBlockA | Removes a content block from a LinkedDataHub document. This tool removes content blocks from LinkedDataHub documents by:
- Deleting the sequence property that references the block (rdf:_N)
- Deleting all properties of the block itself
- If no specific block URI is provided, removes any blocks found via sequence properties
The operation uses SPARQL UPDATE (HTTP PATCH) to perform the deletion.
|
| ldh-CreateContainerA | Creates a LinkedDataHub Container document with proper structure. IMPORTANT CONSTRAINTS:
- The document URL needs to end with a trailing slash (/)
- Documents can only be created at URLs relative to existing container's URL
- Example: if https://localhost/blog/ exists, you cannot create https://localhost/blog/posts/something/
before creating https://localhost/blog/posts/
- LinkedDataHub automatically manages timestamps (dct:created, dct:modified)
- LinkedDataHub automatically manages parent-child relationships (sioc:has_parent) based on URI hierarchy
- It only creates: a document already at the URI is left as it is and the operation fails, unless
if_absent is true, which accepts it as the result (like mkdir -p). To replace a document, PUT it.
|
| ldh-CreateItemA | Creates a LinkedDataHub Item document with proper structure. IMPORTANT CONSTRAINTS:
- The document URL needs to end with a trailing slash (/)
- Documents can only be created at URLs relative to existing container's URL
- Example: if https://localhost/blog/ exists, you cannot create https://localhost/blog/posts/something/
before creating https://localhost/blog/posts/
- LinkedDataHub automatically manages timestamps (dct:created, dct:modified)
- LinkedDataHub automatically manages parent-child relationships (sioc:has_parent) based on URI hierarchy
- It only creates: a document already at the URI is left as it is and the operation fails, unless
if_absent is true, which accepts it as the result (like mkdir -p). To replace a document, PUT it.
|
| ldh-ListB | Returns a list of children documents for the given URL as SPARQL results JSON. |
| MergeC | Merges a list of RDF graphs as JSON-LD dicts into a single RDF graph as JSON-LD. |
| NowA | Returns the current date and time as an xsd:dateTime literal in UTC, following SPARQL's NOW(): every Now in one run of a program returns the same value, the time the run began. |
| ReconcileB | The entities a reconciliation service (the W3C Reconciliation Service API) offers for a name, as a result: one row per candidate, best first, binding ?entity (a URI), ?name, ?description, ?score and ?match. type is one of the service's type ids, limit caps the rows. Wikidata's service is https://wikidata-reconciliation.wmcloud.org/en/api, whose type ids are Wikidata items (Q515 city, Q6256 country, Q43229 organization). |
| ResolveURIA | Creates a new URI relative to the base URL. The relative URI **must** be pre-encoded.
|
| ExtractClassesA | Extracts OWL classes (owl:Class candidates) from rdf:type usage in an RDF dataset, optionally scoped to the subjects in 'bindings'. |
| ExtractDatatypePropertiesA | Extracts OWL datatype properties from literal-valued predicates in an RDF dataset, optionally scoped to the subjects in 'bindings'. |
| ExtractObjectPropertiesB | Extracts OWL object properties (and functional properties, closed-world) from IRI-valued predicates in an RDF dataset, optionally scoped to the subjects in 'bindings'. |
| ExtractOntologyB | Extracts a complete OWL ontology (classes, datatype properties, and object properties with functional property restrictions) from an RDF dataset, optionally scoped to the subjects in 'bindings'. |
| CONSTRUCTB | Executes a SPARQL CONSTRUCT query over an endpoint or over a graph in hand. |
| DESCRIBEC | Executes a SPARQL DESCRIBE query over an endpoint or over a graph in hand. |
| SELECTB | Executes a SPARQL SELECT query over an endpoint or over a graph in hand |
| SubstituteA | Gives one variable of a SPARQL query or update a value without removing the variable: an inline VALUES block restricting it to the term is joined into every group of the query, so the query stays valid, a SELECT still projects the variable and every result row still carries it. Subqueries that do not project the variable keep their own copy (it is renamed there). The query must not assign the variable itself (AS or VALUES). A URI is written as , a literal escaped; a blank node is rejected. Substitute is Values over a one-row table; use Values for several variables or rows.
For example, Substitute("SELECT ?city ?label WHERE { ?city rdfs:label ?label }", "city", URI("http://ex.org/C")) produces "SELECT ?city ?label WHERE { VALUES (?city) { (http://ex.org/C) } ?city rdfs:label ?label }". |
| ValuesA | Restricts variables of a SPARQL query or update to the rows of a SPARQL result set, so one query is constrained by, or batched over, the results of another: an inline VALUES block with the rows is joined into every group of the query. The variables stay variables (still projected, still in templates). Columns default to the result's variables; vars selects and orders them; a row that does not bind a column leaves it free (UNDEF). Subqueries that do not project a column keep their own copy; the query must not assign a restricted variable itself (AS or VALUES). Blank nodes are rejected. Substitute is the one-variable, one-value case. |
| SPARQLStringA | Writes a SPARQL query for an endpoint from a natural language question, using an LLM.
`projection` names the variables the query must project (because what follows reads them from its rows).
`context` holds operations (e.g. a SELECT that inventories predicates, or looks a label up) whose
results are shown to the model as what the endpoint holds, before it writes the query.
A query that does not parse or lacks the projection goes back to the model, a few times at most.
|
| ConcatA | Concatenates multiple string values into a single string, per SPARQL's CONCAT() function: if all inputs carry the same language tag the result carries it too, otherwise the result is a simple (xsd:string) literal. |
| EncodeForURIB | Encodes a string to be URI-safe, following SPARQL's ENCODE_FOR_URI behavior. It encodes characters that are not allowed in URIs, such as spaces, slashes, and colons. |
| ReplaceA | Replaces occurrences of a regular-expression pattern in an input string, per SPARQL's REPLACE() / XPath fn:replace. The replacement string may reference capture groups as $1, $2, ...; flags s, m, i, x, q are supported. The result is a string literal of the same kind (datatype/language tag) as the input. Note: this function should not be used to build URIs! That should be done using EncodeForURI()/ResolveURI().
|
| StrUUIDA | Generates a fresh UUID (Universally Unique Identifier) as a string, following the behavior of SPARQL's STRUUID(). Each invocation produces a new unique identifier. |