Skip to content

BrainAPI is a knowledge graph–powered AI memory layer that transforms unstructured data into structured knowledge, enabling intelligent search, recommendations, and contextual memory for AI agents and applications.

fix(networkx): implement missing _event_path_records helper for event-centric retrieval

Cursor Agentd17b2cc4fe90
diff --git a/src/lib/postgresql/networkx_client.py b/src/lib/postgresql/networkx_client.py
index 55cabb9..addfb6d 100644
--- a/src/lib/postgresql/networkx_client.py
+++ b/src/lib/postgresql/networkx_client.py
@@ -947,6 +947,101 @@ class NetworkXGraphClient(GraphClient):
return neighbors
+ def _node_from_brain(self, brain, uuid: str) -> Node:
+ data = brain.node_data(uuid) if uuid in brain.graph else {}
+ node_kwargs: Dict[str, Any] = {
+ "uuid": uuid,
+ "name": data.get("name", "") or "",
+ "labels": data.get("labels", []) or [],
+ "description": data.get("description", "") or "",
+ "properties": always_dict(data),
+ "polarity": data.get("polarity", "neutral") or "neutral",
+ "metadata": always_dict(data.get("metadata", {})),
+ "happened_at": data.get("happened_at", "") or "",
+ "observations": data.get("observations", []) or [],
+ }
+ last_updated = data.get("last_updated")
+ if last_updated:
+ node_kwargs["last_updated"] = last_updated
+ return Node(**node_kwargs)
+
+
+ def _predicate_from_edge(self, edge_data: dict, direction: str) -> Predicate:
+ edge_data = always_dict(edge_data)
+ predicate_kwargs: Dict[str, Any] = {
+ "uuid": edge_data.get("uuid", "") or "",
+ "name": edge_data.get("rel_type", "") or edge_data.get("name", "") or "",
+ "description": edge_data.get("description", "") or "",
+ "direction": direction,
+ "properties": always_dict(edge_data),
+ "flow_key": edge_data.get("flow_key", "") or "",
+ "observations": edge_data.get("observations", []) or [],
+ "amount": edge_data.get("amount"),
+ }
+ last_updated = edge_data.get("last_updated")
+ if last_updated:
+ predicate_kwargs["last_updated"] = last_updated
+ return Predicate(**predicate_kwargs)
+
+
+ def _incident_edges(
+ self, brain, node_uuid: str
+ ) -> List[Tuple[str, str, dict, str]]:
+ if node_uuid not in brain.graph:
+ return []
+ edges: List[Tuple[str, str, dict, str]] = []
+ for _, neighbor, key, data in brain.graph.out_edges(
+ node_uuid, keys=True, data=True
+ ):
+ edges.append((neighbor, key, dict(data), "out"))
+ for neighbor, _, key, data in brain.graph.in_edges(
+ node_uuid, keys=True, data=True
+ ):
+ edges.append((neighbor, key, dict(data), "in"))
+ return edges
+
+
+ def _event_path_records(
+ self,
+ brain,
+ node_uuids: list[str],
+ predicate_uuid: Optional[str] = None,
+ flow_key: Optional[str] = None,
+ ):
+ for n_uuid in node_uuids:
+ if n_uuid not in brain.graph:
+ continue
+ for m_uuid, r1_key, r1_data, r1_direction in self._incident_edges(
+ brain, n_uuid
+ ):
+ if (
+ predicate_uuid is not None
+ and (r1_data.get("uuid") or r1_key) != predicate_uuid
+ ):
+ continue
+ required_flow_key = (
+ flow_key if flow_key is not None else r1_data.get("flow_key")
+ )
+ if not required_flow_key:
+ continue
+ for b_uuid, r2_key, r2_data, r2_direction in self._incident_edges(
+ brain, m_uuid
+ ):
+ if r2_key == r1_key:
+ continue
+ if r2_data.get("flow_key") != required_flow_key:
+ continue
+ yield (
+ n_uuid,
+ m_uuid,
+ b_uuid,
+ r1_data,
+ r2_data,
+ r1_direction,
+ r2_direction,
+ )
+
+
def get_event_centric_neighbors(
self,
nodes: list[Node | str],
diff --git a/tests/test_networkx_event_centric.py b/tests/test_networkx_event_centric.py
new file mode 100644
index 0000000..1ecd7df
--- /dev/null
+++ b/tests/test_networkx_event_centric.py
@@ -0,0 +1,127 @@
+import os
+import sys
+import unittest
+
+ENV_DEFAULTS = {
+ "BRAINPAT_TOKEN": "test-token",
+ "MODELS_MODE": "local",
+ "EMBEDDINGS_LOCAL_MODEL": "local-model",
+ "EMBEDDINGS_SMALL_MODEL": "small-model",
+ "EMBEDDING_NODES_DIMENSION": "3",
+ "EMBEDDING_TRIPLETS_DIMENSION": "3",
+ "EMBEDDING_OBSERVATIONS_DIMENSION": "3",
+ "EMBEDDING_DATA_DIMENSION": "3",
+ "EMBEDDING_RELATIONSHIPS_DIMENSION": "3",
+ "REDIS_HOST": "localhost",
+ "REDIS_PORT": "6379",
+ "NEO4J_HOST": "localhost",
+ "NEO4J_PORT": "7687",
+ "NEO4J_USERNAME": "neo4j",
+ "NEO4J_PASSWORD": "password",
+ "MILVUS_HOST": "localhost",
+ "MILVUS_PORT": "19530",
+ "MONGO_CONNECTION_STRING": "mongodb://localhost:27017",
+ "CELERY_WORKER_CONCURRENCY": "1",
+ "OLLAMA_HOST": "localhost",
+ "OLLAMA_PORT": "11434",
+ "OLLAMA_LLM_SMALL_MODEL": "small",
+ "OLLAMA_LLM_LARGE_MODEL": "large",
+ "POSTGRES_HOST": "localhost",
+ "POSTGRES_PORT": "5432",
+ "POSTGRES_USERNAME": "postgres",
+ "POSTGRES_PASSWORD": "postgres",
+}
+for key, value in ENV_DEFAULTS.items():
+ os.environ.setdefault(key, value)
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+try:
+ from src.lib.postgresql.graph_store import _BrainGraph
+ from src.lib.postgresql.networkx_client import NetworkXGraphClient
+
+ DEPS_AVAILABLE = True
+except ImportError:
+ _BrainGraph = None
+ NetworkXGraphClient = None
+ DEPS_AVAILABLE = False
+
+
+class _FakeStore:
+ def __init__(self, brain):
+ self._brain = brain
+
+ def ensure_database(self, brain_id):
+ return None
+
+ def get_brain(self, brain_id):
+ return self._brain
+
+
+def _build_brain():
+ brain = _BrainGraph("test-brain")
+ brain.graph.add_node("A", uuid="A", name="Alice", labels=["Person"])
+ brain.graph.add_node("B", uuid="B", name="Meeting", labels=["Event"])
+ brain.graph.add_node("C", uuid="C", name="Bob", labels=["Person"])
+ brain.graph.add_node("D", uuid="D", name="Elsewhere", labels=["Event"])
+ brain.graph.add_edge(
+ "A", "B", key="r1", uuid="r1", rel_type="CAUSED", flow_key="flow1"
+ )
+ brain.graph.add_edge(
+ "B", "C", key="r2", uuid="r2", rel_type="LED_TO", flow_key="flow1"
+ )
+ brain.graph.add_edge(
+ "B", "D", key="r3", uuid="r3", rel_type="UNRELATED", flow_key="other"
+ )
+ return brain
+
+
[email protected](DEPS_AVAILABLE, "postgresql/networkx dependencies unavailable")
+class NetworkXEventCentricTests(unittest.TestCase):
+ def _client(self):
+ client = object.__new__(NetworkXGraphClient)
+ client._store = _FakeStore(_build_brain())
+ return client
+
+ def test_event_path_records_helper_exists(self):
+ self.assertTrue(hasattr(NetworkXGraphClient, "_event_path_records"))
+ self.assertTrue(hasattr(NetworkXGraphClient, "_node_from_brain"))
+ self.assertTrue(hasattr(NetworkXGraphClient, "_predicate_from_edge"))
+
+ def test_get_event_centric_neighbors_returns_matching_flow_paths(self):
+ client = self._client()
+ results = client.get_event_centric_neighbors(["A"], "test-brain")
+ self.assertEqual(len(results), 1)
+ n, r1, m, r2, b = results[0]
+ self.assertEqual(n.uuid, "A")
+ self.assertEqual(m.uuid, "B")
+ self.assertEqual(b.uuid, "C")
+ self.assertEqual(r1.name, "CAUSED")
+ self.assertEqual(r2.name, "LED_TO")
+ self.assertEqual(r1.flow_key, "flow1")
+ self.assertEqual(r2.flow_key, "flow1")
+
+ def test_get_event_centric_neighbors_empty_for_unknown_node(self):
+ client = self._client()
+ self.assertEqual(client.get_event_centric_neighbors(["Z"], "test-brain"), [])
+
+ def test_get_event_centric_neighbors_empty_input(self):
+ client = self._client()
+ self.assertEqual(client.get_event_centric_neighbors([], "test-brain"), [])
+
+ def test_get_nexts_by_flow_key_returns_next_triple(self):
+ client = self._client()
+ res = client.get_nexts_by_flow_key(
+ [{"predicate_uuid": "r1", "flow_key": "flow1"}], "test-brain"
+ )
+ self.assertIn("r1", res)
+ triples = res["r1"]
+ self.assertEqual(len(triples), 1)
+ m, r2, b = triples[0]
+ self.assertEqual(m.uuid, "B")
+ self.assertEqual(r2.name, "LED_TO")
+ self.assertEqual(b.uuid, "C")
+
+
+if __name__ == "__main__":
+ unittest.main()