fix(core): don't zero edge weight when recovering from a partial write

Follow-up to the edge-weight fix, from a Codex review of #3373: the weight
filter excluded sources found in existing_full_source_ids, but that set can come
from relation_chunks_storage, a SEPARATE store from the graph edge. If a prior
attempt upserted relation_chunks but crashed before upsert_edge, there is no
stored scalar weight (already_weights is empty), so filtering those sources
recovered the edge with weight 0. Only apply the exclusion when there IS a
stored scalar (already_weights non-empty); otherwise sum all contributions.

Regression test: an edge with relation_chunks holding the source but no graph
edge yet recovers with weight 1, not 0.

Author: ysys143

lightrag/operate.py

@@ -2510,15 +2510,23 @@ async def _merge_edges_then_upsert(
         # per reprocess (the #3367 sibling of description accumulation).
         # Genuinely new sources still add their weight, preserving legitimate
         # multi-document growth.
-        already_source_id_set = set(existing_full_source_ids)
-        weight = sum(
-            [
+        #
+        # Guard on already_weights (i.e. an existing edge with a stored scalar):
+        # existing_full_source_ids can come from relation_chunks_storage, which
+        # is a SEPARATE store from the graph edge. If a prior attempt upserted
+        # relation_chunks but crashed before upsert_edge, there is no stored
+        # weight yet — filtering those sources would recover the edge with
+        # weight 0. With no stored scalar nothing is double-counted, so sum all.
+        if already_weights:
+            already_source_id_set = set(existing_full_source_ids)
+            new_weight_terms = [
                 dp["weight"]
                 for dp in edges_data
                 if dp.get("source_id") not in already_source_id_set
             ]
-            + already_weights
-        )
+        else:
+            new_weight_terms = [dp["weight"] for dp in edges_data]
+        weight = sum(new_weight_terms + already_weights)
 
         # 6.2 Finalize keywords by merging existing and new keywords
         all_keywords = set()

tests/extraction/test_summary_description_dedup.py

@@ -21,6 +21,7 @@
     _handle_entity_relation_summary,
     _merge_edges_then_upsert,
     _merge_nodes_then_upsert,
+    make_relation_chunk_key,
 )
 from lightrag.constants import GRAPH_FIELD_SEP
 
@@ -257,3 +258,61 @@ def _edge(src: str) -> dict:
         await _merge_edges_then_upsert("A", "B", [_edge(src)], g, None, None, cfg)
 
     assert await g.get_edge("A", "B") is not None
+
+
+class _MemKV:
+    """No-op-ish KV that just serves a preset get_by_id."""
+
+    def __init__(self, data: dict):
+        self.data = dict(data)
+
+    async def get_by_id(self, key):
+        return self.data.get(key)
+
+    async def upsert(self, data):
+        self.data.update(data)
+
+
+@pytest.mark.offline
+@pytest.mark.asyncio
+async def test_edge_weight_recovers_to_one_when_edge_missing_but_chunks_stored():
+    """Partial-write recovery: relation_chunks_storage already has the source but
+    the graph edge does not exist yet (a crash between the two writes). The weight
+    filter must NOT treat those sources as already-weighted — already_weights is
+    empty, so filtering them would recover the edge with weight 0. With no stored
+    scalar, sum all contributions (weight = 1, not 0)."""
+    g = _MemGraph()
+    cfg = _cfg()
+    for name in ("A", "B"):
+        await g.upsert_node(
+            name,
+            {
+                "entity_id": name,
+                "description": name,
+                "source_id": "c1",
+                "entity_type": "X",
+                "file_path": "f",
+            },
+        )
+    rcs = _MemKV({make_relation_chunk_key("A", "B"): {"chunk_ids": ["c1"]}})
+    await _merge_edges_then_upsert(
+        "A",
+        "B",
+        [
+            {
+                "weight": 1.0,
+                "source_id": "c1",
+                "description": "rel",
+                "keywords": "k",
+                "file_path": "f",
+            }
+        ],
+        g,
+        None,
+        None,
+        cfg,
+        relation_chunks_storage=rcs,
+    )
+    edge = await g.get_edge("A", "B")
+    assert edge is not None
+    assert edge["weight"] == 1.0