Execute a SPARQL SELECT query against the knowledge graph (supports time-travel via valid_at/tx)

Export deterministic RDF scoped to one named graph, provenance group, SPARQL CONSTRUCT, or ROOT when no scope is supplied. Scope fields are mutually exclusive.

READ. Propose candidate cross-graph alignments between two named graphs, scored, as an SSSOM mapping set. Returns expected_version, which align_apply requires. Refuses an unknown graph IRI rather than returning 0 candidates.

READ. Apply operator accept/negate decisions to a proposed mapping set. Touches no store. Returns the decided set and the expected_version to carry into align_apply.

WRITE. Materialise decided alignments as owl:sameAs / quipu:distinctFrom in a derived alignment graph. expected_version is REQUIRED and must be carried from the decision: computing it here would hash the set being written, always match, and silently discard a concurrent operator's decision.

READ. The conflicts of merging an incoming share (incoming + base) or promoting a fork (fork) into ROOT, one row per slot with base/ours/theirs values and each side's provenance, bound to what was reviewed. propose:true adds a mechanical proposal with evidence per row; it never sets a decision. present:true returns {decisions, presentation, view}: the standard markdown to show the user, unchanged. Writes nothing.

WRITE. Finish a share merge (incoming + base) or a fork promotion (fork): the clean part plus every decided row in ONE transaction whose source records the reviewer and the decisions hash. Refuses and writes nothing on an undecided row, stale decisions (either side moved), more values than sh:maxCount, a value that is not an RDF term, or (forks) a SHACL refusal. Applying the same decisions again returns outcome already-applied and writes nothing.

Record one choice on one row of a merge decisions file (share or fork) and return {decisions, presentation, view}. Choices: ours, theirs, base, both (only within sh:maxCount), value (with values), defer. Validates the choice against the row; touches no store. Apply with quipu_merge_apply.

Assert facts into the knowledge graph (with optional SHACL validation)

List entities in the knowledge graph, optionally filtered by type or predicate

Time-travel query: see facts as they were at a given point

Validate RDF data against SHACL shapes without writing

Manage persistent SHACL shapes (load, list, get, remove) and inspect the loaded class vocabulary. Loaded shapes auto-validate on writes.

Manage STORED named queries — competency questions a consumer ships with its domain, callable through quipu_ask alongside the compiled-in catalog. Definitions are validated at LOAD (template must parse; every {placeholder} needs a spec; an optional param needs a default) and versioned: re-loading a name closes the prior version rather than overwriting it.

Register a committed named graph before graph-scoped knot writes or labeling. Idempotent: an existing graph retains its original creation timestamp and declared actor. Interned terms are not registration.

Declare lattice labels on an already registered committed graph. Create first with quipu_graph_create. Declarations are versioned; policy tokens describe data, not authorization.

List registered named graphs; optional graph selects one exact registered IRI without materialization enrichment (cannot combine with kind/lifecycle). Includes class, source, lifecycle and labels (freshness/durability/trust/policy/kind). Filter with kind (a dataKind token, e.g. operational | archive) and/or lifecycle (frozen). Also the capability probe for the graph-kinds surface: a store without this tool predates it.

Deep-freeze a named graph: export its FULL history (retracted rows and transactions included) into a read-only archive pack, verify the copy by content hash, delete the local rows, and re-attach the pack so the graph stays addressable at the same IRI. Compose frozen graphs back in with FROM , the urn:quipu:dataset:frozen dataset, or include_kinds:["archive"]. Refuses ROOT, the meta-graph, overlays, attached graphs, and double-freezes.

Thaw a frozen graph: verify its archive pack, detach it, restore the full history into the local store under the same IRI, and reopen the graph for writes. The pack file is kept on disk; the freeze registry row is closed, never deleted.

Manage named datasets — a reusable NAME for an arbitrary set of graphs, so it can be labelled, governed and handed to another agent. FROM <dataset-iri> then means FROM over its members. Datasets overlap freely and are never implicitly active.

Retract ROOT/default-graph facts for an entity: all of them, or narrowed by predicate and/or value. Supplying a graph field is refused; named-graph facts are untouched. Entity + predicate + value retracts exactly ONE (e,a,v) statement — use this to remove a stray edge instead of retracting a whole episode and rebuilding it.

