adi-super-memory 0.3.0__py3-none-any.whl

adi_super_memory/__init__.py

@@ -0,0 +1 @@
+from .core import SuperMemory\nfrom .policy import MemoryPolicy\n

adi_super_memory/adapters/__init__.py

@@ -0,0 +1 @@
+from .langchain import LangChainMemoryAdapter\n

adi_super_memory/adapters/langchain.py

@@ -0,0 +1,9 @@
+class LangChainMemoryAdapter:
+    def __init__(self, super_memory, key: str = "history"):
+        self.mem=super_memory; self.key=key
+    @property
+    def memory_variables(self): return [self.key]
+    def load_memory_variables(self, inputs): return {self.key: self.mem.stm.messages()}
+    def save_context(self, inputs, outputs):
+        self.mem.stm.add("user", str(inputs))
+        self.mem.stm.add("assistant", str(outputs))

adi_super_memory/backends.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Iterable, List, Optional, Tuple
+import threading
+from .types import MemoryItem
+
+class Backend(ABC):
+    @abstractmethod
+    def upsert(self, item: MemoryItem, embedding: List[float]) -> None: ...
+    @abstractmethod
+    def iter_items(self, tenant: str, kinds: Optional[List[str]] = None) -> Iterable[Tuple[MemoryItem, List[float]]]: ...
+
+class InMemoryBackend(Backend):
+    def __init__(self):
+        self._lock = threading.RLock()
+        self._store: Dict[str, Tuple[MemoryItem, List[float]]] = {}
+
+    def upsert(self, item: MemoryItem, embedding: List[float]) -> None:
+        with self._lock:
+            self._store[item.id] = (item, embedding)
+
+    def iter_items(self, tenant: str, kinds: Optional[List[str]] = None):
+        with self._lock:
+            for item, emb in self._store.values():
+                if item.tenant != tenant: continue
+                if kinds and item.kind not in kinds: continue
+                yield item, emb

adi_super_memory/core.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone, timedelta
+from typing import Dict, List, Optional
+import uuid, hashlib, json
+
+from .stm import MessageSTM
+from .policy import MemoryPolicy
+from .embeddings import HashEmbeddingProvider, EmbeddingProvider
+from .backends import Backend, InMemoryBackend
+from .types import MemoryItem
+from .retrieval import cosine, recency_weight
+from .distillers import Distiller, DeterministicDistiller
+from .safety.modes import EnterpriseSafetyMode, SafetyMode
+
+@dataclass
+class SuperMemory:
+    backend: Backend = InMemoryBackend()
+    policy: MemoryPolicy = MemoryPolicy.default()
+    embedder: EmbeddingProvider = HashEmbeddingProvider()
+    tenant: str = "default"
+    safety: SafetyMode = EnterpriseSafetyMode.default()
+
+    def __post_init__(self):
+        self.stm = MessageSTM()
+        self._distiller: Distiller = DeterministicDistiller()
+        self._audit_last = "0"*64
+        self._items: Dict[str, MemoryItem] = {}
+        self._emb: Dict[str, List[float]] = {}
+
+    def set_distiller(self, distiller: Distiller):
+        self._distiller = distiller
+
+    def _audit(self, action: str, item_id: str):
+        body = json.dumps({"t": self.tenant, "a": action, "id": item_id, "prev": self._audit_last}, sort_keys=True).encode("utf-8")
+        self._audit_last = hashlib.sha256(body).hexdigest()
+
+    def audit_last_hash(self) -> str:
+        return self._audit_last
+
+    def add_event(self, actor: str, subkind: str, text: str, tags: Optional[List[str]] = None, score: float = 0.0):
+        return self._add("event", actor, subkind.capitalize(), text, tags or [], score, {"subkind": subkind})
+
+    def add_knowledge(self, namespace: str, title: str, content: str, tags: Optional[List[str]] = None):
+        return self._add("knowledge", "system", title, content, tags or [], 0.0, {"namespace": namespace})
+
+    def add_super(self, title: str, text: str, tags: Optional[List[str]] = None, score: float = 0.0):
+        return self._add("super", "system", title, text, tags or [], score, {})
+
+    def _add(self, kind: str, actor: str, title: str, text: str, tags: List[str], score: float, md: Dict[str,str]):
+        now = datetime.now(timezone.utc)
+        title = self.safety.redaction(title)
+        text = self.safety.redaction(text)
+        item = MemoryItem(id=str(uuid.uuid4()), created_at=now, kind=kind, actor=actor, title=title, text=text, tags=tags, metadata=md, score=float(score), tenant=self.tenant)
+        emb = self.embedder.embed([title + "\n" + text + "\n" + " ".join(tags)])[0]
+        self.backend.upsert(item, emb)
+        self._audit(f"upsert:{kind}", item.id)
+        return item
+
+    def recall(self, query: str, top_k: int = 8, kinds: Optional[List[str]] = None):
+        kinds = kinds or ["event","knowledge","super"]
+        qemb = self.embedder.embed([query])[0]
+        scored=[]
+        for item, emb in self.backend.iter_items(self.tenant, kinds=kinds):
+            sim = cosine(qemb, emb)
+            rec = recency_weight(item.created_at, self.policy.recency_half_life_days)
+            scored.append((0.7*sim+0.2*rec+0.1*float(item.score), item))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [i for _, i in scored[:top_k]]
+
+    def distill(self, window_days: int = 30):
+        cutoff = datetime.now(timezone.utc) - timedelta(days=window_days)
+        events=[]
+        for item, _ in self.backend.iter_items(self.tenant, kinds=["event"]):
+            if item.created_at >= cutoff and (item.score >= self.policy.distill_min_score or item.metadata.get("subkind") == "outcome"):
+                events.append(item)
+        distilled = self._distiller.distill(events)
+        created=[]
+        for d in distilled:
+            created.append(self.add_super(d.get("title","Wisdom"), d.get("text",""), [d.get("tag","wisdom")], float(d.get("avg_score",0) or 0.0)).id)
+        return {"source_events": len(events), "created_super_memories": len(created), "super_memory_ids": created}

