iris-vector-graph 2.15.0__tar.gz → 2.18.0__tar.gz

{iris_vector_graph-2.15.0 → iris_vector_graph-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: iris-vector-graph
-Version: 2.15.0
+Version: 2.18.0
 Summary: Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs
@@ -287,6 +287,52 @@ reference, SHACL shape writing, PROV-O vocabulary mapping, and integration patte
 
 ---
 
+## Revision Ledger (Transaction-Time History)
+
+The structural graph (nodes, labels, properties, relationships, qualifiers) can
+be versioned with an opt-in, immutable revision ledger. A changeset applies
+atomically and produces exactly one revision; a failed operation applies
+nothing. This is **transaction time** (when the ledger recorded a change) and is
+independent of the temporal property graph's **event time** (`ts` on temporal
+edges), which is unchanged and unversioned.
+
+```python
+from iris_vector_graph.ledger import Changeset
+
+genesis = engine.ledger.enable()              # idempotent; captures the existing graph
+head = engine.ledger.head()
+
+cs = Changeset(actor="ingest:etl-42", actor_type="ingest",
+               message="equipment sync",
+               expected_head=head.revision_id,      # optimistic concurrency
+               idempotency_key="etl-42-2026-09-05")  # safe retry
+cs.create_node("pump-7", labels=["Equipment"], properties={"status": "ok"})
+cs.create_node("tank-2")
+r = cs.create_relationship("pump-7", "FEEDS", "tank-2", qualifiers={"weight": "1.0"})
+cs.set_qualifier(r, "capacity", "100")
+result = engine.ledger.commit(cs)              # StaleHeadError if another writer won
+
+engine.ledger.history(limit=20)                # deterministic, pageable, filterable
+engine.ledger.get_revision(result.revision.revision_id).records
+engine.ledger.diff(genesis.revision_id, result.revision.revision_id)
+engine.ledger.reconstruct(genesis.revision_id) # read-only graph as of a revision
+engine.ledger.export_reconstruction(result.revision.revision_id, "at-rev.ndjson")
+engine.ledger.verify()                         # replay from genesis == current tables?
+engine.ledger.verify(adopt=True)               # record any unrecorded (legacy) writes
+```
+
+Existing APIs keep working with a ledger enabled; writes made through them are
+"unrecorded" and are surfaced by `verify()`. `enable(strict=True)` (or
+`set_strict(True)`) rejects non-ledger structural writes with
+`LedgerStrictModeError`; reads, temporal writes, and index maintenance are
+unaffected. Relationships get a stable **statement identity** that survives
+qualifier changes and snapshot restore. Counters are in
+`engine.status().ledger`, the `Graph_KG.ledger_stats` table, and a metrics hook
+(`engine.ledger.register_metrics_hook`, see
+[docs/ledger-prometheus-hook.md](docs/ledger-prometheus-hook.md)).
+
+---
+
 ## Non-USER Namespace Deployment
 
 By default IVG connects to the `USER` namespace. When deploying against a

{iris_vector_graph-2.15.0 → iris_vector_graph-2.18.0}/README.md

@@ -189,6 +189,52 @@ reference, SHACL shape writing, PROV-O vocabulary mapping, and integration patte
 
 ---
 