Atomically SET (entity, predicate) to exactly one value in the ROOT/default graph. Supplying a graph field is refused; named-graph facts are untouched. Retracts every current object on that predicate and asserts the new one in a single transaction. The supersede primitive — re-parenting (reports_to A -> B) is one call, with no empty-predicate window and no way to end up with two supervisors by forgetting the retract half. SINGLE-VALUE semantics: replaces ALL current objects; to add without removing, assert via quipu_knot.

Episode-scoped logical retraction: retract all currently-active facts an episode's ingest contributed (activity node, entities, edges, reified statements), via the bitemporal valid_to close path. Logical, not physical — time-travel history is preserved. Entities and other episodes' facts are untouched. Idempotent. Node IDENTITY is protected: by default (on_orphan=preserve) rdfs:label/rdf:type survive for any node that other episodes still reference, so retraction never leaves an unlabelled, untyped ghost. The response always reports identity_orphans.

RETRACT-ONLY repair: retract every currently-live fact whose transaction source equals an exact string. Reaches facts that no snapshot replacement can touch — quipu_knot composes its own tag as snapshot:, so facts written under any other source (a free-form producer string, a hand-run CLI promote) were previously unretractable forever. There is NO turtle input: the transaction cannot carry an assertion, so this cannot write facts attributed to the named producer. The retraction is stamped with its OWN source, repair:, never the source being cleared. PLANS BY DEFAULT: without apply=true it writes nothing and reports what would be retracted, so planned:0 means 'that source owns nothing live'. Applying requires expect= as a confirmation handshake, and the response reports 'remaining' — a fresh read of the post-state, not an echo of the request. RE-KEYING ORDER: retract FIRST, then re-promote canonically; asserting first is skipped as a duplicate and the retraction then removes everything.

Ingest structured knowledge from an agent episode (nodes + edges)

List the effective owner namespace registry; no writes or allocation.

Mint a typed stable entity, resolve a registered reference or verify a local key IRI against its key triples without fetching. Uncertain mint responses must be reconciled, never blindly retried.

Produce a bounded portable share payload, including canonical manifest and member bytes. Read-only; no server-local output path. Pass the exact scope. Internal-only export exemptions are not accepted over this transport.

Stage a portable share with hash, vocabulary and attestation gates. Copy member contents from quipu_share; this is not a server file path. Exact-name merges default off; review before promotion.

Promote a staged share only when existing promotion gates permit it. Does not bypass quarantine or resolution review. With target_graph, promote into that named graph instead of ROOT, replacing only the share's subjects there; with retire_from too, move those subjects out of that source graph in the same transaction. With dry_run, report what the move would assert, replace and retire, and write nothing.

Acquire complete bounded registered named graphs from an expected MAIN store lineage. Unknown graphs, unsupported attachments/pins and overflow refuse.

Acquire qualified MAIN graphs with a fenced attachment census. expected_generation is required with an explicit main tx; provider clocks are never a global transaction.

Stage one immutable numbered snapshot part. Supply exact sha256 hashes and upload identity; replay is idempotent, changed bytes refuse. No file paths.

Start or read back atomic promotion of a staged snapshot upload. pending=true is not completion; poll the same upload_id. Existing validation gates remain authoritative.

Run stored or inline Datalog rules to fixpoint and persist derivations. Omitted graph means ROOT; pass graph to scope premises. Derivations persist in that graph's reserved companion inferred graph, not alongside asserted facts.

Execute SPARQL 1.1 Update through the guarded update endpoint. Use explicit GRAPH clauses for named graphs; absent scope has standard SPARQL default-graph semantics. Actor/source are declared provenance, not authorization.

Read a bounded batch of ROOT's events without committing a consumer cursor. since overrides consumer. types is a comma-separated event-type filter; group is an episode group, not a graph selector. A named graph's events are quipu_graph_events.

Read a bounded batch of ONE registered committed named graph's events (its own log and offsets) without committing a cursor. Same filters as quipu_events.

Durably set a consumer cursor. Lower offsets explicitly rewind; delivery alone never commits.

Durably set a consumer cursor in one registered committed named graph's event log. Lower offsets explicitly rewind.

Read whole transaction change pages. graph scopes an exact graph; use next_tx for the next page. No cursor write.