adi_super_memory/distillers.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List
+from .types import MemoryItem
+
+class Distiller(ABC):
+    @abstractmethod
+    def distill(self, events: List[MemoryItem]) -> List[Dict[str,str]]: ...
+
+class DeterministicDistiller(Distiller):
+    def distill(self, events: List[MemoryItem]) -> List[Dict[str,str]]:
+        by_tag = {}
+        for e in events:
+            for t in (e.tags or ["untagged"]):
+                by_tag.setdefault(t, []).append(e)
+        out=[]
+        for tag, items in by_tag.items():
+            avg = sum(float(x.score) for x in items)/max(len(items),1)
+            out.append({"title": f"Wisdom: {tag}", "text": f"avg_score={avg:.2f} over {len(items)} events", "tag": tag, "avg_score": f"{avg:.3f}", "examples": ""})
+        return out
+
+class OpenAIChatDistiller(Distiller):
+    def __init__(self, model: str = "gpt-4.1-mini", api_key=None):
+        self.model=model; self.api_key=api_key
+    def distill(self, events: List[MemoryItem]) -> List[Dict[str,str]]:
+        try:
+            from openai import OpenAI
+        except Exception as e:
+            raise RuntimeError("Install OpenAI extras: pip install 'adi-super-memory[llm]'") from e
+        client = OpenAI(api_key=self.api_key)
+        lines=[f"- score={e.score:.2f} tags={','.join(e.tags)}: {e.text[:200]}" for e in events[:80]]
+        prompt="Return JSON array of heuristics (title,text,tag,avg_score,examples).\nEVENTS:\n" + "\n".join(lines)
+        resp = client.chat.completions.create(model=self.model, messages=[{"role":"user","content":prompt}], temperature=0.2)
+        import json as _json
+        content = resp.choices[0].message.content or "[]"
+        try:
+            data = _json.loads(content)
+            return data if isinstance(data, list) else []
+        except Exception:
+            return [{"title":"Wisdom: distilled","text":content[:1500],"tag":"distilled","avg_score":"0.0","examples":""}]