+## Revision Ledger (Transaction-Time History)
+
+The structural graph (nodes, labels, properties, relationships, qualifiers) can
+be versioned with an opt-in, immutable revision ledger. A changeset applies
+atomically and produces exactly one revision; a failed operation applies
+nothing. This is **transaction time** (when the ledger recorded a change) and is
+independent of the temporal property graph's **event time** (`ts` on temporal
+edges), which is unchanged and unversioned.
+
+```python
+from iris_vector_graph.ledger import Changeset
+
+genesis = engine.ledger.enable()              # idempotent; captures the existing graph
+head = engine.ledger.head()
+
+cs = Changeset(actor="ingest:etl-42", actor_type="ingest",
+               message="equipment sync",
+               expected_head=head.revision_id,      # optimistic concurrency
+               idempotency_key="etl-42-2026-09-05")  # safe retry
+cs.create_node("pump-7", labels=["Equipment"], properties={"status": "ok"})
+cs.create_node("tank-2")
+r = cs.create_relationship("pump-7", "FEEDS", "tank-2", qualifiers={"weight": "1.0"})
+cs.set_qualifier(r, "capacity", "100")
+result = engine.ledger.commit(cs)              # StaleHeadError if another writer won
+
+engine.ledger.history(limit=20)                # deterministic, pageable, filterable
+engine.ledger.get_revision(result.revision.revision_id).records
+engine.ledger.diff(genesis.revision_id, result.revision.revision_id)
+engine.ledger.reconstruct(genesis.revision_id) # read-only graph as of a revision
+engine.ledger.export_reconstruction(result.revision.revision_id, "at-rev.ndjson")
+engine.ledger.verify()                         # replay from genesis == current tables?
+engine.ledger.verify(adopt=True)               # record any unrecorded (legacy) writes
+```
+
+Existing APIs keep working with a ledger enabled; writes made through them are
+"unrecorded" and are surfaced by `verify()`. `enable(strict=True)` (or
+`set_strict(True)`) rejects non-ledger structural writes with
+`LedgerStrictModeError`; reads, temporal writes, and index maintenance are
+unaffected. Relationships get a stable **statement identity** that survives
+qualifier changes and snapshot restore. Counters are in
+`engine.status().ledger`, the `Graph_KG.ledger_stats` table, and a metrics hook
+(`engine.ledger.register_metrics_hook`, see
+[docs/ledger-prometheus-hook.md](docs/ledger-prometheus-hook.md)).
+
+---
+
 ## Non-USER Namespace Deployment
 
 By default IVG connects to the `USER` namespace. When deploying against a

{iris_vector_graph-2.15.0 → iris_vector_graph-2.18.0}/iris_src/src/Graph/KG/Algorithms.cls

