memgres 0.2.0__tar.gz → 0.2.1__tar.gz

{memgres-0.2.0 → memgres-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.2.0
+Version: 0.2.1
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT
@@ -282,8 +282,10 @@ Either way the model gets tools `memory_write`, `memory_recall`, `memory_get`,
 X"* / *"what do you know about Y?"* and it calls them. (For semantic recall add the
 embedding env vars — see [docs/BACKENDS.md](docs/BACKENDS.md).)
 
-**Isolation — pin the identity in the client config; the agent never handles the
-token** (so the model spends nothing echoing a secret and can't switch user):
+### Isolation — pin the identity in the client config
+
+The agent **never handles the token** (so the model spends nothing echoing a
+secret and can't switch user):
 
 - **stdio**: set `MEMGRES_KEY_MODE=open` + `MEMGRES_TOKEN=<mgk_…>` in the client's
   `env` block (above).
@@ -305,7 +307,7 @@ argument for the model to supply — force it either way with
 library after the model produces text (see the examples above). Use this when you
 control the agent loop and decide when to write/recall.
 
-## Tokens & auth
+## Multi-tenant, tokens & isolation
 
 There is **no token for single-user / local use** — leave everything default
 (`MEMGRES_KEY_MODE=single`) and it just works. Two token concepts exist, unrelated:

{memgres-0.2.0 → memgres-0.2.1}/README.md

@@ -247,8 +247,10 @@ Either way the model gets tools `memory_write`, `memory_recall`, `memory_get`,
 X"* / *"what do you know about Y?"* and it calls them. (For semantic recall add the
 embedding env vars — see [docs/BACKENDS.md](docs/BACKENDS.md).)
 
-**Isolation — pin the identity in the client config; the agent never handles the
-token** (so the model spends nothing echoing a secret and can't switch user):
+### Isolation — pin the identity in the client config
+
+The agent **never handles the token** (so the model spends nothing echoing a
+secret and can't switch user):
 
 - **stdio**: set `MEMGRES_KEY_MODE=open` + `MEMGRES_TOKEN=<mgk_…>` in the client's
   `env` block (above).
@@ -270,7 +272,7 @@ argument for the model to supply — force it either way with
 library after the model produces text (see the examples above). Use this when you
 control the agent loop and decide when to write/recall.
 
-## Tokens & auth
+## Multi-tenant, tokens & isolation
 
 There is **no token for single-user / local use** — leave everything default
 (`MEMGRES_KEY_MODE=single`) and it just works. Two token concepts exist, unrelated:

{memgres-0.2.0 → memgres-0.2.1}/memgres/qdrant_backend.py

@@ -13,7 +13,13 @@ So tag/tree/TTL changes never need to touch Qdrant — only a body change re-emb
 (upsert) and `forget` deletes the point. Config for the connection:
 
   QDRANT_URL (default http://localhost:6333) · QDRANT_API_KEY ·
-  MEMGRES_QDRANT_COLLECTION (default "memgres")
+  MEMGRES_QDRANT_COLLECTION (default "memgres") ·
+  MEMGRES_QDRANT_CA (path to a CA/self-signed cert to trust for an https URL)
+
+MEMGRES_QDRANT_CA is only needed when Qdrant serves TLS with a certificate the
+system trust store doesn't already know (a self-signed or private-CA deployment):
+point it at the PEM to verify against. Leave it unset for plain http or a
+publicly-trusted cert.
 
 Needs the `[qdrant]` extra (qdrant-client).
 """
@@ -26,14 +32,19 @@ from typing import List, Optional, Sequence, Tuple
 
 class QdrantIndex:
     def __init__(self, dim: int, url: Optional[str] = None,
-                 api_key: Optional[str] = None, collection: Optional[str] = None):
+                 api_key: Optional[str] = None, collection: Optional[str] = None,
+                 ca_cert: Optional[str] = None):
         from qdrant_client import QdrantClient
 
         self.dim = dim
         self.collection = collection or os.environ.get("MEMGRES_QDRANT_COLLECTION", "memgres")
         url = url or os.environ.get("QDRANT_URL", "http://localhost:6333")
         api_key = api_key or os.environ.get("QDRANT_API_KEY") or None
-        self.client = QdrantClient(url=url, api_key=api_key)
+        ca_cert = ca_cert or os.environ.get("MEMGRES_QDRANT_CA") or None
+        # A self-signed / private-CA https endpoint isn't in the system trust store;
+        # `verify=<pem>` makes the underlying httpx client trust exactly that cert.
+        extra = {"verify": ca_cert} if ca_cert else {}
+        self.client = QdrantClient(url=url, api_key=api_key, **extra)
         self._ensure()
 
     def _ensure(self) -> None:
@@ -44,6 +55,7 @@ class QdrantIndex:
                 self.collection,
                 vectors_config=VectorParams(size=self.dim, distance=Distance.COSINE),
             )
+            self._ensure_namespace_index()
             return
         info = self.client.get_collection(self.collection)
         size = info.config.params.vectors.size
@@ -53,6 +65,22 @@ class QdrantIndex:
                 f"Qdrant collection '{self.collection}' has dim {size}, model emits "
                 f"{self.dim} — re-embed into a fresh collection, don't mix models."
             )
+        self._ensure_namespace_index()
+
+    def _ensure_namespace_index(self) -> None:
+        """Keyword payload index on `namespace` so tenant-filtered ANN search
+        stays fast as the collection grows (isolation is enforced by the query
+        filter regardless; this is purely the speed of that filter). Idempotent:
+        check the existing payload schema rather than catch a re-create error."""
+        from qdrant_client.models import PayloadSchemaType
+
+        info = self.client.get_collection(self.collection)
+        if "namespace" in (info.payload_schema or {}):
+            return
+        self.client.create_payload_index(
+            self.collection, field_name="namespace",
+            field_schema=PayloadSchemaType.KEYWORD,
+        )
 
     def upsert(self, id: str, vector: Sequence[float], namespace: str) -> None:
         from qdrant_client.models import PointStruct

{memgres-0.2.0 → memgres-0.2.1}/memgres.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.2.0
+Version: 0.2.1
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT
@@ -282,8 +282,10 @@ Either way the model gets tools `memory_write`, `memory_recall`, `memory_get`,
 X"* / *"what do you know about Y?"* and it calls them. (For semantic recall add the
 embedding env vars — see [docs/BACKENDS.md](docs/BACKENDS.md).)
 
-**Isolation — pin the identity in the client config; the agent never handles the
-token** (so the model spends nothing echoing a secret and can't switch user):
+### Isolation — pin the identity in the client config
+
+The agent **never handles the token** (so the model spends nothing echoing a
+secret and can't switch user):
 
 - **stdio**: set `MEMGRES_KEY_MODE=open` + `MEMGRES_TOKEN=<mgk_…>` in the client's
   `env` block (above).
@@ -305,7 +307,7 @@ argument for the model to supply — force it either way with
 library after the model produces text (see the examples above). Use this when you
 control the agent loop and decide when to write/recall.
 
-## Tokens & auth
+## Multi-tenant, tokens & isolation
 
 There is **no token for single-user / local use** — leave everything default
 (`MEMGRES_KEY_MODE=single`) and it just works. Two token concepts exist, unrelated:

{memgres-0.2.0 → memgres-0.2.1}/memgres.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_config.py
 tests/test_diffing.py
 tests/test_embeddings.py
 tests/test_identity_integration.py
+tests/test_qdrant_ca.py
 tests/test_qdrant_integration.py
 tests/test_search_integration.py
 tests/test_security_integration.py

{memgres-0.2.0 → memgres-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memgres"
-version = "0.2.0"
+version = "0.2.1"
 description = "Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable."
 readme = "README.md"
 license = "MIT"

memgres-0.2.1/tests/test_qdrant_ca.py

@@ -0,0 +1,72 @@
+"""Unit test: MEMGRES_QDRANT_CA is forwarded to the Qdrant client as `verify=`.
+
+No live Qdrant needed — a fake client records the kwargs it was built with and
+stubs the calls `_ensure()` makes, so this runs anywhere (unlike the integration
+tests that need a real server). Guards the self-signed / private-CA TLS path.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import pytest  # noqa: E402
+
+
+class _FakeCollectionInfo:
+    def __init__(self, dim):
+        class _V:  # info.config.params.vectors.size
+            size = dim
+        class _P:
+            vectors = _V()
+        class _C:
+            params = _P()
+        self.config = _C()
+        self.payload_schema = {"namespace": object()}  # pretend the index exists
+
+
+class _FakeClient:
+    last_kwargs = None
+
+    def __init__(self, **kwargs):
+        _FakeClient.last_kwargs = kwargs
+
+    def collection_exists(self, _c):
+        return True
+
+    def get_collection(self, _c):
+        return _FakeCollectionInfo(dim=8)
+
+
+@pytest.fixture
+def fake_qdrant(monkeypatch):
+    import qdrant_client
+    monkeypatch.setattr(qdrant_client, "QdrantClient", _FakeClient)
+    _FakeClient.last_kwargs = None
+    yield
+
+
+def test_ca_cert_forwarded_as_verify(fake_qdrant, monkeypatch):
+    monkeypatch.setenv("MEMGRES_QDRANT_CA", "/etc/ssl/my-ca.pem")
+    from memgres.qdrant_backend import QdrantIndex
+    QdrantIndex(dim=8, url="https://qdrant.example:6333")
+    assert _FakeClient.last_kwargs.get("verify") == "/etc/ssl/my-ca.pem"
+
+
+def test_no_ca_means_no_verify_kwarg(fake_qdrant, monkeypatch):
+    monkeypatch.delenv("MEMGRES_QDRANT_CA", raising=False)
+    from memgres.qdrant_backend import QdrantIndex
+    QdrantIndex(dim=8, url="http://qdrant.example:6333")
+    # default trust store path: don't pin `verify` at all
+    assert "verify" not in _FakeClient.last_kwargs
+
+
+def test_explicit_ca_arg_beats_env(fake_qdrant, monkeypatch):
+    monkeypatch.setenv("MEMGRES_QDRANT_CA", "/env/ca.pem")
+    from memgres.qdrant_backend import QdrantIndex
+    QdrantIndex(dim=8, url="https://qdrant.example:6333", ca_cert="/arg/ca.pem")
+    assert _FakeClient.last_kwargs.get("verify") == "/arg/ca.pem"
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-v"]))

{memgres-0.2.0 → memgres-0.2.1}/tests/test_qdrant_integration.py

@@ -96,6 +96,16 @@ def test_no_pgvector_column_when_qdrant(store):
     assert "embedding" not in cols
 
 
+def test_namespace_payload_index_created(store):
+    # tenant-scoped ANN search filters on `namespace`; a keyword payload index
+    # keeps that filter fast as the collection grows (isolation holds either way)
+    from qdrant_client import QdrantClient
+    qc = QdrantClient(url=QURL)
+    schema = qc.get_collection(COLL).payload_schema or {}
+    assert "namespace" in schema
+    assert str(schema["namespace"].data_type).lower().endswith("keyword")
+
+
 def test_semantic_recall_via_qdrant(store):
     store.write(body="I love apple pie\n", path="food.apple", tags=["fruit"])
     store.write(body="banana bread recipe\n", path="food.banana", tags=["fruit"])