mem0-postgres-store 0.1.0__py3-none-any.whl

mem0_postgres_store/__init__.py

@@ -0,0 +1,17 @@
+"""PostgreSQL persistence for Mem0. Importing this package never patches Mem0."""
+
+from .context import StorageOperationError, TenantContextError, tenant_scope
+from .database import Database
+from .history import PostgresHistoryStore
+from .integration import CompatibilityError, database_vector_config, install
+
+__all__ = [
+    "CompatibilityError",
+    "Database",
+    "PostgresHistoryStore",
+    "StorageOperationError",
+    "TenantContextError",
+    "database_vector_config",
+    "install",
+    "tenant_scope",
+]

mem0_postgres_store/context.py

@@ -0,0 +1,68 @@
+"""Authenticated request context, shared across asyncio and copied worker contexts."""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from threading import Lock
+
+
+class TenantContextError(RuntimeError):
+    """An authenticated tenant scope is required."""
+
+
+class StorageOperationError(RuntimeError):
+    """The SDK caught a persistence error; the operation may be partially committed."""
+
+
+@dataclass
+class TenantContext:
+    tenant_id: str
+    allow_reset: bool = False
+    failures: list[Exception] = field(default_factory=list)
+    lock: Lock = field(default_factory=Lock)
+    active: bool = True
+
+    def record(self, error: Exception) -> None:
+        with self.lock:
+            self.failures.append(error)
+
+
+_current: ContextVar[TenantContext | None] = ContextVar("mem0_postgres_tenant", default=None)
+
+
+def current_tenant() -> TenantContext:
+    context = _current.get()
+    if context is None or not context.active:
+        raise TenantContextError("Establish tenant_scope() using an authenticated tenant identity")
+    return context
+
+
+def require_reset() -> None:
+    context = current_tenant()
+    if not context.allow_reset:
+        error = PermissionError("Reset requires tenant_scope(..., allow_reset=True)")
+        context.record(error)
+        raise error
+
+
+@contextmanager
+def tenant_scope(tenant_id: str, *, allow_reset: bool = False) -> Iterator[None]:
+    """Trust boundary: callers must authenticate/authorize tenant_id before entering.
+
+    Keep all work inside the scope; do not detach background tasks. Errors caught by
+    upstream Mem0 are surfaced at scope exit. This is not a database transaction.
+    """
+    if not isinstance(tenant_id, str) or not tenant_id.strip() or "\x00" in tenant_id:
+        raise TenantContextError("tenant_id must be a nonempty text identity without NUL")
+    context = TenantContext(tenant_id, allow_reset)
+    token = _current.set(context)
+    try:
+        yield
+        if context.failures:
+            raise StorageOperationError(
+                "A persistence operation failed inside tenant_scope; partial writes are possible"
+            ) from context.failures[0]
+    finally:
+        context.active = False
+        _current.reset(token)

mem0_postgres_store/database.py

