fix(adapters): use unconditional CREATE for edges; fix get_rel_map

LangChain adapter:
- Remove WHERE NOT (pattern) guard — CoordiNode returns 0 rows silently
  instead of raising, so the guarded CREATE never executed
- Remove try/except fallback (no longer needed)
- Skip SET r += $props when props is empty — SET r += {} unsupported

LlamaIndex adapter:
- upsert_relations: same fix — skip SET r += $props when props is empty
- get_rel_map: replace [r*1..N] variable-length path with single-hop [r];
  variable-length paths don't serialize correctly in RETURN position
- Adjust ignore_rels filter from NONE(rel IN r ...) to r.__type__ NOT IN
  (compatible with single-hop [r] pattern)

Author: polaz

langchain-coordinode/langchain_coordinode/graph.py

@@ -113,30 +113,29 @@ def add_graph_documents(
                     params={"name": node.id, "props": props},
                 )
 
-            # ── Create relationships (idempotent: skip if already exists) ─
+            # ── Create relationships ──────────────────────────────────────
             for rel in doc.relationships:
                 src_label = _cypher_ident(rel.source.type or "Entity")
                 dst_label = _cypher_ident(rel.target.type or "Entity")
                 rel_type = _cypher_ident(rel.type)
                 props = dict(rel.properties or {})
-                # CoordiNode does not yet support MERGE for edges; use CREATE
-                # guarded by NOT EXISTS to avoid duplicates on repeated calls.
-                try:
+                # CoordiNode does not support MERGE for edges or WHERE NOT
+                # (pattern) guards — use unconditional CREATE.  SET r += $props
+                # is skipped when props is empty because SET r += {} is not
+                # supported by all server versions.
+                if props:
                     self._client.cypher(
                         f"MATCH (src:{src_label} {{name: $src}}) "
                         f"MATCH (dst:{dst_label} {{name: $dst}}) "
-                        f"WHERE NOT (src)-[:{rel_type}]->(dst) "
                         f"CREATE (src)-[r:{rel_type}]->(dst) SET r += $props",
                         params={"src": rel.source.id, "dst": rel.target.id, "props": props},
                     )
-                except Exception:  # noqa: BLE001
-                    # WHERE NOT EXISTS guard may not be supported on all server
-                    # versions; fall back to unconditional CREATE
+                else:
                     self._client.cypher(
                         f"MATCH (src:{src_label} {{name: $src}}) "
                         f"MATCH (dst:{dst_label} {{name: $dst}}) "
-                        f"CREATE (src)-[r:{rel_type}]->(dst) SET r += $props",
-                        params={"src": rel.source.id, "dst": rel.target.id, "props": props},
+                        f"CREATE (src)-[r:{rel_type}]->(dst)",
+                        params={"src": rel.source.id, "dst": rel.target.id},
                     )
 
             # ── Optionally link source document ───────────────────────────
@@ -148,21 +147,12 @@ def add_graph_documents(
                 )
                 for node in doc.nodes:
                     label = _cypher_ident(node.type or "Entity")
-                    try:
-                        self._client.cypher(
-                            f"MATCH (d:__Document__ {{id: $doc_id}}) "
-                            f"MATCH (n:{label} {{name: $name}}) "
-                            f"WHERE NOT (d)-[:MENTIONS]->(n) "
-                            f"CREATE (d)-[:MENTIONS]->(n)",
-                            params={"doc_id": src_id, "name": node.id},
-                        )
-                    except Exception:  # noqa: BLE001
-                        self._client.cypher(
-                            f"MATCH (d:__Document__ {{id: $doc_id}}) "
-                            f"MATCH (n:{label} {{name: $name}}) "
-                            f"CREATE (d)-[:MENTIONS]->(n)",
-                            params={"doc_id": src_id, "name": node.id},
-                        )
+                    self._client.cypher(
+                        f"MATCH (d:__Document__ {{id: $doc_id}}) "
+                        f"MATCH (n:{label} {{name: $name}}) "
+                        f"CREATE (d)-[:MENTIONS]->(n)",
+                        params={"doc_id": src_id, "name": node.id},
+                    )
 
         # Invalidate cached schema so next access reflects new data
         self._schema = None

llama-index-coordinode/llama_index/graph_stores/coordinode/base.py

