prismcortex 0.2.1__py3-none-any.whl

prismcortex/__init__.py

@@ -0,0 +1,40 @@
+"""PrismCortex — deterministic, auditable, self-consolidating memory for AI agents.
+
+    from prismcortex import reference_memory
+    mem = reference_memory()                      # reference adapters + real Gemini
+    mem.digest("My deploy budget is $40k.")
+    mem.recall("What's my deploy budget?").answer
+
+Swap the reference adapters for the real Insight ITS packages (prismlang, prismrag,
+prismresonance, prismlib, Chorus) one port at a time — the engine never changes.
+"""
+from .engine import Memory
+from .factory import reference_memory
+from .models import (
+    Band,
+    DigestOutcome,
+    DigestResult,
+    Edge,
+    GraphVersion,
+    Node,
+    RecallResult,
+    StateDelta,
+    Subgraph,
+)
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "Memory",
+    "reference_memory",
+    "Band",
+    "DigestOutcome",
+    "DigestResult",
+    "RecallResult",
+    "Node",
+    "Edge",
+    "Subgraph",
+    "StateDelta",
+    "GraphVersion",
+    "__version__",
+]

prismcortex/adapters/__init__.py

@@ -0,0 +1,20 @@
+"""Adapters that satisfy the PrismCortex ports."""
+from .reference import (
+    DurableCache,
+    HashingProjector,
+    InMemoryGraphStore,
+    InProcessMesh,
+    InProcessResonance,
+    ListStaging,
+    LocalBlobStore,
+)
+
+__all__ = [
+    "DurableCache",
+    "HashingProjector",
+    "InMemoryGraphStore",
+    "InProcessMesh",
+    "InProcessResonance",
+    "ListStaging",
+    "LocalBlobStore",
+]

prismcortex/adapters/ann.py