@@ -0,0 +1,153 @@
+"""Explicit infrastructure ownership; no environment or runtime DDL discovery."""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+import sqlalchemy as sa
+from psycopg.conninfo import make_conninfo
+from psycopg_pool import ConnectionPool
+from sqlalchemy.orm import Session
+
+from .context import current_tenant
+from .schema import APPEND_ONLY_TABLES, SCHEMA, TABLE_NAMES, VECTOR_COLLECTIONS
+
+
+class Database:
+    """Application-owned pools. Construct after migrations, close during shutdown."""
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        embedding_dimensions: int,
+        pool_size: int = 5,
+        timeout: float = 10,
+    ) -> None:
+        parsed = sa.make_url(url)
+        if parsed.drivername != "postgresql+psycopg":
+            raise ValueError("Use a postgresql+psycopg:// runtime URL")
+        if embedding_dimensions < 1 or pool_size < 1 or timeout <= 0:
+            raise ValueError("Dimensions, pool size and timeout must be positive")
+        self.embedding_dimensions = embedding_dimensions
+        self.closed = False
+        self.engine = sa.create_engine(
+            parsed,
+            pool_size=pool_size,
+            max_overflow=0,
+            pool_timeout=timeout,
+            pool_pre_ping=True,
+            connect_args={"connect_timeout": max(1, int(timeout))},
+        )
+        try:
+            self._validate_runtime()
+        except Exception:
+            self.engine.dispose()
+            raise
+        if any(not isinstance(value, str) for value in parsed.query.values()):
+            self.engine.dispose()
+            raise ValueError("Repeated URL query parameters are not supported")
+        conninfo = make_conninfo(
+            dbname=parsed.database,
+            user=parsed.username,
+            password=parsed.password,
+            host=parsed.host,
+            port=parsed.port,
+            **{key: str(value) for key, value in parsed.query.items()},
+        )
+        self.vector_pool = ConnectionPool(
+            conninfo,
+            min_size=0,
+            max_size=pool_size,
+            timeout=timeout,
+            check=ConnectionPool.check_connection,
+            kwargs={"connect_timeout": max(1, int(timeout))},
+            open=True,
+        )
+
+    def _validate_runtime(self) -> None:
+        with self.engine.connect() as connection:
+            unsafe = connection.execute(
+                sa.text("""
+                SELECT rolsuper OR rolbypassrls OR rolcreaterole OR rolcreatedb
+                FROM pg_roles WHERE rolname = current_user
+            """)
+            ).scalar_one()
+            if unsafe:
+                raise PermissionError("Runtime role must not have privileged role attributes")
+            for table in TABLE_NAMES:
+                row = connection.execute(
+                    sa.text("""
+                    SELECT c.relrowsecurity, c.relforcerowsecurity,
+                           pg_has_role(current_user, c.relowner, 'MEMBER') AS owns
+                    FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid
+                    WHERE n.nspname = :schema AND c.relname = :table
+                """),
+                    {"schema": SCHEMA, "table": table},
+                ).one_or_none()
+                if row is None or not row[0] or not row[1] or row[2]:
+                    raise PermissionError(
+                        f"{SCHEMA}.{table} requires migrations, forced RLS, and a separate owner"
+                    )
+                if connection.execute(
+                    sa.text("SELECT has_table_privilege(current_user, :table, 'TRUNCATE')"),
+                    {"table": f"{SCHEMA}.{table}"},
+                ).scalar_one():
+                    raise PermissionError("Runtime role must not have TRUNCATE privileges")
+                if (
+                    table in APPEND_ONLY_TABLES
+                    and connection.execute(
+                        sa.text("SELECT has_any_column_privilege(current_user, :table, 'UPDATE')"),
+                        {"table": f"{SCHEMA}.{table}"},
+                    ).scalar_one()
+                ):
+                    raise PermissionError(
+                        f"Runtime role must not UPDATE {SCHEMA}.{table}; apply all migrations"
+                    )
+            if connection.execute(
+                sa.text("SELECT has_schema_privilege(current_user, :schema, 'CREATE')"),
+                {"schema": SCHEMA},
+            ).scalar_one():
+                raise PermissionError("Runtime role must not have CREATE on the storage schema")
+            for table in VECTOR_COLLECTIONS:
+                vector_type = connection.execute(
+                    sa.text("""
+                    SELECT format_type(a.atttypid, a.atttypmod)
+                    FROM pg_attribute a
+                    WHERE a.attrelid = to_regclass(:table) AND a.attname = 'vector'
+                """),
+                    {"table": f"{SCHEMA}.{table}"},
+                ).scalar_one()
+                if vector_type != f"vector({self.embedding_dimensions})":
+                    raise ValueError("Embedding dimensions do not match the migrated vector tables")
+
+    @contextmanager
+    def session(self) -> Iterator[Session]:
+        context = current_tenant()
+        try:
+            self.check_open()
+            with Session(self.engine) as session, session.begin():
+                session.execute(
+                    sa.text("SELECT set_config('app.tenant_id', :tenant, true)"),
+                    {"tenant": context.tenant_id},
+                )
+                yield session
+        except Exception as error:
+            context.record(error)
+            raise
+
+    def check_open(self) -> None:
+        if self.closed:
+            raise RuntimeError("Database is closed")
+
+    def close(self) -> None:
+        if not self.closed:
+            self.closed = True
+            self.vector_pool.close()
+            self.engine.dispose()
+
+    def __enter__(self) -> "Database":
+        self.check_open()
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

mem0_postgres_store/history.py