Manage persistent push subscriptions (create/list/delete). Creates may deliver externally; list is still conservatively write-classified like REST.

Read whether the server enforces direct-workflow guards before using quipu_update. Reports capability only, never configuration or credentials.

Dereference an exact IRI as JSON-LD. IRIs are encoded as query values, including slashes and fragments; expanded includes label expansion.

Read the existing entity-history endpoint for an exact IRI. Its current MAIN-history semantics do not certify composed/named-graph audit completeness.

Read bounded transaction metadata after since; does not change a cursor.

Backfill missing ROOT entity embeddings using the configured provider. May consume external embedding resources and persist vectors.

Backfill a bounded number of named-graph entity embeddings; does not rewrite ROOT entity text.

Fuse ranked search seeds with a SPARQL query. Existing mode-specific validation and query budgets apply.

Read a bounded triple-pattern fragment. page and pageSize select a page; absent terms are wildcards.

Get the reconciliation service manifest or resolve keyed query objects without merging entities.

Annotate text with known entities, read-only. A busy cold cache may return no annotations; that is not an absence proof.

Read server graph and transaction statistics. This describes the serving store, not a client-local database.

Read server health as a positive liveness control; healthy does not prove complete graph coverage.

Read served version, source commit and dirty-build identity through MCP without a REST fallback.

Semantic vector search (default), opt-in SQLite FTS5 keyword search, or configurable lexical/vector hybrid fusion. Keyword mode requires query text and an enabled, backfilled index; it needs no embedding provider. Ranked REST results are diagnostic candidates; native MCP renders admitted context only. Agent context uses context_results when insufficient_context is false under quipu-context/v1.

Combined SPARQL + vector similarity search with predicate pushdown. Accepts a pre-computed embedding or natural-language query. Simple type constraints (e.g. ?s a ) are pushed into the vector index for O(log n) filtered ANN.

Search for entities in the knowledge graph by natural language query. Uses text matching on entity names, labels, and values. Replaces Graphiti's search_nodes.

Search for relationships/edges in the knowledge graph by natural language query. Finds facts where the predicate or value matches the query. Replaces Graphiti's search_memory_facts.

Graphiti-compatible flat episode ingestion. Accepts name, body text, group, and source — converts to Quipu episode and ingests.

Impact analysis: walk downstream from an entity. With remove=true, speculatively retracts the entity first (counterfactual: 'what would break if I removed this?'). The store is never mutated.

Golden paths: compute the provenance cone of a trajectory — which steps did its falsifier-gated verified result depend on? Per-step verdicts are in-cone (load-bearing; pruning needs a human Decision), out-of-cone (mechanically prunable), or cannot-evaluate (no derivation edges recorded — never silently prunable). Refuses trajectories with no steps or no falsifier-gated verification.

Golden paths: backtest a pruned candidate (exemplar trajectory minus omitted steps) over recorded history — which past trajectories with a shared work-item topic would have conformed under gp-grammar/1, and how did their work items close? Distinguishes 0 matches from cannot-evaluate, and refuses a pattern it cannot compile.

Unified knowledge search for Bobbin integration. Combines text and optional vector search, returning results tagged with source='knowledge' and normalized 0-1 scores. When an EmbeddingProvider is attached, the query is auto-embedded for semantic search.

Run a curated, parameterized named query by name instead of hand-writing SPARQL. Call with no 'name' (or name='list') to discover the self-describing catalog of available queries and their parameters (e.g. service_deps, references_to, entity_facts, entities_of_type, labeled_like).

Submit a schema evolution proposal (new shape, class, property, or ontology change). Proposals require explicit acceptance before taking effect.

List schema evolution proposals, optionally filtered by status (pending, accepted, rejected)

Accept a pending schema proposal. For shape proposals, validates the Turtle before writing to the shapes table. A proposal carrying a migration runs it in the same transaction; a refused migration leaves the proposal pending and nothing written. With dry_run=true nothing is accepted: the report lists existing facts the new shapes would refuse, what the migration would change, and whether acceptance would go through. Before accepting, a blast-radius plan is computed and returned as 'plan'; a plan whose risk score exceeds risk_threshold, or that cannot be determined, is refused unless accept_risk=true with a risk_reason (recorded in the decision note).

Reject a pending schema proposal with a reason

