fix(14-A): handle numpy-array sparse-vector attrs in ingest()

fastembed's sparse embedders return numpy.ndarray for `.indices` and
`.values`. The previous `getattr(svec, "indices", []) or []` short-circuit
raised "ValueError: The truth value of an array with more than one element
is ambiguous" because numpy arrays don't define multi-element __bool__.

Replace the truthiness fallback with explicit `is None` checks. Convert
indices to plain int and values to plain float so the Qdrant SparseVector
gets native Python types regardless of the embedder's output dtype.

Discovered while running the first end-to-end longmemeval_s ingest against
live Qdrant — the unit suite mocked sparse embedders with plain Python
lists, so the numpy path was never exercised.

Add regression test `test_ingest_handles_numpy_sparse_vector_attrs` that
fakes numpy-shaped sparse outputs and asserts ingest() succeeds with
native int/float lists in the upserted SparseVector.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dzmitrys-dev

src/supamem/eval/longmemeval_ingest.py

@@ -192,9 +192,15 @@ def ingest(
 
     for (sid, text, axis), dvec, svec in zip(chunks, dense_iter, sparse_iter):
         dense_vec = [float(x) for x in dvec]
+        # NOTE: fastembed returns numpy arrays for `indices`/`values`. The
+        # `array or default` truthiness pattern raises "truth value of an
+        # array with more than one element is ambiguous" — use explicit
+        # None checks instead.
+        _idx = getattr(svec, "indices", None)
+        _val = getattr(svec, "values", None)
         sparse_vec = qmodels.SparseVector(
-            indices=list(getattr(svec, "indices", []) or []),
-            values=[float(v) for v in getattr(svec, "values", []) or []],
+            indices=[int(i) for i in (_idx if _idx is not None else [])],
+            values=[float(v) for v in (_val if _val is not None else [])],
         )
         point = qmodels.PointStruct(
             id=point_id,

tests/test_longmemeval_ingest.py

@@ -309,3 +309,66 @@ def test_ingest_does_not_mutate_caller_cfg(patch_embedders: None) -> None:
     original_collection = cfg.collection
     ingest_mod.ingest(cfg, [rec], client=client, suite="longmemeval_s")
     assert cfg.collection == original_collection
+
+
+# Test 9 — regression for numpy-array sparse-vector handling -----------------
+
+
+def test_ingest_handles_numpy_sparse_vector_attrs(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Real fastembed sparse embedders return numpy arrays for indices/values.
+
+    Regression: the previous ``getattr(svec, "indices", []) or []`` short-circuit
+    raised ``ValueError: The truth value of an array with more than one element
+    is ambiguous`` because numpy arrays don't support multi-element ``__bool__``.
+    The fix uses explicit ``is None`` checks. This test fakes numpy-shaped
+    sparse outputs to lock in that behavior without loading fastembed.
+    """
+    np = pytest.importorskip("numpy")
+
+    class _NumpySparse:
+        # Mimics fastembed.SparseEmbedding's array-typed attributes.
+        def __init__(self) -> None:
+            self.indices = np.array([0, 1, 2], dtype=np.int64)
+            self.values = np.array([0.5, 0.3, 0.2], dtype=np.float32)
+
+    def _yield_numpy(batch):
+        for _ in batch:
+            yield _NumpySparse()
+
+    fake_dense = MagicMock()
+    fake_dense.embed.side_effect = lambda batch: ([0.1] * 384 for _ in batch)
+    fake_sparse = MagicMock()
+    fake_sparse.embed.side_effect = _yield_numpy
+    monkeypatch.setattr(ingest_mod, "build_dense_embedder", lambda *a, **k: fake_dense)
+    monkeypatch.setattr(ingest_mod, "build_sparse_embedder", lambda *a, **k: fake_sparse)
+
+    client = MagicMock()
+    client.get_collections.return_value = MagicMock(collections=[])
+
+    rec = _make_raw_record(
+        "q",
+        "single_session_user",
+        sessions=[[{"role": "user", "content": "hello"}]],
+    )
+    cfg = _cfg()
+    # Must not raise — fix converts numpy → list explicitly via `is None` check.
+    count = ingest_mod.ingest(cfg, [rec], client=client, suite="longmemeval_s")
+    assert count == 1
+
+    # Confirm the upsert payload carried plain-Python int/float lists,
+    # not numpy arrays (Qdrant SparseVector wants native lists).
+    upsert_calls = client.upsert.call_args_list
+    assert upsert_calls, "expected at least one upsert call"
+    points = upsert_calls[0].kwargs.get("points") or upsert_calls[0].args[1]
+    sparse = points[0].vector["__sparse__"] if "__sparse__" in points[0].vector else None
+    # The sparse-vector key may differ; resolve generically.
+    if sparse is None:
+        for v in points[0].vector.values():
+            if hasattr(v, "indices") and hasattr(v, "values"):
+                sparse = v
+                break
+    assert sparse is not None
+    assert all(isinstance(i, int) for i in sparse.indices)
+    assert all(isinstance(v, float) for v in sparse.values)