Skip to main content
Glama
web-algebra-mcp

web-algebra-mcp

Official
by AtomGraph

Web-Algebra

Web-Algebra - Listed on Claude AI Directory

A composable RDF operations system that translates natural language instructions into JSON-formatted domain-specific language operations for loading, querying, and writing RDF Linked Data.

Overview

This system implements generic operations for RDF Linked Data and SPARQL management, as well as some LinkedDataHub-specific operations. Operations can be consumed in two ways:

  1. Executable JSON format: Operations are composed into JSON structures and executed by the provided execution engine

  2. Model Context Protocol (MCP): Operations are exposed as tools for AI agents to use interactively

Instead of agents executing semantic workflows step-by-step through individual MCP tool calls, Web-Algebra enables agents to compile entire workflows into optimized JSON "bytecode" that executes atomically - enabling complex multi-operation compositions.

Related MCP server: mcp-sparql

Demo

Web-Algebra in action: an AI agent builds Linked Data pages over MCP

See WebAlgebra in action - translating natural language into RDF operations.

Architecture

The system is built around the Operation abstract base class that provides:

  • Registry System: Auto-discovery of operations from src/web_algebra/operations/

  • JSON DSL: Operations use @op key with args for parameters, supporting nested operation calls

  • RDFLib Type System: Uses URIRef, Literal, Graph, and Result types internally for proper RDF handling

  • Execution Engine: Both standalone execution and MCP server integration

  • Context System: ForEach operations set row context for inner operations to access via Value

  • URI Resolution: Proper semantic URI construction with ResolveURI operation

Key Components

Operations

The operations cover read-write Linked Data, SPARQL queries, URI manipulation, and LinkedDataHub-specific resource creation. Non-exhaustive list:

  • Linked Data

    • GET

    • PATCH

    • POST

    • PUT

  • SPARQL

    • CONSTRUCT

    • DESCRIBE

    • SELECT

    • Substitute

    • Values

    • SPARQLString

  • Schema

    • ExtractClasses

    • ExtractDatatypeProperties

    • ExtractObjectProperties

    • ExtractOntology

  • Reconciliation

    • Reconcile

  • URI & String Operations

    • ResolveURI

    • EncodeForURI

    • Concat

    • Replace

    • Str

    • StrUUID

    • URI

  • Date/Time

    • Now

  • Control Flow & Variables

    • Value

    • Variable

    • ForEach

    • Iterate

    • Filter

    • Bindings

    • Current

    • Position

    • Last

    • Merge

  • LinkedDataHub-specific

    • ldh-CreateContainer

    • ldh-CreateItem

    • ldh-List

    • ldh-AddFile

    • ldh-AddGenericService

    • ldh-AddResultSetChart

    • ldh-AddSelect

    • ldh-AddConstruct

    • ldh-AddView

    • ldh-AddObjectBlock

    • ldh-AddXHTMLBlock

    • ldh-RemoveBlock

    • ldh-GeneratePortal

    • ldh-GenerateClassContainers

    • ldh-GenerateOntologyViews

Usage

Pre-requisites

  1. Install uv

  2. uv venv
    uv sync

Standalone

Natural language instruction

uv run python src/web_algebra/main.py

Then enter instruction, for example:

Select random 10 UK cities from DBpedia

See the instructions of the examples.

Currently requires OpenAI API access. OPENAI_API_KEY env value has to be set.

Execute JSON

uv run web-algebra --from-json ./examples/city-profiles/plan.json

See the examples: each has the instruction it answers, its plan, the result of a run, and checks.

With LinkedDataHub

  1. Run LinkedDataHub v6

  2. Give web-algebra your LDH's owner certificate and its password in the CERT_PEM_PATH and CERT_PASSWORD environment variables (or the --cert_pem_path and --cert_password options, which override them). For example:

export CERT_PEM_PATH=../LinkedDataHub/ssl/owner/cert.pem
export CERT_PASSWORD="$(cat ../LinkedDataHub/secrets/owner_cert_password.txt)"
uv run web-algebra --from-json ./examples/northwind-category-catalogue/plan.json

Here and throughout this guide, the client certificate and its password are only required for authentication with LinkedDataHub. You don't need them if you're not using LinkedDataHub with Web Algebra.

As MCP server

Install

Requires uv. Add this to your MCP client configuration (e.g. claude_desktop_config.json):

{
    "mcpServers": {
        "web-algebra": {
            "command": "uvx",
            "args": ["--from", "web-algebra", "web-algebra-mcp"],
            "env": {
                "CERT_PEM_PATH": "/path/to/LinkedDataHub/ssl/owner/cert.pem",
                "CERT_PASSWORD": "********"
            }
        }
    }
}

or with Claude Code:

claude mcp add web-algebra -e CERT_PEM_PATH=/path/to/LinkedDataHub/ssl/owner/cert.pem -e CERT_PASSWORD=******** -- uvx --from web-algebra web-algebra-mcp

uvx web-algebra mcp runs the same server.

Environment variables:

Name

Required

Description

CERT_PEM_PATH

No