@@ -0,0 +1,173 @@
+"""Mem0 SQLiteManager method contract backed by tenant-scoped transactions."""
+
+import hashlib
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+import sqlalchemy as sa
+
+from .context import current_tenant, require_reset
+from .database import Database
+from .schema import HISTORY_FIELDS, history
+from .schema import messages as message_table
+
+
+def _updated_order(value: str | None) -> datetime | None:
+    # SQLite DATETIME() orders ISO values in UTC to whole seconds; keep the
+    # original text independently for exact round trips, including None.
+    if value is None:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(UTC).replace(microsecond=0)
+
+
+class PostgresHistoryStore:
+    def __init__(self, database: Database) -> None:
+        self.database = database
+        self._closed = False
+
+    def _check_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("PostgresHistoryStore is closed")
+
+    def add_history(
+        self,
+        memory_id: str,
+        old_memory: str | None,
+        new_memory: str | None,
+        event: str,
+        *,
+        created_at: str | None = None,
+        updated_at: str | None = None,
+        is_deleted: int = 0,
+        actor_id: str | None = None,
+        role: str | None = None,
+    ) -> None:
+        self.batch_add_history(
+            [
+                {
+                    "memory_id": memory_id,
+                    "old_memory": old_memory,
+                    "new_memory": new_memory,
+                    "event": event,
+                    "created_at": created_at,
+                    "updated_at": updated_at,
+                    "is_deleted": is_deleted,
+                    "actor_id": actor_id,
+                    "role": role,
+                }
+            ]
+        )
+
+    def batch_add_history(self, records: list[dict[str, Any]]) -> None:
+        self._check_open()
+        with self.database.session() as session:
+            tenant = current_tenant().tenant_id
+            rows = []
+            for record in records:
+                row = {key: record.get(key) for key in HISTORY_FIELDS}
+                row.update(
+                    id=str(uuid.uuid4()),
+                    tenant_id=tenant,
+                    is_deleted=record.get("is_deleted", 0),
+                    updated_order=_updated_order(record.get("updated_at")),
+                )
+                rows.append(row)
+            if rows:
+                session.execute(history.insert(), rows)
+
+    def get_history(self, memory_id: str) -> list[dict[str, Any]]:
+        self._check_open()
+        with self.database.session() as session:
+            rows = session.execute(
+                sa.select(*(history.c[key] for key in HISTORY_FIELDS))
+                .where(history.c.memory_id == memory_id)
+                .order_by(
+                    history.c.created_at.collate("C").asc().nulls_first(),
+                    history.c.updated_order.asc().nulls_first(),
+                    history.c.sequence,
+                )
+            ).mappings()
+            return [dict(row, is_deleted=bool(row["is_deleted"])) for row in rows]
+
+    def save_messages(self, messages: list[dict[str, Any]], session_scope: str) -> None:
+        self._check_open()
+        with self.database.session() as session:
+            if not messages:
+                return
+            tenant = current_tenant().tenant_id
+            # Across processes, serialize insert + pruning for exactly this tenant/scope.
+            # Hash collisions only cause extra serialization; RLS still authorizes rows.
+            lock_key = int.from_bytes(
+                hashlib.sha256((tenant + "\x00" + session_scope).encode()).digest()[:8], signed=True
+            )
+            session.execute(sa.text("SELECT pg_advisory_xact_lock(:key)"), {"key": lock_key})
+            now = datetime.now(UTC).isoformat()
+            table = message_table
+            session.execute(
+                table.insert(),
+                [
+                    {
+                        "id": str(uuid.uuid4()),
+                        "tenant_id": tenant,
+                        "session_scope": session_scope,
+                        "role": message.get("role"),
+                        "content": message.get("content"),
+                        "name": message.get("name"),
+                        "created_at": now,
+                    }
+                    for message in messages
+                ],
+            )
+            keep = (
+                sa.select(table.c.sequence)
+                .where(table.c.session_scope == session_scope)
+                .order_by(table.c.created_at.desc(), table.c.sequence.desc())
+                .limit(10)
+            )
+            session.execute(
+                table.delete().where(
+                    table.c.session_scope == session_scope, table.c.sequence.not_in(keep)
+                )
+            )
+
+    def get_last_messages(self, session_scope: str, limit: int = 10) -> list[dict[str, Any]]:
+        self._check_open()
+        with self.database.session() as session:
+            query = (
+                sa.select(
+                    message_table.c.role,
+                    message_table.c.content,
+                    message_table.c.name,
+                    message_table.c.created_at,
+                    message_table.c.sequence,
+                )
+                .where(message_table.c.session_scope == session_scope)
+                .order_by(message_table.c.created_at.desc(), message_table.c.sequence.desc())
+            )
+            if limit >= 0:  # SQLite LIMIT -1 means all rows.
+                query = query.limit(limit)
+            latest = query.subquery()
+            rows = session.execute(
+                sa.select(
+                    latest.c.role, latest.c.content, latest.c.name, latest.c.created_at
+                ).order_by(latest.c.created_at, latest.c.sequence)
+            ).mappings()
+            return [dict(row) for row in rows]
+
+    def reset(self) -> None:
+        self._check_open()
+        require_reset()
+        with self.database.session() as session:
+            session.execute(history.delete())
+            session.execute(message_table.delete())
+
+    def close(self) -> None:
+        # A manager owns its lifecycle, not the application's shared pools.
+        self._closed = True

