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.
Python ai-agentsai-memoryknowledge-graphknowledge-managementknowledge-representationreccomendation-system
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.pyindex 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.pynew file mode 100644index 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()