Check for existing near-duplicate entities before writing. Uses vector similarity (embedding) and canonical name matching (Jaro-Winkler) to find entities that may be duplicates. Returns candidates with similarity scores and match explanations.

Project the knowledge graph into a render-ready node-link payload in ONE response: nodes (iri, label, rdf:type, degree), edges as [source_index, target_index, predicate] into that node array, and a type census ordered by prevalence. Excludes prov:Activity episodes and rdf/rdfs/prov scaffolding predicates by default so the domain graph is not buried in provenance. Nodes are ranked by degree and capped; the response states what was dropped.

Project the knowledge graph and run a graph algorithm over it: stats (node/edge counts), in_degree (most-referenced entities), pagerank/ppr (global or personalized PageRank from seed entities), components (weakly-connected components), louvain (modularity community detection), or shortest_path. Optionally restrict the projection to a node type or predicate. Read-only by default; louvain with persist:true writes quipu:memberOfCommunity facts (superseding any prior derivation).

Query the knowledge graph for context around a natural-language query: returns relevant entities and their facts, ready to prime an agent. Optionally expand to linked entities.

Generate a live graph report (graphify's GRAPH_REPORT.md equivalent, but queryable): top hubs / 'god-nodes' (by PageRank with in-degree as a secondary signal), surprising connections (low-prior edges that bridge two otherwise-separate Louvain communities — rarer bridges rank first), and auto-suggested questions seeded by those hubs and bridges. Read-only; derived from current graph structure. Communities here are emergent clustering for surfacing, NOT an access boundary.

Read explicit positive/negative support as supported/refuted/both/neither, plus a separate admitted judgment disposition. Current ROOT only; failed/incomplete reads are UNKNOWN, never absence. No action authority or implicit boolean conversion.

Committed-tier evaluation of a governance Policy over the graph of record: evaluates the policy's aegis:claim (a SPARQL ASK, optionally with a $target placeholder) against the committed graph and returns a Verdict — outcome ∈ {satisfied | unsatisfied | unknown} bound to a reproducible evidence_hash. Deterministic and reproducible: any verifier re-running the same ASK over the same committed evidence gets the same verdict (checked, not trusted). Returns the verdict UNSIGNED (signing + persistence is the Phase-0 verifier registry's job).

Verify a signed Verdict against the root of trust AS OF the signature (signing-plane S1): the signature must be valid under a key registered to the verifier at that instant, AND that same registration must authorize the predicate. 'trusted' is that conjunction — the property a consumer should gate on. Pass 'verdict' (the stored verdict's IRI) for a trust decision: quipu then reads when the store recorded the signature, which the signer cannot choose. 'as_of.basis' says which instant was used (recorded | caller-supplied | now). A caller-supplied signed_at/tx is a what-if: 'trusted' is then always false and the answer is in 'would_verify_as_of_supplied_instant'.

Check the Phase-0 verifier registry: may this verifier attest this predicate? The discovery half of the governance gate — lets an agent learn who is authorized before trusting (or requesting) an attestation.

Deterministic, auditable work-item co-occurrence: given a work-item (Bead) IRI, returns the other work-items that share at least one touched code entity via the provenance chain Bead <-implements- GitCommit -modifies-> entity. A graph query over typed provenance edges, not a statistical mine; ordered by overlap strength. Bitemporal: pass valid_at for 'which work co-occurred as of '.

Register an overlay-class named graph bound (bind-once) to a committed parent branch. Overlays are scratch layers over the committed graph: write hypotheses into an overlay, read the composed view, and the committed layer stays untouched.

Write one overlay primitive: assert, retract, or tombstone a triple in an overlay graph. Tombstone masks the parent branch's fact in the composed view without touching the committed layer.

Resolve an overlay's composed view over [overlay > parent-branch-root]: asserted-and-not-tombstoned, nearest wins. Read-only.

Manage OWL ontologies: load (parse + materialize entailments), list, or remove. Loaded ontologies enforce class hierarchy, disjoint-class constraints, and property characteristics (inverse, symmetric, functional).

Walk a fact's derivation chain: a base fact answers with its transaction and source; a reasoner: fact answers with the rule and the premises it currently re-matches; an owl:materialize fact answers with every axiom family that currently re-derives it, premises recursed to base facts. Read-only.