adi_super_memory/embeddings.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import List
+import hashlib, math
+
+class EmbeddingProvider(ABC):
+    @property
+    @abstractmethod
+    def dim(self) -> int: ...
+    @abstractmethod
+    def embed(self, texts: List[str]) -> List[List[float]]: ...
+
+class HashEmbeddingProvider(EmbeddingProvider):
+    def __init__(self, dim: int = 256): self._dim = dim
+    @property
+    def dim(self) -> int: return self._dim
+    def _one(self, text: str) -> List[float]:
+        b = text.encode("utf-8", errors="ignore")
+        seed = hashlib.sha256(b).digest()
+        out = b""; cur = seed
+        while len(out) < self._dim:
+            cur = hashlib.sha256(cur + seed).digest()
+            out += cur
+        v = [((out[i]-128)/128.0) for i in range(self._dim)]
+        n = math.sqrt(sum(x*x for x in v)) or 1.0
+        return [x/n for x in v]
+    def embed(self, texts: List[str]) -> List[List[float]]:
+        return [self._one(t) for t in texts]

adi_super_memory/policy.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Callable, Optional
+
+RedactionFn = Callable[[str], str]
+
+@dataclass(frozen=True)
+class MemoryPolicy:
+    episodic_ttl: Optional[timedelta] = timedelta(days=30)
+    recency_half_life_days: float = 14.0
+    distill_min_score: float = 0.6
+    redaction: Optional[RedactionFn] = None
+
+    @staticmethod
+    def default() -> "MemoryPolicy":
+        return MemoryPolicy()

adi_super_memory/retrieval.py

@@ -0,0 +1,17 @@
+from datetime import datetime, timezone
+from typing import List
+import math
+
+def cosine(a: List[float], b: List[float]) -> float:
+    dot=na=nb=0.0
+    for x,y in zip(a,b):
+        dot += x*y; na += x*x; nb += y*y
+    d = math.sqrt(na)*math.sqrt(nb)
+    return (dot/d) if d else 0.0
+
+def recency_weight(created_at: datetime, half_life_days: float) -> float:
+    now = datetime.now(timezone.utc)
+    if created_at.tzinfo is None:
+        created_at = created_at.replace(tzinfo=timezone.utc)
+    age_days = max((now-created_at).total_seconds(),0.0)/86400.0
+    return math.pow(0.5, age_days/half_life_days) if half_life_days>0 else 1.0

adi_super_memory/robotics/__init__.py

@@ -0,0 +1 @@
+from .runtime import RealTimePolicy\n

adi_super_memory/robotics/runtime.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+@dataclass(frozen=True)
+class RealTimePolicy:
+    max_plan_latency_ms: int = 50
+    max_action_latency_ms: int = 20
+    fail_closed: bool = True

adi_super_memory/safety/__init__.py

@@ -0,0 +1,2 @@
+from .modes import EnterpriseSafetyMode, GovernmentSafetyMode
+from .redaction import default_redactor

adi_super_memory/safety/modes.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from .redaction import default_redactor
+
+@dataclass(frozen=True)
+class SafetyMode:
+    name: str
+    redaction: callable
+    allow_external_network: bool
+    allow_cloud_models: bool
+    require_signed_audit: bool
+
+@dataclass(frozen=True)
+class EnterpriseSafetyMode(SafetyMode):
+    @staticmethod
+    def default():
+        return EnterpriseSafetyMode("enterprise", default_redactor, True, True, True)
+
+@dataclass(frozen=True)
+class GovernmentSafetyMode(SafetyMode):
+    @staticmethod
+    def default():
+        return GovernmentSafetyMode("government", default_redactor, False, False, True)

adi_super_memory/safety/redaction.py