mem0_postgres_store/integration.py

@@ -0,0 +1,125 @@
+"""The only module that mutates Mem0 bindings; install() is explicit and process-global."""
+
+import concurrent.futures
+import hashlib
+import importlib
+import importlib.metadata
+import inspect
+import threading
+from contextvars import copy_context
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+from .database import Database
+from .history import PostgresHistoryStore
+
+_LOCK = threading.Lock()
+_database: Database | None = None
+_PROVIDER = "mem0_postgres_store.vector.TenantPGVector"
+# Official mem0ai 2.2.1 wheel; content equals v2.2.1 sources (ignoring trailing newlines).
+_FINGERPRINTS = {
+    "mem0.memory.main": "b2788e8be9f1cc81b0a5dbe8f1e485bc4934b81c464bdfe2ed72330c089f1dcb",
+    "mem0.memory.storage": "5e7a994e311d8d8cc8fb8e6447cbb7ef85a52fcea4dd7fa9b03bd1b596a1b5e5",
+    "mem0.vector_stores.pgvector": (
+        "3c21398a91eab7846936bd175bf3849975e0086f5bdae18a755d370b2bdb2c4f"
+    ),
+    "mem0.utils.factory": "b1f0fb9edfd220d05a5e0f9c7aac5674339f9525291634eacc5dae26ab4c967b",
+    "mem0.configs.base": "cddb03d76a2266ce0e845c0625d922434e862411ad26fd1c1837d737c02f3655",
+}
+
+
+class CompatibilityError(RuntimeError):
+    """The installed SDK or another patch does not match the audited integration."""
+
+
+class _ContextExecutor(concurrent.futures.ThreadPoolExecutor):
+    def submit(self, fn: Any, /, *args: Any, **kwargs: Any) -> Any:
+        return super().submit(copy_context().run, fn, *args, **kwargs)
+
+
+_concurrent = SimpleNamespace(
+    futures=SimpleNamespace(
+        ThreadPoolExecutor=_ContextExecutor,
+        as_completed=concurrent.futures.as_completed,
+    )
+)
+
+
+def installed_database() -> Database:
+    if _database is None:
+        raise RuntimeError("Call install(database) before constructing Mem0")
+    _database.check_open()
+    return _database
+
+
+def _history_factory(db_path: str = ":memory:") -> PostgresHistoryStore:
+    if db_path != "postgresql://mem0-postgres-store":
+        raise ValueError("Set history_db_path='postgresql://mem0-postgres-store'")
+    return PostgresHistoryStore(installed_database())
+
+
+def _check_compatibility() -> None:
+    if importlib.metadata.version("mem0ai") != "2.2.1":
+        raise CompatibilityError("This integration requires exactly mem0ai==2.2.1")
+    for name, expected in _FINGERPRINTS.items():
+        module = importlib.import_module(name)
+        source = inspect.getsourcefile(module)
+        if (
+            source is None
+            or hashlib.sha256(Path(source).read_bytes().rstrip()).hexdigest() != expected
+        ):
+            raise CompatibilityError(f"Unaudited Mem0 source: {name}; review before upgrading")
+
+
+def install(database: Database) -> None:
+    """Call once at process startup, before any Memory/AsyncMemory instances exist.
+
+    Repeated calls with the same Database are harmless. A different Database may
+    replace the installed one only after that one is closed (for example, repeated
+    application lifespans in one test process); rebinding an open Database is rejected.
+    SDK instances created against a closed Database keep failing closed.
+    """
+    global _database
+    with _LOCK:
+        _check_compatibility()
+        from mem0.memory import main, storage
+        from mem0.utils.factory import VectorStoreFactory
+
+        database.check_open()
+        if main.MEM0_TELEMETRY:
+            raise CompatibilityError("Set MEM0_TELEMETRY=false before importing Mem0")
+        if _database is not None:
+            if (
+                (_database is not database and not _database.closed)
+                or main.SQLiteManager is not _history_factory
+                or VectorStoreFactory.provider_to_class.get("pgvector") != _PROVIDER
+                or main.concurrent is not _concurrent
+            ):
+                raise CompatibilityError("Already installed with a different database or bindings")
+            _database = database
+            return
+        if (
+            main.SQLiteManager is not storage.SQLiteManager
+            or VectorStoreFactory.provider_to_class.get("pgvector")
+            != "mem0.vector_stores.pgvector.PGVector"
+            or main.concurrent is not concurrent
+        ):
+            raise CompatibilityError("Another integration has already patched Mem0")
+        _database = database
+        main.SQLiteManager = _history_factory
+        VectorStoreFactory.provider_to_class["pgvector"] = _PROVIDER
+        main.concurrent = _concurrent
+
+
+def database_vector_config(database: Database) -> dict[str, Any]:
+    """Vector config shared by Memory and AsyncMemory; credentials stay in Database."""
+    return {
+        "provider": "pgvector",
+        "config": {
+            "collection_name": "mem0_vectors",
+            "embedding_model_dims": database.embedding_dimensions,
+            "connection_string": "postgresql://mem0-postgres-store",
+            "hnsw": False,
+        },
+    }

