98 lines
3.4 KiB
Python
98 lines
3.4 KiB
Python
"""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)
|