chore: update memory management with namespace support

- Bump version to 2.1.7.
- Introduce memory namespace handling across memory store, router, and tools for better organization.
- Update Redis memory store to support namespaces.
- Modify agent and worker nodes to utilize project-specific memory namespaces.
- Enhance memory tools to respect namespaces during memory operations.

Author: rithulkamesh

devsper/agents/agent.py

@@ -379,12 +379,14 @@ def __init__(
         message_bus=None,
         audit_logger=None,
         audit_run_id: str = "",
+        memory_namespace: str | None = None,
     ):
         self.model_name = model_name
         self.event_log = event_log or EventLog()
         self.use_tools = use_tools
         self.max_tool_iterations = max_tool_iterations
         self.memory_router = memory_router
+        self.memory_namespace = memory_namespace
         self.store_result_to_memory = store_result_to_memory
         self.reasoning_store = reasoning_store
         self.user_task = user_task
@@ -397,8 +399,14 @@ def __init__(
     def run(self, request: AgentRequest) -> AgentResponse:
         """Stateless run: all context in AgentRequest, all output in AgentResponse."""
         import time
+        from devsper.memory.context import attach_memory_context, detach_memory_context
+
         t0 = time.perf_counter()
         task_id = request.task.id
+        ctx = attach_memory_context(
+            getattr(self.memory_router, "store", None) if self.memory_router else None,
+            self.memory_namespace,
+        )
         try:
             self._emit(events.AGENT_STARTED, {"task_id": task_id})
             self._emit(events.TASK_STARTED, {"task_id": task_id})
@@ -503,6 +511,8 @@ def run(self, request: AgentRequest) -> AgentResponse:
                 error=str(e),
                 success=False,
             )