Path to the LinkedDataHub owner certificate (PEM). Only needed for LinkedDataHub operations.

CERT_PASSWORD

No

Password for the certificate above.

OPENAI_API_KEY

No

OpenAI API key. Only needed for the SPARQLString tool, which asks a model to write the query.

stdio transport

uv run web-algebra-mcp

Streamable HTTP transport

uv run uvicorn web_algebra.server:app --reload

with CERT_PEM_PATH and CERT_PASSWORD set, as above, for LinkedDataHub.

MCP Inspector config

You can the inspector like this:

npx @modelcontextprotocol/inspector

and then open on the URL printed in its console output, for example:

http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=b31e4b3d852b5a2445f45032c484e54e319bf16359585858cf88fe9a90816744

The MCP_PROXY_AUTH_TOKEN is required. If the link does not appear, you need to copy the session token from the console and paste it into inspector's Proxy Session Token config.

Web Algebra's settings:

Claude Desktop tool config from a local checkout

To run the MCP server from a local checkout instead of the published package, add a Web Algebra entry (that uses stdio transport) to the mcpServer configuration your claude_desktop_config.json file:

{
    "mcpServers": {
        "Web Algebra": {
            "command": "uv",
            "args": [
                "--directory",
                "/path/to/Web-Algebra",
                "run",
                "web-algebra-mcp"
            ],
            "env": {
                "CERT_PEM_PATH": "/path/to/LinkedDataHub/ssl/owner/cert.pem",
                "CERT_PASSWORD": "********"
            }
        }
    }
}

Leave the command as it is. Those uv run --with arguments are important, otherwise 3rd party packages cannot be found.

On my Mac, the path to uv has to be absolute, otherwise it doesn't work in Claude Desktop 🤷‍♂️.

CERT_PEM_PATH and CERT_PASSWORD env values are optional.

Available Tools

34 tools
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.

Inputs: inputs (required).

CONSTRUCTB

Executes a SPARQL CONSTRUCT query over an endpoint or over a graph in hand.

Inputs: query (required), graph, endpoint.

DESCRIBEC

Executes a SPARQL DESCRIBE query over an endpoint or over a graph in hand.

Inputs: query (required), graph, endpoint.

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.

Inputs: input (required).

ExtractClassesA

Extracts OWL classes (owl:Class candidates) from rdf:type usage in an RDF dataset, optionally scoped to the subjects in 'bindings'.

Inputs: endpoint (required), bindings.

ExtractDatatypePropertiesA

Extracts OWL datatype properties from literal-valued predicates in an RDF dataset, optionally scoped to the subjects in 'bindings'.

Inputs: endpoint (required), 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'.

Inputs: endpoint (required), 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'.

Inputs: endpoint (required), bindings.

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.

Inputs: url (required).

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.
    

Inputs: url (required), query (required), title (required), service, +2 more.

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.
    

Inputs: url (required), file (required), title (required), description, +1 more.

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

Inputs: url (required), title (required), endpoint (required), auth_pwd, +4 more.

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.
    

Inputs: url (required), value (required), mode, graph, +3 more.

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.

Inputs: url (required), query (required), title (required), chart_type (required), +4 more.

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.
    

Inputs: url (required), query (required), title (required), service, +2 more.

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.

Inputs: url (required), query (required), title (required), mode, +3 more.

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.
    

Inputs: url (required), value (required), title, fragment, +1 more.

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.

Inputs: title (required), parent (required), slug, if_absent, +3 more.

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.

Inputs: title (required), container (required), slug, if_absent, +2 more.

ldh-ListB

Returns a list of children documents for the given URL as SPARQL results JSON.

Inputs: url (required), base, endpoint.

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.

Inputs: url (required), block.

MergeC

Merges a list of RDF graphs as JSON-LD dicts into a single RDF graph as JSON-LD.

Inputs: graphs (required).

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.

Inputs: no named parameters.

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.
    

Inputs: url (required), update (required).

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.

Inputs: url (required), data (required).

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.

Inputs: url (required), data (required).

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).

Inputs: query (required), endpoint (required), type, limit.

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().
    

Inputs: input (required), pattern (required), replacement (required), flags.

ResolveURIA
    Creates a new URI relative to the base URL. The relative URI **must** be pre-encoded.
    

Inputs: base (required), relative (required).

SELECTB

Executes a SPARQL SELECT query over an endpoint or over a graph in hand

Inputs: query (required), graph, endpoint.

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.
    

Inputs: endpoint (required), question (required), context, projection.

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.

Inputs: no named parameters.

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 }".

Inputs: var (required), query (required), binding (required).

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.

Inputs: data (required), query (required), vars.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    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

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      MCP server exposing SPARQL query functionalities for LLMs, enabling query execution, validation, and graph exploration across SPARQL endpoints.
      7
      79 PyPI
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to inspect ontology schemas, search typed objects, and execute read-only SPARQL queries against an RDF triple store.
      3
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to interact with ontology knowledge graphs via MCP SSE, supporting ontology and instance CRUD, relationship traversal, dynamic function registration, role-based tool permissions, and graph visualization.
      -