Initial commit: add .gitignore and README

fusionagi/memory/service.py

@@ -0,0 +1,97 @@
+"""Unified memory service: session, episodic, semantic, vector with tenant isolation."""
+
+from typing import Any
+
+from fusionagi.memory.working import WorkingMemory
+from fusionagi.memory.episodic import EpisodicMemory
+from fusionagi.memory.semantic import SemanticMemory
+
+
+def _scoped_key(tenant_id: str, user_id: str, base: str) -> str:
+    """Scope key by tenant and user."""
+    parts = [tenant_id or "default", user_id or "anonymous", base]
+    return ":".join(parts)
+
+
+class VectorMemory:
+    """
+    Vector memory for embeddings retrieval.
+    Stub implementation; replace with pgvector or Pinecone adapter for production.
+    """
+
+    def __init__(self, max_entries: int = 10000) -> None:
+        self._store: list[dict[str, Any]] = []
+        self._max_entries = max_entries
+
+    def add(self, id: str, embedding: list[float], metadata: dict[str, Any] | None = None) -> None:
+        """Add embedding (stub: stores in-memory)."""
+        if len(self._store) >= self._max_entries:
+            self._store.pop(0)
+        self._store.append({"id": id, "embedding": embedding, "metadata": metadata or {}})
+
+    def search(self, query_embedding: list[float], top_k: int = 10) -> list[dict[str, Any]]:
+        """Search by embedding (stub: returns empty)."""
+        return []
+
+
+class MemoryService:
+    """
+    Unified memory service with tenant isolation.
+    Wraps WorkingMemory (session), EpisodicMemory, SemanticMemory, VectorMemory.
+    """
+
+    def __init__(
+        self,
+        tenant_id: str = "default",
+        user_id: str | None = None,
+    ) -> None:
+        self._tenant_id = tenant_id
+        self._user_id = user_id or "anonymous"
+        self._working = WorkingMemory()
+        self._episodic = EpisodicMemory()
+        self._semantic = SemanticMemory()
+        self._vector = VectorMemory()
+
+    @property
+    def session(self) -> WorkingMemory:
+        """Short-term session memory."""
+        return self._working
+
+    @property
+    def episodic(self) -> EpisodicMemory:
+        """Episodic memory (what happened, decisions, outcomes)."""
+        return self._episodic
+
+    @property
+    def semantic(self) -> SemanticMemory:
+        """Semantic memory (facts, preferences)."""
+        return self._semantic
+
+    @property
+    def vector(self) -> VectorMemory:
+        """Vector memory (embeddings for retrieval)."""
+        return self._vector
+
+    def scope_session(self, session_id: str) -> str:
+        """Return tenant/user scoped session key."""
+        return _scoped_key(self._tenant_id, self._user_id, session_id)
+
+    def get(self, session_id: str, key: str, default: Any = None) -> Any:
+        """Get from session memory (scoped)."""
+        scoped = self.scope_session(session_id)
+        return self._working.get(scoped, key, default)
+
+    def set(self, session_id: str, key: str, value: Any) -> None:
+        """Set in session memory (scoped)."""
+        scoped = self.scope_session(session_id)
+        self._working.set(scoped, key, value)
+
+    def append_episode(self, task_id: str, event: dict[str, Any], event_type: str | None = None) -> int:
+        """Append to episodic memory (with tenant in metadata)."""
+        event = dict(event)
+        meta = event.setdefault("metadata", {})
+        meta = dict(meta) if meta else {}
+        meta["tenant_id"] = self._tenant_id
+        meta["user_id"] = self._user_id
+        event["metadata"] = meta
+        return self._episodic.append(task_id, event, event_type)