mem0_postgres_store/migrate.py

@@ -0,0 +1,35 @@
+"""uv run python -m mem0_postgres_store.migrate --dimensions 1536"""
+
+import argparse
+import os
+
+from alembic import command
+from alembic.config import Config
+
+
+def migration_config(url: str, *, dimensions: int, runtime_role: str) -> Config:
+    config = Config()
+    config.set_main_option("script_location", "mem0_postgres_store:migrations")
+    config.attributes["url"] = url
+    config.cmd_opts = argparse.Namespace(
+        x=[
+            f"dimensions={dimensions}",
+            f"runtime_role={runtime_role}",
+        ]
+    )
+    return config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Apply packaged Alembic migrations")
+    parser.add_argument("--dimensions", type=int, required=True)
+    parser.add_argument("--runtime-role", default="mem0_runtime")
+    args = parser.parse_args()
+    url = os.environ["MEM0_MIGRATION_URL"]
+    command.upgrade(
+        migration_config(url, dimensions=args.dimensions, runtime_role=args.runtime_role), "head"
+    )
+
+
+if __name__ == "__main__":
+    main()

mem0_postgres_store/migrations/env.py

@@ -0,0 +1,27 @@
+"""Migration credentials come only from the Alembic composition boundary."""
+
+from alembic import context
+from sqlalchemy import create_engine, pool
+
+
+def run() -> None:
+    config = context.config
+    url = config.attributes.get("url") or config.get_main_option("sqlalchemy.url")
+    if not url:
+        raise ValueError("Pass migration URL through Config.attributes['url'] or sqlalchemy.url")
+    if context.is_offline_mode():
+        context.configure(url=url, literal_binds=True)
+        with context.begin_transaction():
+            context.run_migrations()
+        return
+    engine = create_engine(url, poolclass=pool.NullPool)
+    try:
+        with engine.connect() as connection:
+            context.configure(connection=connection)
+            with context.begin_transaction():
+                context.run_migrations()
+    finally:
+        engine.dispose()
+
+
+run()

mem0_postgres_store/migrations/versions/0001_storage.py

