PrismResonance

Biologically-inspired dynamic memory layer for RAG and multi-agent systems.

PrismResonance converts static text embeddings into complex-valued wavepackets (z = A · e^{iφ}) so that retrieval is executed as wave interference rather than geometric distance search. Chunks that share the active system frequency experience constructive interference and surface instantly; out-of-phase chunks are muted by destructive interference — no re-embedding, no coordinate mutation.

Why

Installation

pip install prismresonance           # core: numpy, onnx, onnxruntime

No torch dependency. The ONNX graph is compiled with pure onnx.helper.

Quick start

import numpy as np
from prismresonance import PrismResonance
from prismresonance.frequency import FrequencyFamily as FF

# Create (compiles ONNX graph on first run, persists to state_path)
prism = PrismResonance.create(
    embedding_dim=384,
    onnx_path="resonance_engine.onnx",
    state_path="resonance_state.db",
)

# Ingest a chunk (your encoder produces the amplitude vector)
amplitude = np.random.randn(384).astype(np.float32)
amplitude /= np.linalg.norm(amplitude)
prism.ingest("chunk_001", amplitude, FF.EMERGENCY)

# Query
results = prism.query(
    query_amplitude=amplitude,
    query_phase=FF.EMERGENCY,
    candidate_ids=["chunk_001"],
    candidate_amplitudes=np.stack([amplitude]),
    flat=True,         # skip group scan for small corpora
)
for r in results:
    print(r.chunk_id, r.score)

# Consolidate (run in background or on idle)
prism.sleep()

# Persist
prism.save()
prism.shutdown()

Frequency families

Six named phase bands with π/6 separation:

Architecture

Raw chunk ──► Semantic anchor (amplitude A, immutable)
           ──► Resonance classifier (phase φ, dynamic)
                    │
                    ▼
         ┌──────────────────────┐
         │  ResonanceRegistry   │  ← RAM sidecar (never touches source DB)
         │  · Phase registry    │
         │  · Most-Recent index │
         │  · Most-Related index│
         └──────────┬───────────┘
                    │
                    ▼
         ┌──────────────────────┐
         │  ONNX wave engine    │  ← compiled once, frozen forever
         │  MatMul + Add        │
         │  Coherence Shield    │
         └──────────────────────┘
                    │
                    ▼
            Resonant chunk IDs

The source database is strictly read-only. All mutable state lives in the sidecar registry (RAM) and is flushed to a SQLite file during the sleep cycle.

Sleep cycle

prism.sleep()          # blocking fast-sleep (runs all 4 passes)

Four passes:

1. Temporal decay — fades chunks not accessed recently
2. Synaptic alignment — pulls heavily co-activated chunks into the same frequency family
3. Group vector recomputation — rebuilds group centroids
4. Group merge — collapses very similar groups

For background operation pass auto_sleep=True to PrismResonance.create().

Source adapters

Read your existing vector store without touching it:

from prismresonance.adapters.prismrag import PgvectorSourceAdapter, ChromaSourceAdapter

# pgvector (psycopg2 or psycopg3)
adapter = PgvectorSourceAdapter(dsn="postgresql://...", table="embeddings")

# ChromaDB
adapter = ChromaSourceAdapter(collection=client.get_collection("my_col"))

Development

pip install -e ".[dev]"
python -m pytest tests/ -v

License

MIT — see LICENSE.

© 2026 Amin Parva, Insight IT Solutions LLC