@@ -0,0 +1,7 @@
+import re
+_P=[(re.compile(r"\b\d{3}-\d{2}-\d{4}\b"),"[REDACTED_SSN]"),
+    (re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"),"[REDACTED_EMAIL]")]
+def default_redactor(text: str) -> str:
+    out=text
+    for p,r in _P: out=p.sub(r,out)
+    return out

adi_super_memory/stm.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+import threading
+
+@dataclass
+class MessageSTM:
+    _kv: Dict[str, Any] = field(default_factory=dict)
+    _messages: List[Dict[str, str]] = field(default_factory=list)
+    _lock: threading.RLock = field(default_factory=threading.RLock)
+
+    def set(self, key: str, value: Any) -> None:
+        with self._lock: self._kv[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        with self._lock: return self._kv.get(key, default)
+
+    def add(self, role: str, content: str) -> None:
+        with self._lock: self._messages.append({"role": role, "content": content})
+
+    def messages(self, limit: int = 50) -> List[Dict[str, str]]:
+        with self._lock: return list(self._messages[-limit:])

adi_super_memory/types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List
+
+@dataclass(frozen=True)
+class MemoryItem:
+    id: str
+    created_at: datetime
+    kind: str
+    actor: str
+    title: str
+    text: str
+    tags: List[str] = field(default_factory=list)
+    metadata: Dict[str,str] = field(default_factory=dict)
+    score: float = 0.0
+    tenant: str = "default"

adi_super_memory-0.3.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: adi-super-memory
+Version: 0.3.0
+Summary: ADI Super Memory: STM + LTM + distilled Super Memory with adapters and safety modes.
+Author: Adi's American Soft LLC
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0; python_version >= "3.9"
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == "server"
+Requires-Dist: uvicorn>=0.23; extra == "server"
+Provides-Extra: llm
+Requires-Dist: openai>=1.0.0; extra == "llm"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# adi-super-memory v0.3 (PyPI-ready)\n

adi_super_memory-0.3.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+adi_super_memory/__init__.py,sha256=lGC9AL8vmW7GzrEb83eeEXm8p0v2gBK7iDNZygRsMko,65
+adi_super_memory/backends.py,sha256=iplPvVfx67IDp8RsXBHOi3vGAA6DmGIogd_ER9RUTMg,1010
+adi_super_memory/core.py,sha256=iyOK3bLgzhLY3DvHy7Ypow0a9U7BRezRmXpl6_hpaZs,4003
+adi_super_memory/distillers.py,sha256=sW_DAJjG9L_K47EwjVHita49SwtiBsqoBzvaQzBuxCo,1927
+adi_super_memory/embeddings.py,sha256=96OQaldgeOY3UUFvMfseebTjaI2o8CXuSUioqvwZvJg,951
+adi_super_memory/policy.py,sha256=NxVXwxvpftJKvpP0UNhuDH6LF_z2KN1EvGgqtM_Wnk4,449
+adi_super_memory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adi_super_memory/retrieval.py,sha256=riy6Y2xML294fsZb21-vrpOPRClWugjPgRuWQRtpj2g,634
+adi_super_memory/stm.py,sha256=5xNYtAddsDkoyPhTemaWSHJQdHWZMXNnNK6grtHZZcw,789
+adi_super_memory/types.py,sha256=BH6iwnBpPZgbz4rV-YArlrajAzezWZpxJT6wJOEB5AE,398
+adi_super_memory/adapters/__init__.py,sha256=ppoqcdxFAikKxRmIcxapkNwsent6pKbI9LethDSLbh8,47
+adi_super_memory/adapters/langchain.py,sha256=Y4wlpv69zqfj6N_RD1UxcSCJjd15z3A1MDpSoH-MyNk,429
+adi_super_memory/robotics/__init__.py,sha256=EOMHWilw1ZuQwmTN1yvX7fYpQbkW_ZOBSiMECC7souM,37
+adi_super_memory/robotics/runtime.py,sha256=KY7PNre9Tw3EpQK2sqT942ZQw071Wakw-rZgRy0EdGM,179
+adi_super_memory/safety/__init__.py,sha256=ILKFalih5cUX0FohFH412nUgBydloOBtyOWmfc5Wp4Q,102
+adi_super_memory/safety/modes.py,sha256=uKa29ihC_d-WpW2d03coF3lq_c0HuUEexvYJG8vTXnk,626
+adi_super_memory/safety/redaction.py,sha256=vtBrXkr4wohrfyytfipEyRfjGBIxDEdSPeneldzxLZI,267
+adi_super_memory-0.3.0.dist-info/METADATA,sha256=IB_g23hxsiUSZvD5_BwAsoshOgJG6zWffxB5xGrlI8c,715
+adi_super_memory-0.3.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+adi_super_memory-0.3.0.dist-info/top_level.txt,sha256=6n6xha3RX2TEyVBrdWp959fyizdkEULt677xSL4lZOw,17
+adi_super_memory-0.3.0.dist-info/RECORD,,

adi_super_memory-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

adi_super_memory-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+adi_super_memory