iris-vector-graph 1.63.2__tar.gz → 1.63.4__tar.gz

{iris_vector_graph-1.63.2 → iris_vector_graph-1.63.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.63.2
+Version: 1.63.4
 Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
 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
@@ -407,6 +407,43 @@ Returns `[{"s": str, "p": str, "o_id": str, "score": float}, ...]` sorted descen
 
 ---
 
+## Engine Status
+
+Call `engine.status()` at any time to get a structured snapshot of all components. This is the canonical answer to "why is query X returning nothing?"
+
+```python
+s = engine.status()
+print(s.report())
+
+# Readiness gates — use before running query types
+s.ready_for_bfs           # var-length / undirected / shortestPath — needs ^KG + edges
+s.ready_for_vector_search # needs node embeddings
+s.ready_for_edge_search   # needs edge embeddings
+s.ready_for_full_text     # needs BM25 index
+
+# Example: rebuild ^KG if stale
+if not s.ready_for_bfs and s.tables.edges > 0:
+    engine.build_graph_globals()  # calls BuildKG()
+```
+
+Sample output:
+```
+IVG Engine Status
+══════════════════════════════════════════
+SQL Tables  (probe: 23ms)
+  nodes              10,000
+  edges              50,000
+  ...
+Adjacency Globals
+  ✓ ^KG   (50,000 source nodes indexed)
+  ✗ ^NKG  (Arno integer index)
+...
+```
+
+`status()` is explicit-call only — never run automatically at init or before queries. Cost ~50ms.
+
+---
+
 ## PLAID Multi-Vector Search
 
 ```python
@@ -655,6 +692,17 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.63.4 (2026-04-26)
+- chore: merge 080-engine-status to main; NKGAccel.cls added to iris_src from arno upstream
+
+
+### v1.63.3 (2026-04-26)
+- feat: `engine.status() -> EngineStatus` — structured runtime snapshot: SQL row counts, `^KG`/`^NKG` population, ObjectScript classes, Arno capabilities, HNSW/IVF/BM25/PLAID index inventory. Readiness properties: `ready_for_bfs`, `ready_for_vector_search`, `ready_for_edge_search`, `ready_for_full_text`. Detects `^KG`/`rdf_edges` predicate mismatch (stale ^KG from different data snapshot). (spec 080)
+- fix: `BuildKG()` `Traversal.cls` SQL cursors now use fully-qualified `Graph_KG.rdf_edges`, `Graph_KG.rdf_labels`, `Graph_KG.rdf_props` — fixes predicate mismatch when IRIS namespace default SQL schema is not `Graph_KG` (e.g. MINDWALK namespace with `SQLUser` default)
+- fix: `kg_IVFMeta`, `kg_BM25Meta`, `kg_PlaidMeta` added to security allowlist
+- `EngineStatus` exported from top-level `iris_vector_graph`
+
+
 ### v1.63.2 (2026-04-25)
 - fix: `MATCH (a)-[r*1..N]-(b)` undirected BFS now traverses `^KG("in",...)` for inbound edges (was outbound-only)
 - fix: `MATCH (a)<-[r*1..N]-(b)` inbound-only BFS now works  

{iris_vector_graph-1.63.2 → iris_vector_graph-1.63.4}/README.md

@@ -335,6 +335,43 @@ Returns `[{"s": str, "p": str, "o_id": str, "score": float}, ...]` sorted descen
 
 ---
 
+## Engine Status
+
+Call `engine.status()` at any time to get a structured snapshot of all components. This is the canonical answer to "why is query X returning nothing?"
+
+```python
+s = engine.status()
+print(s.report())
+
+# Readiness gates — use before running query types
+s.ready_for_bfs           # var-length / undirected / shortestPath — needs ^KG + edges
+s.ready_for_vector_search # needs node embeddings
+s.ready_for_edge_search   # needs edge embeddings
+s.ready_for_full_text     # needs BM25 index
+
+# Example: rebuild ^KG if stale
+if not s.ready_for_bfs and s.tables.edges > 0:
+    engine.build_graph_globals()  # calls BuildKG()
+```
+
+Sample output:
+```
+IVG Engine Status
+══════════════════════════════════════════
+SQL Tables  (probe: 23ms)
+  nodes              10,000
+  edges              50,000
+  ...
+Adjacency Globals
+  ✓ ^KG   (50,000 source nodes indexed)
+  ✗ ^NKG  (Arno integer index)
+...
+```
+
+`status()` is explicit-call only — never run automatically at init or before queries. Cost ~50ms.
+
+---
+
 ## PLAID Multi-Vector Search
 
 ```python
@@ -583,6 +620,17 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.63.4 (2026-04-26)
+- chore: merge 080-engine-status to main; NKGAccel.cls added to iris_src from arno upstream
+
+
+### v1.63.3 (2026-04-26)
+- feat: `engine.status() -> EngineStatus` — structured runtime snapshot: SQL row counts, `^KG`/`^NKG` population, ObjectScript classes, Arno capabilities, HNSW/IVF/BM25/PLAID index inventory. Readiness properties: `ready_for_bfs`, `ready_for_vector_search`, `ready_for_edge_search`, `ready_for_full_text`. Detects `^KG`/`rdf_edges` predicate mismatch (stale ^KG from different data snapshot). (spec 080)
+- fix: `BuildKG()` `Traversal.cls` SQL cursors now use fully-qualified `Graph_KG.rdf_edges`, `Graph_KG.rdf_labels`, `Graph_KG.rdf_props` — fixes predicate mismatch when IRIS namespace default SQL schema is not `Graph_KG` (e.g. MINDWALK namespace with `SQLUser` default)
+- fix: `kg_IVFMeta`, `kg_BM25Meta`, `kg_PlaidMeta` added to security allowlist
+- `EngineStatus` exported from top-level `iris_vector_graph`
+
+
 ### v1.63.2 (2026-04-25)
 - fix: `MATCH (a)-[r*1..N]-(b)` undirected BFS now traverses `^KG("in",...)` for inbound edges (was outbound-only)
 - fix: `MATCH (a)<-[r*1..N]-(b)` inbound-only BFS now works  

iris_vector_graph-1.63.4/iris_src/src/Graph/KG/NKGAccel.cls

@@ -0,0 +1,560 @@
+/// Graph.KG.NKGAccel — NICHE Knowledge Graph accelerated analytics.
+/// Seed-local algorithms run in ObjectScript at $ORDER speed.
+/// Full-graph algorithms export adjacency for Rust consumption.
+///
+/// Auto-detects ^NKG (integer-encoded) vs ^KG (string-subscripted).
+Class Graph.KG.NKGAccel Extends %RegisteredObject
+{
+
+/// Detect whether ^NKG is available. Cache per-process.
+ClassMethod UseNKG() As %Boolean
+{
+    If $Data(^||NKGAccel("useNKG")) Return ^||NKGAccel("useNKG")
+    Set use = ($Data(^NKG("$meta")) > 0)
+    Set ^||NKGAccel("useNKG") = use
+    Return use
+}
+
+/// Clear cached detection (call after BuildKG or schema change)
+ClassMethod ResetCache()
+{
+    Kill ^||NKGAccel
+}
+
+/// Load arno callout library and register all function IDs for this process.
+/// Call once at startup: Do ##class(Graph.KG.NKGAccel).Load("/path/to/libarno_callout.so")
+/// Returns 1 on success, 0 if library not found or load failed.
+/// Safe to call multiple times — no-ops if already loaded in this process.
+ClassMethod Load(libPath As %String = "/usr/irissys/mgr/libarno_callout.so") As %Boolean
+{
+    If $Data(^||NKGAccel("dllid")) Return 1
+    Set dllid = $ZF(-4, 1, libPath)
+    If dllid = 0 Return 0
+    Set ^||NKGAccel("dllid") = dllid
+    Set ^||NKGAccel("libPath") = libPath
+    Set ^||NKGAccel("bfs_fn") = $ZF(-4, 3, dllid, "kg_bfs_global")
+    Return 1
+}
+
+/// Returns 1 if arno is loaded and bfs function is available in this process.
+ClassMethod IsLoaded() As %Boolean
+{
+    If '$Data(^||NKGAccel("dllid")) Return 0
+    Return (^||NKGAccel("bfs_fn") > 0)
+}
+
+// ============================================================
+// T015: ExportAdjacency — full graph for Rust consumption
+// ============================================================
+
+/// Export full graph adjacency as integer-indexed lines.
+/// Format: srcIdx:dstIdx1,dstIdx2,...\n
+/// Returns string directly if < 3MB, otherwise chunks to ^||adj.
+ClassMethod ExportAdjacency() As %String
+{
+    If ..UseNKG() Return ..ExportAdjacencyNKG()
+    Return ..ExportAdjacencyKG()
+}
+
+/// Export from ^NKG (integer subscripts — zero string overhead)
+ClassMethod ExportAdjacencyNKG() As %String [ Private ]
+{
+    Set result = "", chunk = "", chunkNum = 0
+    Set src = ""
+    For {
+        Set src = $Order(^NKG(-3, src))
+        Quit:src=""
+        Set nbrs = "", pred = ""
+        For {
+            Set pred = $Order(^NKG(-1, src, pred))
+            Quit:pred=""
+            Set dst = ""
+            For {
+                Set dst = $Order(^NKG(-1, src, pred, dst))
+                Quit:dst=""
+                Set:nbrs'="" nbrs = nbrs _ ","
+                Set nbrs = nbrs _ dst
+            }
+        }
+        Set line = src _ ":" _ nbrs _ $Char(10)
+        If $Length(result) + $Length(line) > 3000000 {
+            // Switch to chunked mode
+            If chunkNum = 0 {
+                Set chunkNum = 1
+                Set ^||adj(1) = result
+                Set result = ""
+            }
+            If $Length(chunk) + $Length(line) > 32000 {
+                Set chunkNum = chunkNum + 1
+                Set ^||adj(chunkNum) = chunk
+                Set chunk = ""
+            }
+            Set chunk = chunk _ line
+        } Else {
+            Set result = result _ line
+        }
+    }
+    If chunkNum > 0 {
+        If chunk '= "" { Set chunkNum = chunkNum + 1, ^||adj(chunkNum) = chunk }
+        Set ^||adj = chunkNum
+        Return "CHUNKED:" _ chunkNum
+    }
+    Return result
+}
+
+/// Export from ^KG (string subscripts — builds node index on the fly)
+ClassMethod ExportAdjacencyKG() As %String [ Private ]
+{
+    // Pass 1: assign integer indices to all nodes
+    Kill ^||nodeIdx
+    Set n = 0, node = ""
+    For {
+        Set node = $Order(^KG("deg", node))
+        Quit:node=""
+        Set ^||nodeIdx(node) = n
+        Set ^||nodeMap(n) = node
+        Set n = n + 1
+    }
+    // Also pick up nodes only in "in" (no outgoing edges)
+    Set node = ""
+    For {
+        Set node = $Order(^KG("in", node))
+        Quit:node=""
+        If '$Data(^||nodeIdx(node)) {
+            Set ^||nodeIdx(node) = n
+            Set ^||nodeMap(n) = node
+            Set n = n + 1
+        }
+    }
+
+    // Pass 2: build adjacency
+    Set result = "", chunk = "", chunkNum = 0
+    Set src = ""
+    For {
+        Set src = $Order(^KG("out", src))
+        Quit:src=""
+        Set sIdx = $Get(^||nodeIdx(src))
+        If sIdx = "" Continue
+        Set nbrs = "", pred = ""
+        For {
+            Set pred = $Order(^KG("out", src, pred))
+            Quit:pred=""
+            Set dst = ""
+            For {
+                Set dst = $Order(^KG("out", src, pred, dst))
+                Quit:dst=""
+                Set dIdx = $Get(^||nodeIdx(dst))
+                If dIdx = "" Continue
+                Set:nbrs'="" nbrs = nbrs _ ","
+                Set nbrs = nbrs _ dIdx
+            }
+        }
+        Set line = sIdx _ ":" _ nbrs _ $Char(10)
+        If $Length(result) + $Length(line) > 3000000 {
+            If chunkNum = 0 {
+                Set chunkNum = 1
+                Set ^||adj(1) = result
+                Set result = ""
+            }
+            If $Length(chunk) + $Length(line) > 32000 {
+                Set chunkNum = chunkNum + 1
+                Set ^||adj(chunkNum) = chunk
+                Set chunk = ""
+            }
+            Set chunk = chunk _ line
+        } Else {
+            Set result = result _ line
+        }
+    }
+    If chunkNum > 0 {
+        If chunk '= "" { Set chunkNum = chunkNum + 1, ^||adj(chunkNum) = chunk }
+        Set ^||adj = chunkNum
+        Return "CHUNKED:" _ chunkNum _ "|NODEMAP"
+    }
+    // Append node map header so Rust can resolve indices to strings
+    Set header = "NODEMAP:" _ n _ $Char(10)
+    For i = 0:1:n-1 { Set header = header _ i _ "=" _ ^||nodeMap(i) _ $Char(10) }
+    Return header _ "---" _ $Char(10) _ result
+}
+
+// ============================================================
+// T019: KHopNeighbors — seed-local BFS at $ORDER speed
+// ============================================================
+
+/// k-hop BFS from a seed node. Returns JSON with visited nodes and distances.
+/// Runs entirely in ObjectScript — no Rust, no graph serialization.
+/// Cost: ~0.5ms for 2-hop fanout-16 regardless of graph size.
+ClassMethod KHopNeighbors(seedId As %String, k As %Integer = 2, maxNodes As %Integer = 1000) As %String
+{
+    Set useNKG = ..UseNKG()
+    If useNKG {
+        Set seedIdx = $Get(^NKG("$NI", seedId))
+        If seedIdx = "" Return "{""error"":""node not found"",""node"":"""_seedId_"""}"
+    }
+
+    Kill ^||visited, ^||frontier, ^||nextFrontier
+    If useNKG {
+        Set ^||visited(seedIdx) = 0
+        Set ^||frontier(seedIdx) = ""
+    } Else {
+        Set ^||visited(seedId) = 0
+        Set ^||frontier(seedId) = ""
+    }
+    Set totalNodes = 1
+
+    For hop = 1:1:k {
+        Kill ^||nextFrontier
+        Set node = ""
+        For {
+            Set node = $Order(^||frontier(node))
+            Quit:node=""
+            If useNKG {
+                Set pred = ""
+                For {
+                    Set pred = $Order(^NKG(-1, node, pred))
+                    Quit:pred=""
+                    Set dst = ""
+                    For {
+                        Set dst = $Order(^NKG(-1, node, pred, dst))
+                        Quit:dst=""
+                        If '$Data(^||visited(dst)) {
+                            Set ^||visited(dst) = hop
+                            Set ^||nextFrontier(dst) = ""
+                            Set totalNodes = totalNodes + 1
+                            If totalNodes >= maxNodes Goto KHDone
+                        }
+                    }
+                }
+            } Else {
+                Set pred = ""
+                For {
+                    Set pred = $Order(^KG("out", node, pred))
+                    Quit:pred=""
+                    Set dst = ""
+                    For {
+                        Set dst = $Order(^KG("out", node, pred, dst))
+                        Quit:dst=""
+                        If '$Data(^||visited(dst)) {
+                            Set ^||visited(dst) = hop
+                            Set ^||nextFrontier(dst) = ""
+                            Set totalNodes = totalNodes + 1
+                            If totalNodes >= maxNodes Goto KHDone
+                        }
+                    }
+                }
+            }
+        }
+        Kill ^||frontier
+        Merge ^||frontier = ^||nextFrontier
+    }
+
+KHDone
+    // Serialize result
+    Set result = "{""seed"":"""_seedId_""",""hops"":"_k_",""totalNodes"":"_totalNodes_",""nodes"":["
+    Set node = "", first = 1
+    For {
+        Set node = $Order(^||visited(node), 1, dist)
+        Quit:node=""
+        Set:'first result = result _ ","
+        Set first = 0
+        If useNKG {
+            Set nodeStr = $Get(^NKG("$ND", node), node)
+        } Else {
+            Set nodeStr = node
+        }
+        Set result = result _ "{""id"":"""_nodeStr_""",""dist"":"_dist_"}"
+    }
+    Set result = result _ "]}"
+    Return result
+}
+
+// ============================================================
+// T020: PPRNative — Personalized PageRank via power iteration
+// ============================================================
+
+/// Personalized PageRank from seed node(s). Runs in ObjectScript.
+/// Returns top-K nodes with scores as JSON.
+ClassMethod PPRNative(seedId As %String, alpha As %Double = 0.85, maxIter As %Integer = 20, topK As %Integer = 20) As %String
+{
+    Set useNKG = ..UseNKG()
+
+    // Initialize: collect seed's local neighborhood (2-hop)
+    // and run PPR only on the subgraph
+    Set khJson = ..KHopNeighbors(seedId, 2, 5000)
+    Set kh = ##class(%DynamicObject).%FromJSON(khJson)
+    If kh.%IsDefined("error") Return khJson
+
+    // Build local adjacency from the visited nodes
+    Kill ^||pprAdj, ^||pprScore, ^||pprNext
+    Set nodes = kh.nodes
+    Set n = nodes.%Size()
+
+    // Index the local nodes
+    Kill ^||localIdx
+    For i = 0:1:n-1 {
+        Set nodeId = nodes.%Get(i).id
+        Set ^||localIdx(nodeId) = i
+    }
+
+    // Build local adjacency
+    For i = 0:1:n-1 {
+        Set nodeId = nodes.%Get(i).id
+        Set deg = 0
+        If useNKG {
+            Set nkgIdx = $Get(^NKG("$NI", nodeId), "")
+            If nkgIdx '= "" {
+                Set pred = ""
+                For {
+                    Set pred = $Order(^NKG(-1, nkgIdx, pred))
+                    Quit:pred=""
+                    Set dst = ""
+                    For {
+                        Set dst = $Order(^NKG(-1, nkgIdx, pred, dst))
+                        Quit:dst=""
+                        Set dstStr = $Get(^NKG("$ND", dst), "")
+                        If $Data(^||localIdx(dstStr)) {
+                            Set ^||pprAdj(i, deg) = ^||localIdx(dstStr)
+                            Set deg = deg + 1
+                        }
+                    }
+                }
+            }
+        } Else {
+            Set pred = ""
+            For {
+                Set pred = $Order(^KG("out", nodeId, pred))
+                Quit:pred=""
+                Set dst = ""
+                For {
+                    Set dst = $Order(^KG("out", nodeId, pred, dst))
+                    Quit:dst=""
+                    If $Data(^||localIdx(dst)) {
+                        Set ^||pprAdj(i, deg) = ^||localIdx(dst)
+                        Set deg = deg + 1
+                    }
+                }
+            }
+        }
+        Set ^||pprAdj(i) = deg
+    }
+
+    // Find seed index
+    Set seedLocalIdx = $Get(^||localIdx(seedId), 0)
+
+    // Initialize scores: teleport vector = 1 for seed, 0 for others
+    For i = 0:1:n-1 { Set ^||pprScore(i) = 0 }
+    Set ^||pprScore(seedLocalIdx) = 1
+
+    // Power iteration
+    For iter = 1:1:maxIter {
+        For i = 0:1:n-1 { Set ^||pprNext(i) = 0 }
+        For i = 0:1:n-1 {
+            Set deg = $Get(^||pprAdj(i), 0)
+            If deg = 0 Continue
+            Set contrib = ^||pprScore(i) / deg
+            For j = 0:1:deg-1 {
+                Set nbr = ^||pprAdj(i, j)
+                Set ^||pprNext(nbr) = ^||pprNext(nbr) + (alpha * contrib)
+            }
+        }
+        // Add teleport
+        For i = 0:1:n-1 {
+            Set ^||pprNext(i) = ^||pprNext(i) + ((1 - alpha) * $Select(i=seedLocalIdx:1, 1:0))
+        }
+        // Swap
+        For i = 0:1:n-1 { Set ^||pprScore(i) = ^||pprNext(i) }
+    }
+
+    // Collect top-K by score (simple selection)
+    Kill ^||ranked
+    For i = 0:1:n-1 {
+        Set score = ^||pprScore(i)
+        Set ^||ranked(-score, i) = ""
+    }
+
+    Set result = "{""seed"":"""_seedId_""",""alpha"":"_alpha_",""iterations"":"_maxIter_",""scores"":["
+    Set first = 1, count = 0
+    Set sk = ""
+    For {
+        Set sk = $Order(^||ranked(sk))
+        Quit:sk=""
+        Set idx = ""
+        For {
+            Set idx = $Order(^||ranked(sk, idx))
+            Quit:idx=""
+            Set nodeId = nodes.%Get(idx).id
+            Set score = -sk
+            Set:'first result = result _ ","
+            Set first = 0
+            Set result = result _ "{""id"":"""_nodeId_""",""score"":"_$FNumber(score,"",6)_"}"
+            Set count = count + 1
+            If count >= topK Goto PPRDone
+        }
+    }
+
+PPRDone
+    Set result = result _ "]}"
+    Return result
+}
+
+// ============================================================
+// Wrappers that replace CacheGraphJson path for seed-local
+// ============================================================
+
+/// K-hop neighborhood — pure ObjectScript, no Rust needed
+ClassMethod KHopJson(seedId As %String, k As %Integer = 2, maxNodes As %Integer = 1000) As %String
+{
+    Return ..KHopNeighbors(seedId, k, maxNodes)
+}
+
+/// Personalized PageRank — pure ObjectScript on local subgraph
+ClassMethod PPRJson(seedId As %String, alpha As %Double = 0.85, maxIter As %Integer = 20) As %String
+{
+    Return ..PPRNative(seedId, alpha, maxIter)
+}
+
+/// Random walk — pure ObjectScript
+ClassMethod RandomWalkJson(seedId As %String, walkLength As %Integer = 20, numWalks As %Integer = 10) As %String
+{
+    Set useNKG = ..UseNKG()
+    Set result = "["
+    For w = 1:1:numWalks {
+        Set:'(w=1) result = result _ ","
+        Set result = result _ "["
+        Set current = seedId
+        If useNKG { Set currentIdx = $Get(^NKG("$NI", seedId), "") }
+        Set result = result _ """" _ seedId _ """"
+        For step = 1:1:walkLength {
+            // Collect neighbors
+            Kill ^||walkNbrs
+            Set nbrCount = 0
+            If useNKG && (currentIdx '= "") {
+                Set pred = "" For { Set pred=$Order(^NKG(-1,currentIdx,pred)) Quit:pred=""  Set dst="" For { Set dst=$Order(^NKG(-1,currentIdx,pred,dst)) Quit:dst=""  Set nbrCount=nbrCount+1, ^||walkNbrs(nbrCount)=dst } }
+            } Else {
+                Set pred="" For { Set pred=$Order(^KG("out",current,pred)) Quit:pred=""  Set dst="" For { Set dst=$Order(^KG("out",current,pred,dst)) Quit:dst=""  Set nbrCount=nbrCount+1, ^||walkNbrs(nbrCount)=dst } }
+            }
+            If nbrCount = 0 Quit
+            // Pick random neighbor
+            Set pick = $Random(nbrCount) + 1
+            If useNKG {
+                Set currentIdx = ^||walkNbrs(pick)
+                Set current = $Get(^NKG("$ND", currentIdx), currentIdx)
+            } Else {
+                Set current = ^||walkNbrs(pick)
+            }
+            Set result = result _ ",""" _ current _ """"
+        }
+        Set result = result _ "]"
+    }
+    Set result = result _ "]"
+    Return result
+}
+
+ClassMethod BFSJson(seed As %String, predicatesJson As %String = "[]", maxHops As %Integer = 3, maxResults As %Integer = 0) As %String
+{
+    Set dllPath = $Get(^||NKGAccel("libPath"), "/usr/irissys/mgr/libarno_callout.so")
+    If '$Data(^||NKGAccel("bfs_fn")) {
+        Set dllid = $ZF(-4, 1, dllPath)
+        If dllid = 0 {
+            Return ##class(Graph.KG.Traversal).BFSFastJson(seed, predicatesJson, maxHops, "")
+        }
+        Set ^||NKGAccel("dllid") = dllid
+        Set ^||NKGAccel("bfs_fn") = $ZF(-4, 3, dllid, "kg_bfs_global")
+    }
+    Set dllid = ^||NKGAccel("dllid")
+    Set fnid = ^||NKGAccel("bfs_fn")
+    If fnid = 0 {
+        Return ##class(Graph.KG.Traversal).BFSFastJson(seed, predicatesJson, maxHops, "")
+    }
+    Set adjStr = ..ExportAdjacencyWithPreds()
+    If $Extract(adjStr, 1, 8) = "CHUNKED:" {
+        Set nChunks = $Piece(adjStr, ":", 2)
+        Set adjStr = ""
+        For i = 1:1:nChunks {
+            Set adjStr = adjStr _ ^||adjWP(i)
+            If $Length(adjStr) > 3500000 {
+                Kill ^||adjWP
+                Return ##class(Graph.KG.Traversal).BFSFastJson(seed, predicatesJson, maxHops, "")
+            }
+        }
+        Kill ^||adjWP
+    }
+    If $Length(adjStr) = 0 {
+        Return ##class(Graph.KG.Traversal).BFSFastJson(seed, predicatesJson, maxHops, "")
+    }
+    Return $ZF(-5, dllid, fnid, adjStr, seed, predicatesJson, maxHops, maxResults)
+}
+
+ClassMethod ExportAdjacencyWithPreds() As %String [ Private ]
+{
+    Set result = "", chunk = "", chunkNum = 0
+    Set src = ""
+    For {
+        Set src = $Order(^NKG(-1, src))
+        Quit:src=""
+        Set srcStr = $Get(^NKG("$ND", src), src)
+        Set pred = ""
+        For {
+            Set pred = $Order(^NKG(-1, src, pred))
+            Quit:pred=""
+            Set predStr = $Get(^NKG("$LS", -pred - 1), pred)
+            Set dst = ""
+            For {
+                Set dst = $Order(^NKG(-1, src, pred, dst))
+                Quit:dst=""
+                Set dstStr = $Get(^NKG("$ND", dst), dst)
+                Set line = srcStr _ $Char(31) _ predStr _ $Char(31) _ dstStr _ $Char(10)
+                If $Length(result) + $Length(line) > 3000000 {
+                    If chunkNum = 0 {
+                        Set chunkNum = 1
+                        Set ^||adjWP(1) = result
+                        Set result = ""
+                    }
+                    If $Length(chunk) + $Length(line) > 32000 {
+                        Set chunkNum = chunkNum + 1
+                        Set ^||adjWP(chunkNum) = chunk
+                        Set chunk = ""
+                    }
+                    Set chunk = chunk _ line
+                } Else {
+                    Set result = result _ line
+                }
+            }
+        }
+    }
+    If chunkNum > 0 {
+        If chunk '= "" { Set chunkNum = chunkNum + 1, ^||adjWP(chunkNum) = chunk }
+        Set ^||adjWP = chunkNum
+        Return "CHUNKED:" _ chunkNum
+    }
+    Return result
+}
+
+ClassMethod Capabilities() As %String
+{
+    Set cap = {}
+    Do cap.%Set("version", "0.1.0")
+    Do cap.%Set("nkg_accel", 1, "boolean")
+    Do cap.%Set("nkg_data", ..UseNKG(), "boolean")
+    Do cap.%Set("global_set", ##class(%Dictionary.ClassDefinition).%ExistsId("User.GlobalSet"), "boolean")
+    Do cap.%Set("vec_index", ##class(%Dictionary.ClassDefinition).%ExistsId("Graph.KG.VecIndex"), "boolean")
+    Set hasRust = 0
+    Try {
+        If ##class(Graph.KG.ArnoAccel).IsAvailable() Set hasRust = 1
+    } Catch {}
+    Do cap.%Set("rust_callout", hasRust, "boolean")
+    Set algos = ["khop", "ppr", "random_walk", "export_adjacency", "bfs"]
+    Do cap.%Set("algorithms", algos)
+    Set rustAlgos = []
+    If hasRust {
+        Do rustAlgos.%Push("pagerank")
+        Do rustAlgos.%Push("wcc")
+        Do rustAlgos.%Push("cdlp")
+        Do rustAlgos.%Push("bfs")
+    }
+    Do cap.%Set("rust_algorithms", rustAlgos)
+    Do cap.%Set("bfs", 1, "boolean")
+    Return cap.%ToJSON()
+}
+
+}