@@ -172,16 +172,19 @@ def get_rel_map(
         node_ids = [n.id for n in graph_nodes]
         ignored = list(ignore_rels) if ignore_rels else []
 
-        # Push ignore_rels filter into Cypher so LIMIT applies after filtering;
-        # a Python-side filter after LIMIT would silently truncate valid results.
         params: dict[str, object] = {"ids": node_ids}
         ignore_clause = ""
         if ignored:
-            ignore_clause = " AND NONE(rel IN r WHERE type(rel) IN $ignored_rels)"
+            # Single-hop [r]: filter with r.__type__ NOT IN $ignored_rels.
+            ignore_clause = " AND NOT r.__type__ IN $ignored_rels"
             params["ignored_rels"] = ignored
 
+        # CoordiNode does not support variable-length path [r*1..N] in RETURN
+        # position (result serialisation is undefined for path lists).  Use a
+        # single-hop pattern; multi-hop traversal is a future enhancement.
+        _ = depth  # depth parameter reserved; currently single-hop only
         cypher = (
-            f"MATCH (n)-[r*1..{depth}]->(m) "
+            f"MATCH (n)-[r]->(m) "
             f"WHERE n.id IN $ids{ignore_clause} "
             f"RETURN n, r, m, n.id AS _src_id, m.id AS _dst_id "
             f"LIMIT {limit}"
@@ -194,12 +197,11 @@ def get_rel_map(
             dst_data = row.get("m", {})
             src_id = str(row.get("_src_id", ""))
             dst_id = str(row.get("_dst_id", ""))
-            # Variable-length path [r*1..N] returns a list of relationship dicts.
-            rels = row.get("r", [])
-            if isinstance(rels, list) and rels:
-                first_rel = rels[0]
-                # CoordiNode: use __type__ key instead of "type" — type() returns null
-                rel_label = first_rel.get("__type__") or first_rel.get("type", "RELATED") if isinstance(first_rel, dict) else str(first_rel)
+            # Single-hop [r] returns the relationship as a dict.
+            # CoordiNode: use __type__ key — type() returns null.
+            r_val = row.get("r", {})
+            if isinstance(r_val, dict):
+                rel_label = r_val.get("__type__") or r_val.get("type") or "RELATED"
             else:
                 rel_label = "RELATED"
             src = _node_result_to_labelled(src_id, src_data)
@@ -223,20 +225,25 @@ def upsert_relations(self, relations: list[Relation]) -> None:
             props = rel.properties or {}
             label = _cypher_ident(rel.label)
             # CoordiNode does not yet support MERGE for edge patterns; use CREATE.
+            # SET r += $props is skipped when props is empty — SET r += {} is
+            # not supported by all server versions.
             # Note: repeated calls will create duplicate edges until MERGE for
             # edges is implemented server-side.
-            cypher = (
-                f"MATCH (src {{id: $src_id}}) MATCH (dst {{id: $dst_id}}) "
-                f"CREATE (src)-[r:{label}]->(dst) SET r += $props"
-            )
-            self._client.cypher(
-                cypher,
-                params={
-                    "src_id": rel.source_id,
-                    "dst_id": rel.target_id,
-                    "props": props,
-                },
-            )
+            if props:
+                cypher = (
+                    f"MATCH (src {{id: $src_id}}) MATCH (dst {{id: $dst_id}}) "
+                    f"CREATE (src)-[r:{label}]->(dst) SET r += $props"
+                )
+                self._client.cypher(
+                    cypher,
+                    params={"src_id": rel.source_id, "dst_id": rel.target_id, "props": props},
+                )
+            else:
+                cypher = f"MATCH (src {{id: $src_id}}) MATCH (dst {{id: $dst_id}}) CREATE (src)-[r:{label}]->(dst)"
+                self._client.cypher(
+                    cypher,
+                    params={"src_id": rel.source_id, "dst_id": rel.target_id},
+                )
 
     def delete(
         self,

tests/integration/adapters/test_langchain.py

@@ -27,6 +27,7 @@ def graph():
 
 # ── Basic connectivity ────────────────────────────────────────────────────────
 
+
 def test_connect(graph):
     assert graph is not None
 
@@ -47,6 +48,7 @@ def test_refresh_schema_does_not_raise(graph):
 
 # ── Cypher query ──────────────────────────────────────────────────────────────
 
+
 def test_query_returns_list(graph):
     result = graph.query("RETURN 1 AS n")
     assert isinstance(result, list)
@@ -61,6 +63,7 @@ def test_query_count(graph):
 
 # ── add_graph_documents ───────────────────────────────────────────────────────
 
+
 @pytest.fixture
 def unique_tag():
     return uuid.uuid4().hex[:8]
@@ -95,8 +98,7 @@ def test_add_graph_documents_creates_relationship(graph, unique_tag):
 
     # Verify the relationship was created, not just the source node.
     result = graph.query(
-        "MATCH (a:LCPerson2 {name: $src})-[r:LC_RESEARCHES]->(b:LCConcept {name: $dst}) "
-        "RETURN count(r) AS cnt",
+        "MATCH (a:LCPerson2 {name: $src})-[r:LC_RESEARCHES]->(b:LCConcept {name: $dst}) RETURN count(r) AS cnt",
         params={"src": f"Charlie-{unique_tag}", "dst": f"GraphRAG-{unique_tag}"},
     )
     assert result[0]["cnt"] >= 1, f"relationship not found: {result}"

tests/integration/adapters/test_llama_index.py

@@ -30,6 +30,7 @@ def tag():
 
 # ── Basic connectivity ────────────────────────────────────────────────────────
 
+
 def test_connect(store):
     assert store is not None
 
@@ -47,6 +48,7 @@ def test_structured_query_literal(store):
 
 # ── Node operations ───────────────────────────────────────────────────────────
 
+
 def test_upsert_and_get_nodes(store, tag):
     nodes = [
         EntityNode(label="LITestPerson", name=f"Alice-{tag}", properties={"role": "researcher"}),
@@ -80,6 +82,7 @@ def test_get_by_id(store, tag):
 
 # ── Relation operations ───────────────────────────────────────────────────────
 
+
 def test_upsert_and_get_triplets(store, tag):
     src = EntityNode(label="LIRelPerson", name=f"Src-{tag}")
     dst = EntityNode(label="LIRelConcept", name=f"Dst-{tag}")
@@ -121,6 +124,7 @@ def test_get_rel_map(store, tag):
 
 # ── Delete ────────────────────────────────────────────────────────────────────
 
+
 def test_delete_by_id(store, tag):
     node = EntityNode(label="LIDelete", name=f"Del-{tag}")
     store.upsert_nodes([node])