graphrag-codeproperty-graph 0.5.1__tar.gz → 0.5.2__tar.gz

{graphrag_codeproperty_graph-0.5.1 → graphrag_codeproperty_graph-0.5.2}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.5.2] - 2026-09-16
+
+### Fixed
+- **`VectorLoader` no longer writes the raw embedding vector as a Neptune node
+  property.** The 0.5.1 on-node write (`SET n += {embedding: <array>, ...}`) was a
+  Neo4j-era pattern: Neo4j stores list-valued properties, but the graph backend is
+  now Neptune Database, whose openCypher rejects arrays ("Property value must be a
+  simple literal"). Every per-node write failed with `BadRequestException`, flooding
+  the ingest log with warnings. The embedding **vector** already lives in the vector
+  store (AOSS/OpenSearch), which is the sole surface used for kNN retrieval — nothing
+  reads the on-node vector. `VectorLoader.load` now writes only **scalar embedding
+  provenance** to the node (`hasEmbedding`, `embeddingModel`, `embeddingDimensions`,
+  `embeddingTarget`, `embeddedTime`), which Neptune accepts, preserving the
+  graph-side "this node has an embedding" signal without duplicating unqueryable data.
+  Covered by `tests/test_delta_ingestor_embedding_property.py`
+  (`test_vector_loader_writes_scalar_provenance_not_array`). (PSAPI-66782.)
+
 ## [0.5.1] - 2026-09-15
 
 ### Fixed

{graphrag_codeproperty_graph-0.5.1 → graphrag_codeproperty_graph-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphrag-codeproperty-graph
-Version: 0.5.1
+Version: 0.5.2
 Summary: Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring
 Project-URL: Repository, https://github.com/kanjani-ai-research/codeproperty-graph
 Author-email: Evan Erwee <evan@erwee.com>

{graphrag_codeproperty_graph-0.5.1 → graphrag_codeproperty_graph-0.5.2}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/codeproperty_graph"]
 
 [project]
 name = "graphrag-codeproperty-graph"
-version = "0.5.1"
+version = "0.5.2"
 description = "Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring"
 readme = "README.md"
 requires-python = ">=3.11"

{graphrag_codeproperty_graph-0.5.1 → graphrag_codeproperty_graph-0.5.2}/src/codeproperty_graph/vector_loader.py

@@ -163,7 +163,17 @@ class VectorLoader:
             result.total_loaded += count
             logger.info(f"Loaded {count} vectors for target '{target}'")
 
-        # Also write embedding as a node property on Neptune (client schema conformance)
+        # Write embedding PROVENANCE (scalar metadata) onto the graph node.
+        #
+        # The embedding VECTOR itself lives in the vector store (AOSS/OpenSearch),
+        # which is the sole surface used for kNN retrieval. We deliberately do NOT
+        # write the raw vector as a node property: the original Neo4j schema stored
+        # `SET n.embedding = <array>` (Neo4j supports list-valued properties), but
+        # the graph backend here is Neptune Database, whose openCypher rejects
+        # array/list property values ("Property value must be a simple literal").
+        # Storing scalar provenance (model, dimensions, timestamp, presence flag)
+        # keeps the "this node has an embedding" graph-side signal — queryable and
+        # filterable — without duplicating the vector where nothing reads it.
         if self._graph_store and records:
             written = 0
             for raw in records:
@@ -171,13 +181,21 @@ class VectorLoader:
                 try:
                     await self._graph_store.update_node_properties(
                         record.cpg_node_id,
-                        {"embedding": record.vector, "embeddedTime": record.metadata.get("embedded_time", "")},
+                        {
+                            "hasEmbedding": True,
+                            "embeddingModel": record.embedding_model,
+                            "embeddingDimensions": (
+                                record.embedding_dimensions or len(record.vector)
+                            ),
+                            "embeddingTarget": record.embedding_target,
+                            "embeddedTime": record.metadata.get("embedded_time", ""),
+                        },
                     )
                     written += 1
                 except Exception as e:
-                    logger.debug(f"Failed to write embedding property for {record.cpg_node_id}: {e}")
+                    logger.debug(f"Failed to write embedding provenance for {record.cpg_node_id}: {e}")
             if written:
-                logger.info(f"Wrote embedding property to {written} Neptune nodes")
+                logger.info(f"Wrote embedding provenance to {written} Neptune nodes")
 
         if result.errors:
             logger.warning(f"Encountered {len(result.errors)} validation errors during load")

{graphrag_codeproperty_graph-0.5.1 → graphrag_codeproperty_graph-0.5.2}/tests/test_delta_ingestor_embedding_property.py

@@ -69,3 +69,61 @@ async def test_vector_loader_receives_graph_store():
         )
         # And it should be the SAME store GraphLoader got.
         assert GL.call_args.kwargs.get("graph_store") is graph_store
+
+
+# ─── Wave (Neptune fix): on-node write must be SCALAR provenance, not the array ──
+#
+# Neptune Database openCypher rejects list/array property values ("Property value
+# must be a simple literal"). The raw embedding vector lives in the vector store
+# (AOSS); the graph node must carry only scalar provenance. This test drives
+# VectorLoader.load directly and asserts what actually reaches update_node_properties.
+
+from codeproperty_graph import VectorLoader
+
+
+@pytest.mark.asyncio
+async def test_vector_loader_writes_scalar_provenance_not_array():
+    graph_store = MagicMock(name="neptune_store")
+    graph_store.update_node_properties = AsyncMock(return_value=True)
+
+    vector_store = MagicMock(name="opensearch_store")
+    vector_store.put_vectors = AsyncMock(return_value=1)
+
+    loader = VectorLoader(vector_store=vector_store, graph_store=graph_store)
+
+    records = [{
+        "cpg_node_id": "n1",
+        "embedding_target": "class_summary",
+        "vector": [0.1] * 768,
+        "text": "summary text",
+        "embedding_model": "nomic-embed-text",
+        "embedding_dimensions": 768,
+        "metadata": {"embedded_time": "2026-09-16T07:50:43Z"},
+    }]
+
+    await loader.load(records)
+
+    # The on-node write must have happened...
+    assert graph_store.update_node_properties.await_count == 1
+    node_id, props = graph_store.update_node_properties.await_args.args
+
+    assert node_id == "n1"
+    # ...and it must NOT include the raw vector array (the Neptune-rejecting bug).
+    assert "embedding" not in props, (
+        "VectorLoader must not write the raw embedding array to the Neptune node "
+        "(Neptune Database rejects list-valued properties)"
+    )
+    # ...every value written must be a Neptune-safe scalar literal.
+    for key, value in props.items():
+        assert not isinstance(value, (list, dict, tuple, set)), (
+            f"Node property {key!r} must be a scalar literal, got {type(value).__name__}"
+        )
+    # ...and the useful provenance is present.
+    assert props["hasEmbedding"] is True
+    assert props["embeddingModel"] == "nomic-embed-text"
+    assert props["embeddingDimensions"] == 768
+    assert props["embeddingTarget"] == "class_summary"
+    assert props["embeddedTime"] == "2026-09-16T07:50:43Z"
+
+    # The VECTOR itself still goes to the vector store (AOSS).
+    assert vector_store.put_vectors.await_count >= 1