+        finally:
+            detach_memory_context(ctx)
 
     def build_request(
         self,
@@ -690,7 +700,7 @@ def _store_result_to_memory(self, task: Task, text: str) -> None:
         index = getattr(self.memory_router, "index", None)
         if isinstance(index, MemoryIndex):
             record = index.ensure_embedding(record)
-        store.store(record)
+        store.store(record, namespace=self.memory_namespace)
 
     def _run_with_tools_for_request(
         self,

devsper/memory/context.py

@@ -0,0 +1,36 @@
+"""Process/async context for memory store + namespace (tools + agent execution)."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+_current_store: ContextVar[object | None] = ContextVar("devsper_memory_store", default=None)
+_current_namespace: ContextVar[str | None] = ContextVar("devsper_memory_namespace", default=None)
+
+
+def attach_memory_context(store: object | None, namespace: str | None) -> tuple[Token[object | None], Token[str | None]]:
+    return (_current_store.set(store), _current_namespace.set(namespace))
+
+
+def detach_memory_context(tokens: tuple[Token[object | None], Token[str | None]]) -> None:
+    _current_store.reset(tokens[0])
+    _current_namespace.reset(tokens[1])
+
+
+def get_effective_memory_store():
+    """Prefer agent/router store when set; else process default SQLite store."""
+    s = _current_store.get()
+    if s is not None:
+        return s
+    from devsper.memory.memory_store import get_default_store
+
+    return get_default_store()
+
+
+def get_effective_memory_namespace() -> str | None:
+    """Active namespace for tool memory ops (None = legacy global/run default)."""
+    return _current_namespace.get()

devsper/memory/memory_index.py

@@ -33,6 +33,7 @@ def query_memory(
         top_k: int = 5,
         min_similarity: float = 0.0,
         include_archived: bool = False,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
         """
         Semantic search: embed query, score against stored records with embeddings,
@@ -41,7 +42,9 @@ def query_memory(
         Use min_similarity > 0 (e.g. 0.45) to avoid injecting barely-related memory.
         By default excludes archived records (consolidation).
         """
-        records = self.store.list_memory(limit=500, include_archived=include_archived)
+        records = self.store.list_memory(
+            limit=500, include_archived=include_archived, namespace=namespace
+        )
         if not records:
             return []
         query_emb = embed_text(text)
@@ -64,6 +67,7 @@ def query_across_runs(
         min_similarity: float = 0.0,
         run_id_filter: str | None = None,
         include_archived: bool = False,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
         """
         v1.8: Same as query_memory but over more records (all runs), optional run_id filter.
@@ -73,6 +77,7 @@ def query_across_runs(
             limit=2000,
             include_archived=include_archived,
             run_id_filter=run_id_filter,
+            namespace=namespace,
         )
         if not records:
             return []

devsper/memory/memory_router.py

@@ -20,11 +20,13 @@ def __init__(
         index: MemoryIndex | None = None,
         top_k: int = 10,
         min_similarity: float = 0.55,
+        default_namespace: str | None = None,
     ) -> None:
         self.store = store or MemoryStore()
         self.index = index or MemoryIndex(self.store)
         self.top_k = top_k
         self.min_similarity = min_similarity
+        self.default_namespace = default_namespace
 
     def get_relevant_memory(self, task: str) -> list[MemoryRecord]:
         """
@@ -35,6 +37,7 @@ def get_relevant_memory(self, task: str) -> list[MemoryRecord]:
             task,
             top_k=self.top_k,
             min_similarity=self.min_similarity,
+            namespace=self.default_namespace,
         )
 
     def get_memory_context(self, task: str) -> str:
@@ -44,7 +47,9 @@ def get_memory_context(self, task: str) -> str:
         Empty if no memories meet the relevance threshold.
         """
         lines = []
-        inject_records = self.store.list_memory(tag_contains="user_injection", limit=10)
+        inject_records = self.store.list_memory(
+            tag_contains="user_injection", limit=10, namespace=self.default_namespace
+        )
         if inject_records:
             lines.append("USER INJECTIONS (high priority):")
             for r in inject_records:

devsper/memory/memory_store.py

@@ -20,6 +20,13 @@ def _default_db_path() -> str:
     return os.path.join(base, "memory.db")
 
 
+def _norm_namespace(namespace: str | None) -> str:
+    """SQLite partition key; empty string means legacy default (same as namespace=None)."""
+    if namespace is None or namespace == "":
+        return ""
+    return namespace
+
+
 class MemoryStore:
     """Local persistent store for memory records. Uses SQLite."""
 
@@ -60,8 +67,17 @@ def _init_schema(self) -> None:
                 conn.execute("ALTER TABLE memory ADD COLUMN archived INTEGER DEFAULT 0")
             except sqlite3.OperationalError:
                 pass
+            try:
+                conn.execute(
+                    "ALTER TABLE memory ADD COLUMN namespace TEXT NOT NULL DEFAULT ''"
+                )
+            except sqlite3.OperationalError:
+                pass
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS ix_memory_namespace ON memory(namespace)"
+            )
 
-    def store(self, record: MemoryRecord) -> str:
+    def store(self, record: MemoryRecord, namespace: str | None = None) -> str:
         """Store a memory record. Returns record id. Redacts PII if compliance.pii_redaction enabled."""
         content = record.content
         try:
@@ -84,12 +100,13 @@ def store(self, record: MemoryRecord) -> str:
         embedding_json = json.dumps(emb) if emb is not None else None
         archived = row.get("archived", 0)
         run_id = row.get("run_id", "") or ""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.execute(
                 """
                 INSERT OR REPLACE INTO memory
-                (memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                (memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived, namespace)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     row["memory_id"],
@@ -101,27 +118,39 @@ def store(self, record: MemoryRecord) -> str:
                     embedding_json,
                     run_id,
                     archived,
+                    ns,
                 ),
             )
         return row["memory_id"]
 
-    def retrieve(self, memory_id: str) -> MemoryRecord | None:
+    def retrieve(self, memory_id: str, namespace: str | None = None) -> MemoryRecord | None:
         """Retrieve a single record by id."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.row_factory = sqlite3.Row
             cur = conn.execute(
-                "SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived FROM memory WHERE memory_id = ?",
-                (memory_id,),
+                """
+                SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding, run_id, archived,
+                       COALESCE(namespace, '') AS namespace
+                FROM memory WHERE memory_id = ? AND COALESCE(namespace, '') = ?
+                """,
+                (memory_id, ns),
             )
             row = cur.fetchone()
         if row is None:
             return None
-        return _row_to_record(dict(row))
+        d = dict(row)
+        d.pop("namespace", None)
+        return _row_to_record(d)
 
-    def delete(self, memory_id: str) -> bool:
+    def delete(self, memory_id: str, namespace: str | None = None) -> bool:
         """Delete a record. Returns True if something was deleted."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
-            cur = conn.execute("DELETE FROM memory WHERE memory_id = ?", (memory_id,))
+            cur = conn.execute(
+                "DELETE FROM memory WHERE memory_id = ? AND COALESCE(namespace, '') = ?",
+                (memory_id, ns),
+            )
             return cur.rowcount > 0
 
     def list_memory(
@@ -132,12 +161,14 @@ def list_memory(
         tag_contains: str | None = None,
         include_archived: bool = False,
         run_id_filter: str | None = None,
+        namespace: str | None = None,
     ) -> list[MemoryRecord]:
-        """List records, optionally filtered by type, tag, archived, run_id, with limit/offset."""
+        """List records, optionally filtered by type, tag, archived, run_id, namespace, with limit/offset."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             conn.row_factory = sqlite3.Row
-            conditions = []
-            params = []
+            conditions = ["COALESCE(namespace, '') = ?"]
+            params: list = [ns]
             if memory_type is not None:
                 conditions.append("memory_type = ?")
                 params.append(memory_type.value)
@@ -149,40 +180,64 @@ def list_memory(
             if run_id_filter is not None:
                 conditions.append("run_id = ?")
                 params.append(run_id_filter)
-            where = (" WHERE " + " AND ".join(conditions)) if conditions else ""
+            where = " WHERE " + " AND ".join(conditions)
             params.extend([limit, offset])
             cur = conn.execute(
                 f"""
                 SELECT memory_id, memory_type, content, tags, timestamp, source_task, embedding,
-                       COALESCE(run_id, '') as run_id, COALESCE(archived, 0) as archived
+                       COALESCE(run_id, '') as run_id, COALESCE(archived, 0) as archived,
+                       COALESCE(namespace, '') as namespace
                 FROM memory{where} ORDER BY timestamp DESC LIMIT ? OFFSET ?
                 """,
                 params,
             )
             rows = cur.fetchall()
-        return [_row_to_record(dict(r)) for r in rows]
+        out = []
+        for r in rows:
+            d = dict(r)
+            d.pop("namespace", None)
+            out.append(_row_to_record(d))
+        return out
 
-    def list_all_ids(self, memory_type: MemoryType | None = None) -> list[str]:
+    def list_all_ids(self, memory_type: MemoryType | None = None, namespace: str | None = None) -> list[str]:
         """List all memory ids (for index sync)."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             if memory_type is not None:
                 cur = conn.execute(
-                    "SELECT memory_id FROM memory WHERE memory_type = ?",
-                    (memory_type.value,),
+                    """
+                    SELECT memory_id FROM memory
+                    WHERE memory_type = ? AND COALESCE(namespace, '') = ?
+                    """,
+                    (memory_type.value, ns),
                 )
             else:
-                cur = conn.execute("SELECT memory_id FROM memory")
+                cur = conn.execute(
+                    "SELECT memory_id FROM memory WHERE COALESCE(namespace, '') = ?",
+                    (ns,),
+                )
             return [r[0] for r in cur.fetchall()]
 
-    def set_archived(self, memory_id: str, archived: bool = True) -> bool:
+    def set_archived(self, memory_id: str, archived: bool = True, namespace: str | None = None) -> bool:
         """v1.8: Mark a record as archived (e.g. after consolidation)."""
+        ns = _norm_namespace(namespace)
         with self._conn() as conn:
             cur = conn.execute(
-                "UPDATE memory SET archived = ? WHERE memory_id = ?",
-                (1 if archived else 0, memory_id),
+                """
+                UPDATE memory SET archived = ?
+                WHERE memory_id = ? AND COALESCE(namespace, '') = ?
+                """,
+                (1 if archived else 0, memory_id, ns),
             )
             return cur.rowcount > 0
 
+    def purge_namespace(self, namespace: str) -> None:
+        """Remove all memory rows for a logical namespace (e.g. when a project is deleted)."""
+        if not namespace or not str(namespace).strip():
+            return
+        with self._conn() as conn:
+            conn.execute("DELETE FROM memory WHERE namespace = ?", (namespace,))
+
 
 def _row_to_record(row: dict) -> MemoryRecord:
     tags_str = row.get("tags") or ""