@@ -0,0 +1,88 @@
+"""Tenant-isolated history, extraction context, vectors and entity vectors."""
+
+from typing import Any
+
+import sqlalchemy as sa
+from alembic import context, op
+
+revision = "0001"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    args: dict[str, Any] = context.get_x_argument(as_dictionary=True)
+    dimensions = int(args.get("dimensions", 1536))
+    runtime_role = args.get("runtime_role", "mem0_runtime")
+    if not 1 <= dimensions <= 16000:
+        raise ValueError("dimensions must be between 1 and 16000")
+    quote = op.get_bind().dialect.identifier_preparer.quote_identifier
+    role = quote(runtime_role)
+    # The DBA must install the vector extension before migrations.
+    op.execute("CREATE SCHEMA mem0_store")
+    op.execute("REVOKE ALL ON SCHEMA mem0_store FROM PUBLIC")
+    op.execute(f"GRANT USAGE ON SCHEMA mem0_store TO {role}")
+    op.execute("""
+        CREATE TABLE mem0_store.history (
+            sequence BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            tenant_id TEXT NOT NULL CHECK (tenant_id <> ''),
+            id TEXT NOT NULL,
+            memory_id TEXT, old_memory TEXT, new_memory TEXT, event TEXT,
+            created_at TEXT, updated_at TEXT, updated_order TIMESTAMPTZ,
+            is_deleted INTEGER, actor_id TEXT, role TEXT,
+            UNIQUE (tenant_id, id)
+        )
+    """)
+    op.execute("""
+        CREATE INDEX history_tenant_memory_order ON mem0_store.history
+        (tenant_id, memory_id, created_at COLLATE "C", updated_order, sequence)
+    """)
+    op.execute("""
+        CREATE TABLE mem0_store.messages (
+            sequence BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            tenant_id TEXT NOT NULL CHECK (tenant_id <> ''),
+            id TEXT NOT NULL, session_scope TEXT, role TEXT, content TEXT, name TEXT,
+            created_at TEXT, UNIQUE (tenant_id, id)
+        )
+    """)
+    op.execute("""
+        CREATE INDEX messages_tenant_scope_order ON mem0_store.messages
+        (tenant_id, session_scope, created_at DESC, sequence DESC)
+    """)
+    for table in ("mem0_vectors", "mem0_vectors_entities"):
+        op.execute(f"""
+            CREATE TABLE mem0_store.{table} (
+                tenant_id TEXT NOT NULL
+                    DEFAULT nullif(current_setting('app.tenant_id', true), '')
+                    CHECK (tenant_id <> ''),
+                id UUID NOT NULL,
+                vector public.vector({dimensions}),
+                payload JSONB,
+                PRIMARY KEY (tenant_id, id)
+            )
+        """)
+        op.execute(f"""
+            CREATE INDEX {table}_text_idx ON mem0_store.{table}
+            USING gin(to_tsvector('simple', payload->>'text_lemmatized'))
+        """)
+    for table in ("history", "messages", "mem0_vectors", "mem0_vectors_entities"):
+        qualified = f"mem0_store.{table}"
+        op.execute(f"ALTER TABLE {qualified} ENABLE ROW LEVEL SECURITY")
+        op.execute(f"ALTER TABLE {qualified} FORCE ROW LEVEL SECURITY")
+        # A restrictive guard prevents a later permissive policy widening tenancy.
+        for name, mode in (("tenant_access", "PERMISSIVE"), ("tenant_guard", "RESTRICTIVE")):
+            op.execute(f"""
+                CREATE POLICY {name} ON {qualified} AS {mode} FOR ALL TO PUBLIC
+                USING (tenant_id = nullif(current_setting('app.tenant_id', true), ''))
+                WITH CHECK (tenant_id = nullif(current_setting('app.tenant_id', true), ''))
+            """)
+        op.execute(f"REVOKE ALL ON {qualified} FROM PUBLIC")
+        op.execute(f"GRANT SELECT, INSERT, UPDATE, DELETE ON {qualified} TO {role}")
+    op.execute(f"GRANT USAGE ON ALL SEQUENCES IN SCHEMA mem0_store TO {role}")
+
+
+def downgrade() -> None:
+    for table in ("mem0_vectors_entities", "mem0_vectors", "messages", "history"):
+        op.drop_table(table, schema="mem0_store")
+    op.execute(sa.text("DROP SCHEMA mem0_store"))