@@ -0,0 +1,104 @@
+"""IVF-style ANN retrieval for graphs beyond ~10k nodes (numpy-only, no extra deps)."""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import numpy as np
+
+from .reference import InMemoryGraphStore
+
+
+class AnnGraphStore(InMemoryGraphStore):
+    """In-memory bitemporal store with inverted-file ANN when node count exceeds threshold."""
+
+    def __init__(self, *, tenant_id: str = "default", ivf_threshold: Optional[int] = None, nlist: int = 256, nprobe: int = 16) -> None:
+        super().__init__()
+        self.tenant_id = tenant_id
+        self._ivf_threshold = ivf_threshold or int(os.environ.get("PRISMCORTEX_ANN_THRESHOLD", "5000"))
+        self._nlist = nlist
+        self._nprobe = nprobe
+        self._centroids: Optional[np.ndarray] = None
+        self._inverted: list[list[str]] = []
+        self._ivf_dirty = True
+
+    def _rebuild_ivf(self) -> None:
+        self._ensure_matrix()
+        if self._emb_unit is None or len(self._emb_ids) < self._ivf_threshold:
+            self._centroids = None
+            self._inverted = []
+            self._ivf_dirty = False
+            return
+        n, d = self._emb_unit.shape
+        k = min(self._nlist, max(8, n // 40))
+        rng = np.random.default_rng(42)
+        idx = rng.choice(n, size=k, replace=False)
+        self._centroids = self._emb_unit[idx].copy()
+        # Lloyd-lite: 3 iterations
+        for _ in range(3):
+            sims = self._emb_unit @ self._centroids.T
+            assign = np.argmax(sims, axis=1)
+            for c in range(k):
+                mask = assign == c
+                if mask.any():
+                    self._centroids[c] = self._emb_unit[mask].mean(axis=0)
+                    cn = np.linalg.norm(self._centroids[c]) or 1.0
+                    self._centroids[c] /= cn
+        self._inverted = [[] for _ in range(k)]
+        sims = self._emb_unit @ self._centroids.T
+        assign = np.argmax(sims, axis=1)
+        for i, c in enumerate(assign):
+            self._inverted[int(c)].append(self._emb_ids[i])
+        self._ivf_dirty = False
+
+    def _ensure_matrix(self) -> None:
+        super()._ensure_matrix()
+        if self._matrix_dirty:
+            self._ivf_dirty = True
+
+    def apply(self, delta):
+        v = super().apply(delta)
+        self._ivf_dirty = True
+        return v
+
+    def retrieve(self, embedding: list[float], k: int = 8):
+        if not self._nodes:
+            return super().retrieve(embedding, k)
+        self._ensure_matrix()
+        if self._emb_unit is None:
+            return super().retrieve(embedding, k)
+        if len(self._emb_ids) < self._ivf_threshold:
+            return super().retrieve(embedding, k)
+        if self._ivf_dirty:
+            self._rebuild_ivf()
+        if self._centroids is None:
+            return super().retrieve(embedding, k)
+
+        q = np.asarray(embedding, dtype=np.float32)
+        qn = float(np.linalg.norm(q)) or 1.0
+        q = q / qn
+        csim = self._centroids @ q
+        n = len(self._emb_ids)
+        # Scale probe depth with graph size (more clusters searched at 50k+ nodes).
+        nprobe = min(len(csim), max(self._nprobe, n // 2000))
+        probe = np.argsort(-csim, kind="stable")[:nprobe]
+        candidates: set[str] = set()
+        id_to_row = {nid: i for i, nid in enumerate(self._emb_ids)}
+        for c in probe:
+            for nid in self._inverted[int(c)]:
+                candidates.add(nid)
+        if not candidates:
+            return super().retrieve(embedding, k)
+
+        rows = [id_to_row[nid] for nid in candidates if nid in id_to_row]
+        sims = self._emb_unit[rows] @ q
+        order = np.argsort(-sims, kind="stable")[: min(k, len(rows))]
+        chosen = {self._emb_ids[rows[int(i)]] for i in order}
+
+        edges = [e for e in self._edges.values() if e.is_current and (e.src in chosen or e.dst in chosen)]
+        for e in edges:
+            chosen.add(e.src)
+            chosen.add(e.dst)
+        nodes = [self._nodes[n] for n in chosen if n in self._nodes]
+        from ..models import Subgraph
+        return Subgraph(nodes=nodes, edges=edges)

prismcortex/adapters/prism.py

@@ -0,0 +1,174 @@
+"""Production adapters — the real Insight ITS packages behind the ports.
+
+Import-guarded so the OSS core stays installable without them (`pip install
+prismcortex[prism]`). Each class wraps exactly one package:
+
+  - PrismLangProjector  → prismlang.PrismProjector   (deterministic, CPU-stable vectors)
+  - PrismResonanceAdapter → prismresonance.PrismResonance (wavepacket weight + sleep)
+  - PrismLibCache       → prismlib SQLiteStore        (durable cache-as-failover)
+
+The bitemporal GraphStore stays PrismCortex-owned (the reference store *is* the design
+— prismrag-patch is a retrieval governor, not a bitemporal database, so it slots in as
+a recall-time filter rather than the store itself). The Chorus/prismlib cluster mesh is
+the remaining seam; InProcessMesh stands in until it's wired.
+"""
+from __future__ import annotations
+
+import os
+import time
+from typing import Optional
+
+import numpy as np
+
+
+class PrismLangProjector:
+    """GistProjector via prismlang.PrismProjector.
+
+    project() returns (category_slug, vector, trace). The vector is all-MiniLM-L6-v2
+    JL-reduced with a seed derived from tenant_id — deterministic given a fixed tenant,
+    which is exactly the CPU-stable projection the read-path determinism contract needs.
+    """
+
+    def __init__(self, taxonomy=None, tenant_id: str = "prismcortex", k: int = 128) -> None:
+        # k = projection dimension. PrismLang defaults to 64, which crowds at scale
+        # (retrieval recall drops to ~0.86 at 3k facts); 128 restores it to ~0.97 with no
+        # latency cost. See benchmarks/scale_bench.py.
+        from prismlang import Category, PrismProjector, TaxonomyConfig
+
+        if taxonomy is None:
+            taxonomy = TaxonomyConfig(categories=[
+                Category("general", "General", ["the", "a", "is", "of", "to"]),
+                Category("preference", "Preference", ["like", "prefer", "favorite", "want", "hate"]),
+                Category("fact", "Fact", ["is", "are", "has", "budget", "name", "id", "number"]),
+                Category("tech", "Tech", ["deploy", "database", "server", "region", "api", "model"]),
+            ])
+        self._p = PrismProjector(taxonomy, tenant_id=tenant_id, k=k)
+        _, probe, _ = self._p.project("dimension probe")
+        self.dim = len(probe)
+
+    def embed(self, text: str) -> list[float]:
+        _, vec, _ = self._p.project(text)
+        return [float(x) for x in vec]
+
+    def classify(self, text: str) -> str:
+        cat, _, _ = self._p.project(text)
+        return cat
+
+
+class PrismResonanceAdapter:
+    """ResonanceEngine via prismresonance.PrismResonance (compiles an ONNX graph on
+    first construction; writes a small state db)."""
+
+    def __init__(self, embedding_dim: int, state_path: str = "resonance_state.db", onnx_path: str = "resonance_engine.onnx") -> None:
+        from prismresonance import PrismResonance
+        from prismresonance.frequency import FrequencyFamily
+
+        self._FF = FrequencyFamily
+        self._r = PrismResonance.create(embedding_dim=embedding_dim, state_path=state_path, onnx_path=onnx_path)
+        self._amps: dict[str, np.ndarray] = {}  # kept so reinforce can re-ingest
+
+    def _freq(self, band: str):
+        return getattr(self._FF, band, self._FF.NEUTRAL)
+
+    def ingest(self, chunk_id: str, amplitude: list[float], band: str) -> None:
+        amp = np.asarray(amplitude, dtype=np.float32)
+        if amp.size == 0:
+            return
+        self._amps[chunk_id] = amp
+        self._r.ingest(chunk_id, amp, self._freq(band))
+
+    def reinforce(self, chunk_id: str) -> None:
+        amp = self._amps.get(chunk_id)
+        if amp is not None:  # re-ingest at higher salience ≈ LTP
+            self._r.ingest(chunk_id, amp, self._FF.ALERT)
+
+    def rank(self, candidate_ids: list[str]) -> list[str]:
+        return list(candidate_ids)  # resonance ordering is not on the determinism path
+
+    def consolidate(self) -> None:
+        self._r.sleep()
+
+    def shutdown(self) -> None:
+        try:
+            self._r.shutdown()
+        except Exception:
+            pass
+
+
+class PrismLibCache:
+    """ResponseCache via prismlib SQLiteStore — exact-key, durable (cache-as-failover).
+
+    packet_id carries our content-address; response carries the frozen answer. Durable
+    by file path so a frozen answer survives restart and cache eviction.
+    """
+
+    _TEN_YEARS = 10 * 365 * 24 * 3600
+
+    def __init__(self, db_path: str = ".prismcortex_cache/prismlib.db") -> None:
+        from prism.cache import CacheEntry, SQLiteStore
+
+        os.makedirs(os.path.dirname(db_path) or ".", exist_ok=True)
+        self._CacheEntry = CacheEntry
+        self._db_path = db_path
+        self._store = SQLiteStore(db_path=db_path)
+
+    def get(self, key: str) -> Optional[str]:
+        entry = self._store.load(key)
+        return entry.response if entry else None
+
+    def has(self, key: str) -> bool:
+        return self._store.load(key) is not None
+
+    def put(self, key: str, value: str) -> None:
+        now = time.time()
+        self._store.save(self._CacheEntry(
+            packet_id=key, query_text="", response=value,
+            created_at=now, expires_at=now + self._TEN_YEARS,
+        ))
+
+    def clear(self) -> None:
+        """Drop all cached answers (recreate the store) — used on erasure."""
+        from prism.cache import SQLiteStore
+
+        try:
+            self._store.close()
+        except Exception:  # noqa: BLE001
+            pass
+        if self._db_path != ":memory:" and os.path.exists(self._db_path):
+            os.remove(self._db_path)
+        self._store = SQLiteStore(db_path=self._db_path)
+
+
+def prism_memory(
+    *,
+    model: Optional[str] = None,
+    cache_db: str = ".prismcortex_cache/prismlib.db",
+    tenant_id: str = "prismcortex",
+    resonance_state: str = ".prismcortex_cache/resonance_state.db",
+    resonance_onnx: str = ".prismcortex_cache/resonance_engine.onnx",
+    k: int = 8,
+):
+    """Production-wired Memory: real PrismLang + PrismResonance + PrismLib + Gemini.
+
+    GraphStore + Mesh remain the reference (PrismCortex-owned bitemporal store; mesh is
+    the open Chorus seam). Needs prismcortex[prism], prismcortex[gemini], and a key.
+    """
+    from ..engine import Memory
+    from ..llm.gemini import GeminiClient
+    from .reference import InMemoryGraphStore, InProcessMesh, ListStaging
+
+    projector = PrismLangProjector(tenant_id=tenant_id)
+    resonance = PrismResonanceAdapter(embedding_dim=projector.dim, state_path=resonance_state, onnx_path=resonance_onnx)
+    cache = PrismLibCache(db_path=cache_db)
+    gemini = GeminiClient(model=model)
+    return Memory(
+        projector=projector,
+        extractor=gemini,
+        renderer=gemini,
+        store=InMemoryGraphStore(),
+        resonance=resonance,
+        cache=cache,
+        mesh=InProcessMesh(),
+        staging=ListStaging(),
+        k=k,
+    )