@@ -5,10 +5,11 @@ Class Graph.KG.Algorithms Extends %RegisteredObject
 
 ClassMethod WCCJson(maxIter As %Integer = 100) As %String
 {
+	Set pGraph = 0
 	Set nodeCount = 0
 	Set node = ""
 	For {
-		Set node = $Order(^KG("deg", node))
+		Set node = $Order(^KG("deg", pGraph, node))
 		Quit:node=""
 		Set labels(node) = node
 		Set nodeCount = nodeCount + 1
@@ -16,7 +17,7 @@ ClassMethod WCCJson(maxIter As %Integer = 100) As %String
 	// Also include nodes that only appear as targets (no outgoing edges = no "deg" entry)
 	Set node = ""
 	For {
-		Set node = $Order(^KG("in", 0, node))
+		Set node = $Order(^KG("in", pGraph, node))
 		Quit:node=""
 		If '$Data(labels(node)) {
 			Set labels(node) = node
@@ -38,11 +39,11 @@ ClassMethod WCCJson(maxIter As %Integer = 100) As %String
 			// Check outgoing neighbors
 			Set p = ""
 			For {
-				Set p = $Order(^KG("out", 0, node, p))
+				Set p = $Order(^KG("out", pGraph, node, p))
 				Quit:p=""
 				Set o = ""
 				For {
-					Set o = $Order(^KG("out", 0, node, p, o))
+					Set o = $Order(^KG("out", pGraph, node, p, o))
 					Quit:o=""
 					Set nbrLabel = $Get(labels(o), o)
 					If minLabel ]] nbrLabel Set minLabel = nbrLabel
@@ -52,11 +53,11 @@ ClassMethod WCCJson(maxIter As %Integer = 100) As %String
 			// Check incoming neighbors
 			Set p = ""
 			For {
-				Set p = $Order(^KG("in", 0, node, p))
+				Set p = $Order(^KG("in", pGraph, node, p))
 				Quit:p=""
 				Set s = ""
 				For {
-					Set s = $Order(^KG("in", 0, node, p, s))
+					Set s = $Order(^KG("in", pGraph, node, p, s))
 					Quit:s=""
 					Set nbrLabel = $Get(labels(s), s)
 					If minLabel ]] nbrLabel Set minLabel = nbrLabel
@@ -84,17 +85,18 @@ ClassMethod WCCJson(maxIter As %Integer = 100) As %String
 
 ClassMethod CDLPJson(maxIter As %Integer = 10) As %String
 {
+	Set pGraph = 0
 	Set nodeCount = 0
 	Set node = ""
 	For {
-		Set node = $Order(^KG("deg", node))
+		Set node = $Order(^KG("deg", pGraph, node))
 		Quit:node=""
 		Set labels(node) = node
 		Set nodeCount = nodeCount + 1
 	}
 	Set node = ""
 	For {
-		Set node = $Order(^KG("in", 0, node))
+		Set node = $Order(^KG("in", pGraph, node))
 		Quit:node=""
 		If '$Data(labels(node)) {
 			Set labels(node) = node
@@ -116,11 +118,11 @@ ClassMethod CDLPJson(maxIter As %Integer = 10) As %String
 			// Count outgoing neighbor labels
 			Set p = ""
 			For {
-				Set p = $Order(^KG("out", 0, node, p))
+				Set p = $Order(^KG("out", pGraph, node, p))
 				Quit:p=""
 				Set o = ""
 				For {
-					Set o = $Order(^KG("out", 0, node, p, o))
+					Set o = $Order(^KG("out", pGraph, node, p, o))
 					Quit:o=""
 					Set nbrLabel = $Get(labels(o), o)
 					Set counts(nbrLabel) = $Get(counts(nbrLabel), 0) + 1
@@ -130,11 +132,11 @@ ClassMethod CDLPJson(maxIter As %Integer = 10) As %String
 			// Count incoming neighbor labels
 			Set p = ""
 			For {
-				Set p = $Order(^KG("in", 0, node, p))
+				Set p = $Order(^KG("in", pGraph, node, p))
 				Quit:p=""
 				Set s = ""
 				For {
-					Set s = $Order(^KG("in", 0, node, p, s))
+					Set s = $Order(^KG("in", pGraph, node, p, s))
 					Quit:s=""
 					Set nbrLabel = $Get(labels(s), s)
 					Set counts(nbrLabel) = $Get(counts(nbrLabel), 0) + 1

{iris_vector_graph-2.15.0 → iris_vector_graph-2.18.0}/iris_src/src/Graph/KG/Centrality.cls

@@ -8,10 +8,10 @@
 ///   - EigenvectorJson         — power iteration over raw adjacency A (NOT PageRank with α=1)
 ///
 /// Storage (read-only):
-///   ^KG("out", 0, s, p, o)   outbound edges (shard-0)
+///   ^KG("out", pGraph, s, p, o)   outbound edges (shard-0)
 ///   ^KG("in",  0, o, p, s)   inbound edges (shard-0)
-///   ^KG("deg", node)         total out-degree
-///   ^KG("degp", node, pred)  per-predicate out-degree
+///   ^KG("deg", pGraph, node)         total out-degree
+///   ^KG("degp", pGraph, node, pred)  per-predicate out-degree
 ///
 /// Process-private scratch (killed on exit):
 ///   ^||CENT(-score, node)    descending sort buffer (shared across algos)
@@ -37,6 +37,7 @@ Class Graph.KG.Centrality Extends %RegisteredObject [ SqlSchemaName = Graph_KG ]
 /// @returns JSON array: [{"id":"node","score":0.42,"degree":17}, ...] sorted desc by score
 ClassMethod DegreeCentralityJson(direction As %String = "out", predicate As %String = "", topK As %Integer = 10000) As %String
 {
+	Set pGraph = 0
     // Count nodes for normalization
     Set nodeCount = 0
     // Enumerate the full node set: outbound sources (^KG("deg")) UNION
@@ -45,13 +46,13 @@ ClassMethod DegreeCentralityJson(direction As %String = "out", predicate As %Str
     Kill ^||CENTNODES
     Set node = ""
     For {
-        Set node = $Order(^KG("deg", node))
+        Set node = $Order(^KG("deg", pGraph, node))
         Quit:node=""
         Set ^||CENTNODES(node) = ""
     }
     Set node = ""
     For {
-        Set node = $Order(^KG("in", 0, node))
+        Set node = $Order(^KG("in", pGraph, node))
         Quit:node=""
         Set ^||CENTNODES(node) = ""
     }
@@ -77,30 +78,30 @@ ClassMethod DegreeCentralityJson(direction As %String = "out", predicate As %Str
         If predicate = "" {
             // All predicates
             If direction = "out" {
-                Set deg = +$Get(^KG("deg", node))
+                Set deg = +$Get(^KG("deg", pGraph, node))
             } ElseIf direction = "in" {
-                // Walk ^KG("in", 0, node, p, s) and count
+                // Walk ^KG("in", pGraph, node, p, s) and count
                 Set p = ""
                 For {
-                    Set p = $Order(^KG("in", 0, node, p))
+                    Set p = $Order(^KG("in", pGraph, node, p))
                     Quit:p=""
                     Set s = ""
                     For {
-                        Set s = $Order(^KG("in", 0, node, p, s))
+                        Set s = $Order(^KG("in", pGraph, node, p, s))
                         Quit:s=""
                         Set deg = deg + 1
                     }
                 }
             } Else {
                 // both = out + in
-                Set deg = +$Get(^KG("deg", node))
+                Set deg = +$Get(^KG("deg", pGraph, node))
                 Set p = ""
                 For {
-                    Set p = $Order(^KG("in", 0, node, p))
+                    Set p = $Order(^KG("in", pGraph, node, p))
                     Quit:p=""
                     Set s = ""
                     For {
-                        Set s = $Order(^KG("in", 0, node, p, s))
+                        Set s = $Order(^KG("in", pGraph, node, p, s))
                         Quit:s=""
                         Set deg = deg + 1
                     }
@@ -109,20 +110,20 @@ ClassMethod DegreeCentralityJson(direction As %String = "out", predicate As %Str
         } Else {
             // Specific predicate
             If direction = "out" {
-                Set deg = +$Get(^KG("degp", node, predicate))
+                Set deg = +$Get(^KG("degp", pGraph, node, predicate))
             } ElseIf direction = "in" {
-                // Walk ^KG("in", 0, node, predicate, *)
+                // Walk ^KG("in", pGraph, node, predicate, *)
                 Set s = ""
                 For {
-                    Set s = $Order(^KG("in", 0, node, predicate, s))
+                    Set s = $Order(^KG("in", pGraph, node, predicate, s))
                     Quit:s=""
                     Set deg = deg + 1
                 }
             } Else {
-                Set deg = +$Get(^KG("degp", node, predicate))
+                Set deg = +$Get(^KG("degp", pGraph, node, predicate))
                 Set s = ""
                 For {
-                    Set s = $Order(^KG("in", 0, node, predicate, s))
+                    Set s = $Order(^KG("in", pGraph, node, predicate, s))
                     Quit:s=""
                     Set deg = deg + 1
                 }

{iris_vector_graph-2.15.0 → iris_vector_graph-2.18.0}/iris_src/src/Graph/KG/EdgeScan.cls

@@ -1,90 +1,95 @@
 /// Graph.KG.EdgeScan — adjacency-global maintenance + scan procedures.
 ///
 /// ============================================================================
-/// ^KG ADJACENCY LAYOUT OF RECORD (canonical — do not deviate)
+/// ^KG ADJACENCY LAYOUT OF RECORD (spec 214 — named-graph aware)
 /// ============================================================================
-/// The production adjacency layout is SHARD-PREFIXED:
 ///
-///     ^KG("out", 0, s, p, o) = weight     outbound edges
-///     ^KG("in",  0, o, p, s) = weight     inbound edges
-///     ^KG("deg", s)          = out-degree
-///     ^KG("degp", s, p)      = per-predicate out-degree
+///     ^KG("out", graph, s, p, o) = weight
+///     ^KG("in",  graph, o, p, s) = weight
+///     ^KG("deg", graph, s)           = out-degree
+///     ^KG("degp", graph, s, p)       = per-predicate out-degree
 ///
-/// Every live reader scans this layout: MatchEdges (here), Graph.KG.Algorithms,
-/// Graph.KG.Centrality, Graph.KG.Subgraph, and the NKG builders. WriteAdjacency
-/// (below), TraversalBuild.BuildKG, TemporalIndex.InsertEdge, and the (currently
-/// undeployed) Graph.KG.GraphIndex functional index all WRITE this exact form.
+/// graph = "" (empty string) = default graph (FR-003 sentinel).
+/// graph = "umls" etc. = named graph.
+/// Merged-view traversal iterates the full ^KG("out") tree (all graph subscripts).
+/// Graph-filtered traversal uses a fixed graph subscript.
 ///
-/// There is a LEGACY no-shard layout — ^KG("out", s, p, o) — still written by
-/// the bench harness (Graph.KG.BenchSeeder / BenchFormat) and the standalone CSV
-/// Graph.KG.Loader, and read by dead Else-fallback branches in NKGAccelTraversal
-/// / NKGAccelAdjacency. Nothing in the production write/read path uses it.
-/// DO NOT add new readers or writers of the no-shard form. If you need adjacency,
-/// use ^KG("out", 0, ...). See docs/index-maintenance-architecture-review.md.
+/// ^NKG is per-identifier (no graph dimension); InternNode unchanged.
 /// ============================================================================
 Class Graph.KG.EdgeScan Extends %RegisteredObject
 {
 
-ClassMethod MatchEdges(sourceId As %String, predicate As %String, shard As %Integer = 0) As %String [ SqlProc, SqlName = MatchEdges ]
+/// Scan adjacency globals. graph="" returns merged view across all graphs.
+ClassMethod MatchEdges(sourceId As %String, predicate As %String, shard As %Integer = 0, graph = 0) As %String [ SqlProc, SqlName = MatchEdges ]
 {
 	Set results = ##class(%DynamicArray).%New()
 	Set sourceId = $Get(sourceId, "")
 	Set predicate = $Get(predicate, "")
 
-	If sourceId '= "" {
-		If $Length(predicate) > 0 {
-			Set o = ""
-			For {
-				Set o = $Order(^KG("out", 0, sourceId, predicate, o))
-				Quit:o=""
-				Set w = $Get(^KG("out", 0, sourceId, predicate, o), 1.0)
-				Set entry = ##class(%DynamicObject).%New()
-				Do entry.%Set("s", sourceId)
-				Do entry.%Set("p", predicate)
-				Do entry.%Set("o", o)
-				Do entry.%Set("w", +w)
-				Do results.%Push(entry)
-			}
-		} Else {
-			Set p = ""
-			For {
-				Set p = $Order(^KG("out", 0, sourceId, p))
-				Quit:p=""
+	// Build the list of graph subscripts to iterate
+	Kill tGraphs
+	// graph=0 means merged view (all graphs); non-0 = specific named graph
+	If (graph '= 0) && (graph '= "") {
+		Set tGraphs(graph) = ""
+	} Else {
+		Set g = ""
+		For {
+			Set g = $Order(^KG("out", g))
+			Quit:g=""
+			Set tGraphs(g) = ""
+		}
+	}
+
+	Set g = ""
+	For {
+		Set g = $Order(tGraphs(g))
+		Quit:g=""
+		If sourceId '= "" {
+			If $Length(predicate) > 0 {
 				Set o = ""
 				For {
-					Set o = $Order(^KG("out", 0, sourceId, p, o))
+					Set o = $Order(^KG("out", g, sourceId, predicate, o))
 					Quit:o=""
-					Set w = $Get(^KG("out", 0, sourceId, p, o), 1.0)
+					Set w = $Get(^KG("out", g, sourceId, predicate, o), 1.0)
 					Set entry = ##class(%DynamicObject).%New()
-					Do entry.%Set("s", sourceId)
-					Do entry.%Set("p", p)
-					Do entry.%Set("o", o)
-					Do entry.%Set("w", +w)
+					Do entry.%Set("s", sourceId) Do entry.%Set("p", predicate) Do entry.%Set("o", o) Do entry.%Set("w", +w)
 					Do results.%Push(entry)
 				}
+			} Else {
+				Set p = ""
+				For {
+					Set p = $Order(^KG("out", g, sourceId, p))
+					Quit:p=""
+					Set o = ""
+					For {
+						Set o = $Order(^KG("out", g, sourceId, p, o))
+						Quit:o=""
+						Set w = $Get(^KG("out", g, sourceId, p, o), 1.0)
+						Set entry = ##class(%DynamicObject).%New()
+						Do entry.%Set("s", sourceId) Do entry.%Set("p", p) Do entry.%Set("o", o) Do entry.%Set("w", +w)
+						Do results.%Push(entry)
+					}
+				}
 			}
-		}
-	} Else {
-		Set s = ""
-		For {
-			Set s = $Order(^KG("out", 0, s))
-			Quit:s=""
-			Set p = ""
+		} Else {
+			Set s = ""
 			For {
-				Set p = $Order(^KG("out", 0, s, p))
-				Quit:p=""
-				If ($Length(predicate) > 0) && (p '= predicate) Continue
-				Set o = ""
+				Set s = $Order(^KG("out", g, s))
+				Quit:s=""
+				Set p = ""
 				For {
-					Set o = $Order(^KG("out", 0, s, p, o))
-					Quit:o=""
-					Set w = $Get(^KG("out", 0, s, p, o), 1.0)
-					Set entry = ##class(%DynamicObject).%New()
-					Do entry.%Set("s", s)
-					Do entry.%Set("p", p)
-					Do entry.%Set("o", o)
-					Do entry.%Set("w", +w)
-					Do results.%Push(entry)
+					Set p = $Order(^KG("out", g, s, p))
+					Quit:p=""
+					If ($Length(predicate) > 0) && (p '= predicate) Continue
+					Set o = ""
+					For {
+						Set o = $Order(^KG("out", g, s, p, o))
+						Quit:o=""
+						Set w = $Get(^KG("out", g, s, p, o), 1.0)
+						Set entry = ##class(%DynamicObject).%New()
+						Do entry.%Set("s", s) Do entry.%Set("p", p) Do entry.%Set("o", o) Do entry.%Set("w", +w)
+						Do results.%Push(entry)
+					}
 				}
 			}
 		}
@@ -93,12 +98,14 @@ ClassMethod MatchEdges(sourceId As %String, predicate As %String, shard As %Inte
 	Return results.%ToJSON()
 }
 
-ClassMethod WriteAdjacency(s As %String, p As %String, o As %String, w As %String = "1.0")
+/// Write adjacency entries for one edge. graph="" = default graph (spec 214).
+ClassMethod WriteAdjacency(s As %String, p As %String, o As %String, w As %String = "1.0", graph = 0)
 {
-	Set ^KG("out", 0, s, p, o) = +w
-	Set ^KG("in", 0, o, p, s) = +w
-	Set tmp = $Increment(^KG("deg", s))
-	Set tmp = $Increment(^KG("degp", s, p))
+	Set ^KG("out", graph, s, p, o) = +w
+	Set ^KG("in", graph, o, p, s) = +w
+	Set tmp = $Increment(^KG("deg", graph, s))
+	Set tmp = $Increment(^KG("degp", graph, s, p))
+	// ^NKG is per-identifier (no graph dimension); unchanged by spec 214
 	If $Data(^NKG("$meta", "nodeCount")) {
 		Set sIdx = ##class(Graph.KG.GraphIndex).InternNode(s)
 		Set oIdx = ##class(Graph.KG.GraphIndex).InternNode(o)
@@ -114,20 +121,17 @@ ClassMethod WriteAdjacency(s As %String, p As %String, o As %String, w As %Strin
 	}
 }
 
-ClassMethod DeleteAdjacency(s As %String, p As %String, o As %String)
+/// Delete adjacency entries for one edge. graph="" = default graph (spec 214).
+ClassMethod DeleteAdjacency(s As %String, p As %String, o As %String, graph = 0)
 {
-	Kill ^KG("out", 0, s, p, o)
-	Kill ^KG("in", 0, o, p, s)
+	Kill ^KG("out", graph, s, p, o)
+	Kill ^KG("in", graph, o, p, s)
 	If $Data(^NKG("$meta", "nodeCount")) {
 		Do ##class(Graph.KG.GraphIndex).DeleteIndex("", s, p, o, "")
 	}
 }
 
-
 /// Bulk ingest edges via SQL INSERT + persistent ^KG global writes.
-/// Writes to BOTH rdf_edges (SQL, queryable via Cypher) AND ^KG globals (BFS acceleration).
-/// edges_json: JSON array of {"s":s,"p":p,"o":o} objects.
-/// Returns count of edges written.
 ClassMethod BulkIngestEdgesSQL(edgesJson As %String, predicate As %String = "KNOWS") As %Integer
 {
 	Set data = {}.%FromJSON(edgesJson)
@@ -142,14 +146,13 @@ ClassMethod BulkIngestEdgesSQL(edgesJson As %String, predicate As %String = "KNO
 		If s = o { Continue }
 		&sql(INSERT INTO Graph_KG.rdf_edges (s, p, o_id) VALUES (:s, :p, :o))
 		If (SQLCODE '= 0) && (SQLCODE '= -119) { Continue }
-		Do ..WriteAdjacency(s, p, o, "1.0")
+		Do ..WriteAdjacency(s, p, o, "1.0", 0)
 		Set n = n + 1
 	}
 	TCOMMIT
 	Quit n
 }
 
-/// Bulk ingest edges from a JSON file path — streams large datasets without MAXSTRING limit.
 ClassMethod BulkIngestEdgesFile(filePath As %String, predicate As %String = "KNOWS") As %Integer
 {
 	Set stream = ##class(%Stream.FileCharacter).%New()
@@ -161,9 +164,6 @@ ClassMethod BulkIngestEdgesFile(filePath As %String, predicate As %String = "KNO
 	Quit ..BulkIngestEdgesSQL(json, predicate)
 }
 
-/// Bulk ingest nodes + labels + properties via batched SQL.
-/// nodesJson: JSON array of {"id":id, "labels":["L1",...], "props":{"k":"v",...}} objects.
-/// Returns count of nodes written.
 ClassMethod BulkIngestNodesSQL(nodesJson As %String) As %Integer
 {
 	Set data = {}.%FromJSON(nodesJson)
@@ -173,7 +173,7 @@ ClassMethod BulkIngestNodesSQL(nodesJson As %String) As %Integer
 	While iter.%GetNext(.idx, .node) {
 		Set id = node.id
 		If id = "" { Continue }
-		&sql(INSERT INTO Graph_KG.nodes (node_id) VALUES (:id))
+		&sql(INSERT INTO Graph_KG.nodes (node_id, graph_id) VALUES (:id, ''))
 		If (SQLCODE '= 0) && (SQLCODE '= -119) { Continue }
 		If $IsObject(node.labels) {
 			Set liter = node.labels.%GetIterator()
@@ -198,9 +198,7 @@ ClassMethod BulkIngestNodesSQL(nodesJson As %String) As %Integer
 	Quit n
 }
 
-/// Remove ^KG("out"/"in"/"deg") entries for each node ID in the JSON array.
-/// Removes: out-adjacency (node as source), in-adjacency (node as target), degree counter.
-/// Returns count of nodes processed. Dangling in-refs where deleted node was a source are not removed.
+/// Remove ^KG adjacency entries for each node in JSON array (merged view).
 ClassMethod BulkDeleteAdjacency(nodeIdsJSON As %String) As %Integer
 {
 	Set arr = ##class(%DynamicArray).%FromJSON(nodeIdsJSON)
@@ -208,9 +206,21 @@ ClassMethod BulkDeleteAdjacency(nodeIdsJSON As %String) As %Integer
 	Set iter = arr.%GetIterator()
 	While iter.%GetNext(.idx, .nodeId) {
 		If nodeId = "" { Continue }
-		Kill ^KG("out", 0, nodeId)
-		Kill ^KG("in", 0, nodeId)
-		Kill ^KG("deg", nodeId)
+		// Kill all graph subscripts for this node as source
+		Set g = ""
+		For {
+			Set g = $Order(^KG("out", g))
+			Quit:g=""
+			Kill ^KG("out", g, nodeId)
+			Kill ^KG("deg", g, nodeId)
+		}
+		// Kill all graph subscripts for this node as target
+		Set g = ""
+		For {
+			Set g = $Order(^KG("in", g))
+			Quit:g=""
+			Kill ^KG("in", g, nodeId)
+		}
 		Set count = count + 1
 	}
 	Quit count