Skip to main content
Glama
web-algebra-mcp

web-algebra-mcp

Official
by AtomGraph

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
CERT_PASSWORDNoPassword for the certificate above.
CERT_PEM_PATHNoPath to the LinkedDataHub owner certificate (PEM). Only needed for LinkedDataHub operations.
OPENAI_API_KEYNoOpenAI API key. Only needed for the SPARQLString tool, which asks a model to write the query.

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
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 (&lt; &gt; &amp;)
    ✅ 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.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

B3.2/5.0

Scored across 34 tools

Disambiguation4/5

Most tools have clearly distinct resource/action targets: HTTP methods differ, LDH add-query tools differ from SPARQL execution tools, and block types are separated. A few pairs remain confusable, especially ldh-CreateContainer vs ldh-CreateItem, ldh-AddSelect vs SELECT, ldh-AddConstruct vs CONSTRUCT, and Substitute vs Values.

Naming Consistency2/5

The set mixes all-caps HTTP/SPARQL names (GET, SELECT, CONSTRUCT), PascalCase functions (EncodeForURI, ExtractClasses, StrUUID), 'ldh-' prefixed PascalCase (ldh-AddView), and bare nouns (Merge, Now). The ldh- prefix provides some grouping, but there is no predictable verb_noun pattern across the whole set.

Tool Count2/5

With 34 tools, the surface is above the 25+ threshold for a heavy set. Although the tools span multiple domains, many are narrow utility or LDH-specific operations, making the set large for reliable agent selection.

Completeness3/5

Coverage includes RDF graph read/write, LDH document and block creation, SPARQL querying, and utility helpers. However, there is no generic HTTP DELETE for RDF graphs, no LDH document deletion, and no ASK query form, leaving notable lifecycle gaps.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues