fix: correct API usage across SDK, tests, and integrations

- client: support "host:port" string in AsyncCoordinodeClient constructor
- test_types: fix _FakePV vector kind "vector" → "vector_value"
- test_basic: fix health() (bool not dict), cypher() (List[Dict] not .columns/.rows)
- langchain graph.py: query() — cypher() already returns List[Dict], no manual parse
- llama-index base.py: fix get/get_triplets/get_rel_map (dict row access),
  vector_query (r.node.id, r.node.properties, r.distance),
  structured_query (direct return)
- lint: remove unused imports and dead variable

Closes #1

Author: polaz

coordinode/_types.py

@@ -3,7 +3,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, Dict, List, Sequence, Union
+from typing import Any, Dict, List, Union
 
 # We import proto types lazily to avoid hard-fail when stubs aren't generated yet.
 

coordinode/client.py

@@ -15,7 +15,6 @@
     dict_to_props,
     from_property_value,
     props_to_dict,
-    to_property_value,
 )
 
 
@@ -82,8 +81,12 @@ class AsyncCoordinodeClient:
 
     Usage::
 
-        async with AsyncCoordinodeClient("localhost") as client:
+        async with AsyncCoordinodeClient("localhost:7080") as client:
             rows = await client.cypher("MATCH (n:Person) RETURN n.name LIMIT 5")
+
+        # Also accepts separate host and port:
+        async with AsyncCoordinodeClient("localhost", port=7080) as client:
+            ...
     """
 
     def __init__(
@@ -94,6 +97,10 @@ def __init__(
         tls: bool = False,
         timeout: float = 30.0,
     ) -> None:
+        # Support "host:port" as a single string (common gRPC convention).
+        if ":" in host and port == 7080:
+            _h, _p = host.rsplit(":", 1)
+            host, port = _h, int(_p)
         self._host = host
         self._port = port
         self._tls = tls
@@ -307,7 +314,7 @@ class CoordinodeClient:
 
     Usage::
 
-        with CoordinodeClient("localhost") as client:
+        with CoordinodeClient("localhost:7080") as client:
             rows = client.cypher("MATCH (n:Person) RETURN n.name LIMIT 5")
             print(rows)  # [{"n.name": "Alice"}, ...]
     """

langchain-coordinode/langchain_coordinode/graph.py

@@ -83,12 +83,8 @@ def query(
         Returns:
             List of row dicts (column name → value).
         """
-        result = self._client.cypher(query, params=params or {})
-        rows: List[Dict[str, Any]] = []
-        columns = list(result.columns)
-        for row in result.rows:
-            rows.append(dict(zip(columns, row)))
-        return rows
+        # cypher() returns List[Dict[str, Any]] directly — column name → value.
+        return self._client.cypher(query, params=params or {})
 
     # ── Lifecycle ─────────────────────────────────────────────────────────
 

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

@@ -2,13 +2,11 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Optional
 
 from llama_index.core.graph_stores.types import (
     ChunkNode,
     EntityNode,
-    KG_NODES_KEY,
-    KG_RELATIONS_KEY,
     LabelledNode,
     PropertyGraphStore,
     Relation,
@@ -73,9 +71,9 @@ def get(
             )
             cypher = f"MATCH (n) WHERE {where_clauses} RETURN n, id(n) AS _id LIMIT 1000"
             result = self._client.cypher(cypher, params=properties)
-            for row in result.rows:
-                node_data = row[0] if row else {}
-                node_id = str(row[1]) if len(row) > 1 else ""
+            for row in result:
+                node_data = row.get("n", {})
+                node_id = str(row.get("_id", ""))
                 nodes.append(_node_result_to_labelled(node_id, node_data))
 
         return nodes
@@ -104,22 +102,20 @@ def get_triplets(
         where = f"WHERE {' AND '.join(conditions)}" if conditions else ""
         cypher = (
             f"MATCH (n)-{rel_pattern}->(m) {where} "
-            "RETURN n, type(r), m, id(n) AS _src_id, id(m) AS _dst_id "
+            "RETURN n, type(r) AS rel_type, m, id(n) AS _src_id, id(m) AS _dst_id "
             "LIMIT 1000"
         )
         result = self._client.cypher(cypher, params=params)
 
         triplets: List[List[LabelledNode]] = []
-        for row in result.rows:
-            src_data, rel_type, dst_data, src_id, dst_id = (
-                row[0], row[1], row[2], str(row[3]), str(row[4])
-            )
+        for row in result:
+            src_data = row.get("n", {})
+            rel_type = row.get("rel_type", "RELATED")
+            dst_data = row.get("m", {})
+            src_id = str(row.get("_src_id", ""))
+            dst_id = str(row.get("_dst_id", ""))
             src = _node_result_to_labelled(src_id, src_data)
-            rel = Relation(
-                label=str(rel_type),
-                source_id=src_id,
-                target_id=dst_id,
-            )
+            rel = Relation(label=str(rel_type), source_id=src_id, target_id=dst_id)
             dst = _node_result_to_labelled(dst_id, dst_data)
             triplets.append([src, rel, dst])
 
@@ -137,10 +133,8 @@ def get_rel_map(
             return []
 
         ids = [n.id for n in graph_nodes]
-        rel_filter = ""
-        if ignore_rels:
-            # We can't dynamically exclude types in OpenCypher without WHERE
-            pass
+        # ignore_rels: OpenCypher doesn't support dynamic type exclusion in patterns;
+        # would require WHERE NOT type(r) IN $ignore_rels — added when needed.
 
         cypher = (
             f"MATCH (n)-[r*1..{depth}]->(m) "
@@ -151,13 +145,16 @@ def get_rel_map(
         result = self._client.cypher(cypher, params={"ids": ids})
 
         triplets: List[List[LabelledNode]] = []
-        for row in result.rows:
-            src_data, rels, dst_data, src_id, dst_id = (
-                row[0], row[1], row[2], str(row[3]), str(row[4])
-            )
+        for row in result:
+            src_data = row.get("n", {})
+            dst_data = row.get("m", {})
+            src_id = str(row.get("_src_id", ""))
+            dst_id = str(row.get("_dst_id", ""))
+            # Variable-length path r returns a list; take first rel type as label.
+            rels = row.get("r", [])
+            rel_label = str(rels[0]) if isinstance(rels, list) and rels else "RELATED"
             src = _node_result_to_labelled(src_id, src_data)
             dst = _node_result_to_labelled(dst_id, dst_data)
-            rel_label = str(rels[0]) if isinstance(rels, list) and rels else "RELATED"
             rel = Relation(label=rel_label, source_id=src_id, target_id=dst_id)
             triplets.append([src, rel, dst])
 
@@ -228,13 +225,14 @@ def vector_query(
         nodes: List[LabelledNode] = []
         scores: List[float] = []
         for r in results:
+            # VectorResult has .node (NodeResult with .id/.properties) and .distance
             node = ChunkNode(
-                id_=str(r.node_id),
-                text=r.properties.get("text", ""),
-                properties=r.properties,
+                id_=str(r.node.id),
+                text=r.node.properties.get("text", ""),
+                properties=r.node.properties,
             )
             nodes.append(node)
-            scores.append(r.score)
+            scores.append(r.distance)
 
         return nodes, scores
 
@@ -264,12 +262,8 @@ def structured_query(
         param_map: Optional[Dict[str, Any]] = None,
     ) -> Any:
         """Execute a raw Cypher query."""
-        result = self._client.cypher(query, params=param_map or {})
-        rows = []
-        columns = list(result.columns)
-        for row in result.rows:
-            rows.append(dict(zip(columns, row)))
-        return rows
+        # cypher() returns List[Dict[str, Any]] — column name → value.
+        return self._client.cypher(query, params=param_map or {})
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────

tests/integration/test_basic.py

@@ -22,24 +22,25 @@ def client():
 
 
 def test_health(client):
-    h = client.health()
-    assert h.get("status") in ("ok", "serving", "SERVING")
+    # health() returns bool — True when server reports SERVING
+    assert client.health() is True
 
 
 def test_cypher_return_literal(client):
+    # cypher() returns List[Dict[str, Any]] — one row per result row
     result = client.cypher("RETURN 1 AS n")
-    assert result.columns == ["n"] or "n" in result.columns
-    assert len(result.rows) == 1
+    assert len(result) == 1
+    assert result[0]["n"] == 1
 
 
 def test_create_and_get_node(client):
     result = client.cypher(
         "CREATE (n:IntegrationTest {name: $name}) RETURN id(n) AS node_id",
         params={"name": "sdk-test-node"},
     )
-    assert result.rows, "CREATE returned no rows"
-    node_id = str(result.rows[0][0])
-    assert node_id
+    assert result, "CREATE returned no rows"
+    node_id = result[0]["node_id"]
+    assert node_id is not None
 
     # Clean up
     client.cypher(
@@ -49,7 +50,8 @@ def test_create_and_get_node(client):
 
 
 def test_vector_search(client):
-    # Insert a node with an embedding, then search for it
+    # Insert a node with an embedding, then search for it.
+    # VectorResult has .node (NodeResult) and .distance (float).
     vec = [0.1] * 16
     client.cypher(
         "CREATE (d:VecTestDoc {id: 'vs-test', embedding: $vec})",
@@ -63,5 +65,7 @@ def test_vector_search(client):
             top_k=1,
         )
         assert len(results) >= 1
+        assert hasattr(results[0], "distance")
+        assert hasattr(results[0], "node")
     finally:
         client.cypher("MATCH (d:VecTestDoc {id: 'vs-test'}) DELETE d")

tests/unit/test_types.py

@@ -53,7 +53,7 @@ def bytes_value(self):
         return self._value
 
     @property
-    def vector(self):
+    def vector_value(self):
         return self._value
 
     @property
@@ -135,7 +135,7 @@ def test_bytes_value(self):
 
     def test_vector(self):
         vec = _FakeVec([0.1, 0.2])
-        pv = _FakePV("vector", vec)
+        pv = _FakePV("vector_value", vec)
         result = from_property_value(pv)
         assert result == pytest.approx([0.1, 0.2])