mda-memory 0.1.2__tar.gz → 0.2.0__tar.gz

mda_memory-0.2.0/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: mda-memory
+Version: 0.2.0
+Summary: Online associative memory for LLMs
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: open-webui
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: rich
+Requires-Dist: prompt_toolkit
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: anthropic
+Requires-Dist: ollama
+Requires-Dist: chromadb
+Requires-Dist: sentence-transformers
+Requires-Dist: tqdm
+Requires-Dist: matplotlib
+Requires-Dist: ijson
+Requires-Dist: deep-translator
+Requires-Dist: langdetect
+Dynamic: license-file
+
+# Modular Dynamic Architecture (MDA)
+
+**Online associative memory for LLMs. Learns during inference. No backpropagation.**
+
+[![PyPI](https://img.shields.io/pypi/v/mda-memory.svg)](https://pypi.org/project/mda-memory/)
+[![License: SSPL](https://img.shields.io/badge/License-SSPL-blue.svg)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+---
+
+## What is MDA?
+
+Large language models can reason but cannot remember. RAG partially addresses this but cannot update during a conversation or learn from it.
+
+MDA fills precisely these gaps.
+
+It encodes knowledge as **512-dimensional Holographic Distributed Representations (HDRs)**, connects concepts through a **sparse synapse graph**, and retrieves context by activating entity networks not by text-chunk similarity search. New knowledge is integrated immediately, without rebuilding any index.
+
+**MDA is not a RAG replacement. It is the persistent learning layer that RAG and LLMs are missing.**
+
+![MDA Process](docs/figure1_process.png)
+
+---
+
+## Key Properties
+
+- **Token-free** — no tokenizer, no vocabulary
+- **Attention-free** — no transformer encoder required
+- **Online learning** — learns during inference via the Oja rule
+- **No catastrophic forgetting** — entities are independent; new knowledge never overwrites old
+- **CPU-first** — runs on numpy; GPU acceleration via PyTorch when available
+- **Model-agnostic** — works with Ollama, OpenAI, Anthropic, llama.cpp, or any LLM
+
+---
+
+## Quick Start
+
+```bash
+pip install mda-memory
+```
+
+```python
+from mda.integrations.engine import MDAEngine
+
+engine = MDAEngine(model="qwen3:4b", user_id="demo")
+engine.learn("Solaris Station was founded by Dr. Mira Voss in 2041.")
+
+response = engine.chat("Who founded Solaris?")
+print(response)
+# Dr. Mira Voss founded Solaris Station in 2041.
+```
+
+### CLI
+
+```bash
+mda --model qwen3:4b
+mda --model claude-haiku-4-5-20251001 --provider anthropic
+```
+
+---
+
+## How Memory Works
+
+Each turn, MDA retrieves relevant context from previous turns and injects it into the LLM prompt with confidence scores, inferred connections, and structured events. Memory grows and strengthens across the conversation without any reindexing.
+
+![MDA Example](docs/mda_example.png)
+
+---
+
+## Benchmark Results
+
+![Benchmark](docs/benchmark_chart.png)
+
+Evaluated against a strong RAG baseline (bge-large-en-v1.5 + ChromaDB, top-6 retrieval) across 80 questions spanning 8 cognitive categories:
+
+| Category | RAG | MDA | Δ |
+|---|---|---|---|
+| ATOMIC_RECALL | 100% | 85% | −15% |
+| MULTI_HOP | 90% | 90% | 0% |
+| CROSS_DOCUMENT | 80% | 70% | −10% |
+| REASONING | 70% | 90% | **+20%** |
+| INCREMENTAL_LEARNING | 0% | 60% | **+60%** |
+| NOISE_RESISTANCE | 100% | 100% | 0% |
+| MEMORY_COMPRESSION | 90% | 70% | −20% |
+| BOUNDARY | 100% | 100% | 0% |
+| **OVERALL** | **78.8%** | **83.1%** | **+4.3%** |
+
+MDA uses **3.1× less context per query** than RAG while achieving higher overall accuracy.
+
+**Long-context retention (200 turns):** RAG 0% — MDA 92%.
+
+---
+
+## How It Works
+
+### Entity & W Matrix
+Every concept is an `Entity` with a 512-dim identity vector `v` and a lazy-initialized weight matrix `W` (512×512). `W` is `None` until first activation — memory overhead is proportional to usage.
+
+### Online Learning (Oja Rule)
+```
+ΔW = η(yxᵀ − y²W)
+```
+No backpropagation. No gradient descent. Runs in O(d²) per entity per turn.
+
+### AssociativeChain
+Query → origin entity → BFS synapse traversal (depth 3-6) → context assembly. Dynamic inhibition threshold cached per entity count.
+
+### BrocaModule
+```
+score = 0.35·s_query + 0.45·s_W + 0.20·s_sense
+```
+
+---
+
+## Open WebUI Integration
+
+MDA works as a native Open WebUI Filter Function — zero pipeline server required.
+
+1. Copy `mda/integrations/owui_function.py` contents
+2. Open WebUI → Admin Panel → Functions → "+" → paste → Save
+3. Enable globally
+
+---
+
+## AgentMemory
+
+Tool-call aware memory layer for agentic loops. No LLM call inside — pure memory read/write with typed, step-indexed observations.
+
+```python
+from mda import AgentMemory
+
+agent_mem = AgentMemory()
+
+# After each tool call
+agent_mem.observe("http_get", "status 200 OK", step=1)
+agent_mem.error("payments API /v2/charge returned 410 Gone", step=7)
+agent_mem.decision("using batch mode because rate limit is 100/min", step=12)
+agent_mem.environment("API base URL is https://api.example.com/v3")
+
+# Before next decision
+context = agent_mem.query("payments API")
+# → [ERROR@7] payments API /v2/charge returned 410 Gone
+# → [DECISION@12] using batch mode because rate limit is 100/min
+
+# Detect repeated attempts
+if agent_mem.is_looping("retry charge endpoint"):
+    agent_mem.decision("switching to /v3/charge endpoint", step=15)
+
+# Find related past errors
+related = agent_mem.similar_errors("connection refused")
+
+# Persist & restore across runs
+agent_mem.save()
+agent_mem.load()
+```
+
+Context tags: `[OBSERVE@N tool]`, `[ERROR@N]`, `[DECISION@N]`, `[ENV]`
+
+Checkpoint is written to `.memory/{user_id}/agent_{run_id}.json` relative to the **current working directory** — not the library install path.
+
+---
+
+## Batch Engine
+
+For multi-agent workloads or large context windows:
+
+```python
+from mda.integrations.engine import MDABatchEngine
+
+engine = MDABatchEngine(depth=6, top_k_branches=5)
+contexts = engine.build_context_batch([
+    "legal contract risk analysis",
+    "MDA memory architecture",
+])
+# depth=6 → 15,625 associative paths per query
+```
+
+GPU acceleration activates automatically when PyTorch + CUDA is available.
+
+---
+
+## Roadmap
+
+- [x] GPU acceleration — EntityMatrix matmul, persistent tensor cache
+- [x] 512-dim HDR — higher representation capacity
+- [x] Open WebUI integration — native Filter Function
+- [x] Batch engine — N queries in single GPU pass
+- [x] AgentMemory — tool-call aware step-indexed memory for agentic loops
+- [ ] `mda.cloud` API — persistent memory as a service
+- [ ] MDA + RAG hybrid — offline corpus retrieval + online learning
+- [ ] Low-rank W — W ≈ A×B for higher-dimensional HDRs
+- [ ] Independent benchmark — community-constructed evaluation set
+
+---
+
+## License
+
+[SSPL 1.0](LICENSE) — free for research and personal use. Commercial use requires a separate agreement.
+
+For commercial licensing: mert@kairfy.com

mda_memory-0.2.0/README.md

@@ -0,0 +1,200 @@
+# Modular Dynamic Architecture (MDA)
+
+**Online associative memory for LLMs. Learns during inference. No backpropagation.**
+
+[![PyPI](https://img.shields.io/pypi/v/mda-memory.svg)](https://pypi.org/project/mda-memory/)
+[![License: SSPL](https://img.shields.io/badge/License-SSPL-blue.svg)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+---
+
+## What is MDA?
+
+Large language models can reason but cannot remember. RAG partially addresses this but cannot update during a conversation or learn from it.
+
+MDA fills precisely these gaps.
+
+It encodes knowledge as **512-dimensional Holographic Distributed Representations (HDRs)**, connects concepts through a **sparse synapse graph**, and retrieves context by activating entity networks not by text-chunk similarity search. New knowledge is integrated immediately, without rebuilding any index.
+
+**MDA is not a RAG replacement. It is the persistent learning layer that RAG and LLMs are missing.**
+
+![MDA Process](docs/figure1_process.png)
+
+---
+
+## Key Properties
+
+- **Token-free** — no tokenizer, no vocabulary
+- **Attention-free** — no transformer encoder required
+- **Online learning** — learns during inference via the Oja rule
+- **No catastrophic forgetting** — entities are independent; new knowledge never overwrites old
+- **CPU-first** — runs on numpy; GPU acceleration via PyTorch when available
+- **Model-agnostic** — works with Ollama, OpenAI, Anthropic, llama.cpp, or any LLM
+
+---
+
+## Quick Start
+
+```bash
+pip install mda-memory
+```
+
+```python
+from mda.integrations.engine import MDAEngine
+
+engine = MDAEngine(model="qwen3:4b", user_id="demo")
+engine.learn("Solaris Station was founded by Dr. Mira Voss in 2041.")
+
+response = engine.chat("Who founded Solaris?")
+print(response)
+# Dr. Mira Voss founded Solaris Station in 2041.
+```
+
+### CLI
+
+```bash
+mda --model qwen3:4b
+mda --model claude-haiku-4-5-20251001 --provider anthropic
+```
+
+---
+
+## How Memory Works
+
+Each turn, MDA retrieves relevant context from previous turns and injects it into the LLM prompt with confidence scores, inferred connections, and structured events. Memory grows and strengthens across the conversation without any reindexing.
+
+![MDA Example](docs/mda_example.png)
+
+---
+
+## Benchmark Results
+
+![Benchmark](docs/benchmark_chart.png)
+
+Evaluated against a strong RAG baseline (bge-large-en-v1.5 + ChromaDB, top-6 retrieval) across 80 questions spanning 8 cognitive categories:
+
+| Category | RAG | MDA | Δ |
+|---|---|---|---|
+| ATOMIC_RECALL | 100% | 85% | −15% |
+| MULTI_HOP | 90% | 90% | 0% |
+| CROSS_DOCUMENT | 80% | 70% | −10% |
+| REASONING | 70% | 90% | **+20%** |
+| INCREMENTAL_LEARNING | 0% | 60% | **+60%** |
+| NOISE_RESISTANCE | 100% | 100% | 0% |
+| MEMORY_COMPRESSION | 90% | 70% | −20% |
+| BOUNDARY | 100% | 100% | 0% |
+| **OVERALL** | **78.8%** | **83.1%** | **+4.3%** |
+
+MDA uses **3.1× less context per query** than RAG while achieving higher overall accuracy.
+
+**Long-context retention (200 turns):** RAG 0% — MDA 92%.
+
+---
+
+## How It Works
+
+### Entity & W Matrix
+Every concept is an `Entity` with a 512-dim identity vector `v` and a lazy-initialized weight matrix `W` (512×512). `W` is `None` until first activation — memory overhead is proportional to usage.
+
+### Online Learning (Oja Rule)
+```
+ΔW = η(yxᵀ − y²W)
+```
+No backpropagation. No gradient descent. Runs in O(d²) per entity per turn.
+
+### AssociativeChain
+Query → origin entity → BFS synapse traversal (depth 3-6) → context assembly. Dynamic inhibition threshold cached per entity count.
+
+### BrocaModule
+```
+score = 0.35·s_query + 0.45·s_W + 0.20·s_sense
+```
+
+---
+
+## Open WebUI Integration
+
+MDA works as a native Open WebUI Filter Function — zero pipeline server required.
+
+1. Copy `mda/integrations/owui_function.py` contents
+2. Open WebUI → Admin Panel → Functions → "+" → paste → Save
+3. Enable globally
+
+---
+
+## AgentMemory
+
+Tool-call aware memory layer for agentic loops. No LLM call inside — pure memory read/write with typed, step-indexed observations.
+
+```python
+from mda import AgentMemory
+
+agent_mem = AgentMemory()
+
+# After each tool call
+agent_mem.observe("http_get", "status 200 OK", step=1)
+agent_mem.error("payments API /v2/charge returned 410 Gone", step=7)
+agent_mem.decision("using batch mode because rate limit is 100/min", step=12)
+agent_mem.environment("API base URL is https://api.example.com/v3")
+
+# Before next decision
+context = agent_mem.query("payments API")
+# → [ERROR@7] payments API /v2/charge returned 410 Gone
+# → [DECISION@12] using batch mode because rate limit is 100/min
+
+# Detect repeated attempts
+if agent_mem.is_looping("retry charge endpoint"):
+    agent_mem.decision("switching to /v3/charge endpoint", step=15)
+
+# Find related past errors
+related = agent_mem.similar_errors("connection refused")
+
+# Persist & restore across runs
+agent_mem.save()
+agent_mem.load()
+```
+
+Context tags: `[OBSERVE@N tool]`, `[ERROR@N]`, `[DECISION@N]`, `[ENV]`
+
+Checkpoint is written to `.memory/{user_id}/agent_{run_id}.json` relative to the **current working directory** — not the library install path.
+
+---
+
+## Batch Engine
+
+For multi-agent workloads or large context windows:
+
+```python
+from mda.integrations.engine import MDABatchEngine
+
+engine = MDABatchEngine(depth=6, top_k_branches=5)
+contexts = engine.build_context_batch([
+    "legal contract risk analysis",
+    "MDA memory architecture",
+])
+# depth=6 → 15,625 associative paths per query
+```
+
+GPU acceleration activates automatically when PyTorch + CUDA is available.
+
+---
+
+## Roadmap
+
+- [x] GPU acceleration — EntityMatrix matmul, persistent tensor cache
+- [x] 512-dim HDR — higher representation capacity
+- [x] Open WebUI integration — native Filter Function
+- [x] Batch engine — N queries in single GPU pass
+- [x] AgentMemory — tool-call aware step-indexed memory for agentic loops
+- [ ] `mda.cloud` API — persistent memory as a service
+- [ ] MDA + RAG hybrid — offline corpus retrieval + online learning
+- [ ] Low-rank W — W ≈ A×B for higher-dimensional HDRs
+- [ ] Independent benchmark — community-constructed evaluation set
+
+---
+
+## License
+
+[SSPL 1.0](LICENSE) — free for research and personal use. Commercial use requires a separate agreement.
+
+For commercial licensing: mert@kairfy.com

mda_memory-0.2.0/mda/__init__.py

@@ -0,0 +1,4 @@
+from mda.mda import MDA
+from mda.integrations.agent import AgentMemory
+
+__all__ = ["MDA", "AgentMemory"]

mda_memory-0.2.0/mda/core/accelerator.py

@@ -0,0 +1,154 @@
+"""
+mda/core/accelerator.py — numpy/torch adapter.
+
+All GPU work happens here; everything else in MDA stays numpy-typed at call
+boundaries.  Graceful-fallback pattern: torch is an optional dependency.
+HAS_TORCH / HAS_CUDA / HAS_MPS flags are set at import time and can be
+inspected by callers before dispatching to GPU helpers.
+
+Functions that unconditionally require torch (to_t, to_np, normalize_t,
+cosine_t, fft_bind_t) raise RuntimeError when torch is absent rather than
+producing a confusing NameError.  Batch helpers (batch_cosine, batch_matmul)
+fall back to numpy silently.
+"""
+import numpy as np
+
+try:
+    import torch
+
+    HAS_TORCH = True
+    HAS_CUDA  = torch.cuda.is_available()
+    HAS_MPS   = (
+        getattr(torch.backends, "mps", None) is not None
+        and torch.backends.mps.is_available()
+    )
+
+    if HAS_CUDA:
+        DEVICE = torch.device("cuda")
+    elif HAS_MPS:
+        DEVICE = torch.device("mps")
+    else:
+        DEVICE = torch.device("cpu")
+
+except ImportError:
+    HAS_TORCH = False
+    HAS_CUDA  = False
+    HAS_MPS   = False
+    DEVICE    = None
+
+
+def get_device():
+    """Return the active torch.device, or None if torch is not installed."""
+    return DEVICE
+
+
+def to_t(v: np.ndarray):
+    """np float32 array → contiguous torch.Tensor on DEVICE.
+
+    Raises RuntimeError if torch is not installed.
+    """
+    if not HAS_TORCH:
+        raise RuntimeError("to_t requires torch, which is not installed.")
+    return torch.from_numpy(np.ascontiguousarray(v)).float().to(DEVICE)
+
+
+def to_np(t) -> np.ndarray:
+    """torch.Tensor (any device) → np.float32 ndarray.
+
+    Raises RuntimeError if torch is not installed.
+    """
+    if not HAS_TORCH:
+        raise RuntimeError("to_np requires torch, which is not installed.")
+    return t.detach().cpu().numpy().astype(np.float32)
+
+
+def normalize_t(v: np.ndarray) -> np.ndarray:
+    """Normalize *v* via torch.linalg.vector_norm on DEVICE; return np.float32.
+
+    Raises RuntimeError if torch is not installed.
+    """
+    if not HAS_TORCH:
+        raise RuntimeError("normalize_t requires torch, which is not installed.")
+    t = to_t(v)
+    n = torch.linalg.vector_norm(t)
+    return to_np(t / (n + 1e-8))
+
+
+def cosine_t(a: np.ndarray, b: np.ndarray) -> float:
+    """Cosine similarity via torch.dot on DEVICE; return Python float.
+
+    Raises RuntimeError if torch is not installed.
+    """
+    if not HAS_TORCH:
+        raise RuntimeError("cosine_t requires torch, which is not installed.")
+    ta = to_t(a)
+    tb = to_t(b)
+    na = torch.linalg.vector_norm(ta)
+    nb = torch.linalg.vector_norm(tb)
+    return float((torch.dot(ta, tb) / (na * nb + 1e-8)).item())
+
+
+def fft_bind_t(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Circular convolution via torch.fft on DEVICE; return real np.float32.
+
+    Raises RuntimeError if torch is not installed.
+    """
+    if not HAS_TORCH:
+        raise RuntimeError("fft_bind_t requires torch, which is not installed.")
+    ta = to_t(a)
+    tb = to_t(b)
+    result = torch.fft.ifft(torch.fft.fft(ta) * torch.fft.fft(tb))
+    return to_np(result.real)
+
+
+def batch_cosine(matrix: np.ndarray, vec: np.ndarray) -> np.ndarray:
+    """(N, D) matrix @ (D,) vec → (N,) cosine scores as np.float32.
+
+    Matrix rows are assumed to be pre-normalised (unit vectors).
+    Uses torch.mv on DEVICE when torch is available; falls back to numpy.
+    """
+    if HAS_TORCH:
+        tm = to_t(matrix)
+        tv = to_t(vec)
+        return torch.mv(tm, tv).cpu().numpy()
+    return (matrix @ vec).astype(np.float32)
+
+
+def batch_matmul(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """General (M, K) @ (K, N) → (M, N) as np.float32.
+
+    Uses torch.mm on DEVICE when torch is available; falls back to numpy.
+    """
+    if HAS_TORCH:
+        ta = to_t(a)
+        tb = to_t(b)
+        return torch.mm(ta, tb).cpu().numpy()
+    return (a @ b).astype(np.float32)
+
+
+# ---------------------------------------------------------------------------
+# MDA Dual Mode — SINGLE (numpy/CPU) vs BATCH (CUDA, high throughput)
+# ---------------------------------------------------------------------------
+
+class MDAMode:
+    SINGLE = "single"
+    BATCH  = "batch"
+
+
+_mode: str = MDAMode.SINGLE
+
+
+def set_mode(mode: str) -> None:
+    """Switch between MDAMode.SINGLE and MDAMode.BATCH."""
+    global _mode
+    _mode = mode
+
+
+def get_mode() -> str:
+    """Return the current mode string ('single' or 'batch')."""
+    return _mode
+
+
+def is_batch_mode() -> bool:
+    """True only when mode is BATCH *and* CUDA is available."""
+    return _mode == MDAMode.BATCH and HAS_CUDA

{mda_memory-0.1.2 → mda_memory-0.2.0}/mda/core/bind.py

@@ -1,39 +1,59 @@
-import numpy as np
-
-DIM = 256
-
-
-def normalize(v: np.ndarray) -> np.ndarray:
-    n = np.linalg.norm(v)
-    return v / (n + 1e-8)
-
-
-def random_vector(dim: int = DIM, seed: int = None) -> np.ndarray:
-    rng = np.random.default_rng(seed)
-    return normalize(rng.normal(0, 1, dim))
-
-
-def zero_vector(dim: int = DIM) -> np.ndarray:
-    return np.zeros(dim)
-
-
-def bind(a: np.ndarray, b: np.ndarray) -> np.ndarray:
-    return np.real(np.fft.ifft(np.fft.fft(a) * np.fft.fft(b)))
-
-
-def unbind(compound: np.ndarray, b: np.ndarray) -> np.ndarray:
-    F_b     = np.fft.fft(b)
-    F_b_inv = np.conj(F_b) / (np.abs(F_b) ** 2 + 1e-6)
-    b_inv   = np.real(np.fft.ifft(F_b_inv))
-    return np.real(np.fft.ifft(np.fft.fft(compound) * np.fft.fft(b_inv)))
-
-
-def bind_many(*vectors: np.ndarray) -> np.ndarray:
-    result = vectors[0].copy()
-    for v in vectors[1:]:
-        result = bind(result, v)
-    return result
-
-
-def cosine(a: np.ndarray, b: np.ndarray) -> float:
-    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8))
+import numpy as np
+
+DIM = 512
+
+# GPU delegation — safe regardless of torch availability.
+try:
+    from mda.core.accelerator import (
+        normalize_t as _normalize_t,
+        cosine_t    as _cosine_t,
+        fft_bind_t  as _fft_bind_t,
+        HAS_TORCH,
+    )
+except ImportError:
+    HAS_TORCH    = False
+    _normalize_t = None
+    _cosine_t    = None
+    _fft_bind_t  = None
+
+
+def normalize(v: np.ndarray) -> np.ndarray:
+    if HAS_TORCH and _normalize_t is not None:
+        return _normalize_t(v)
+    n = np.linalg.norm(v)
+    return v / (n + 1e-8)
+
+
+def random_vector(dim: int = DIM, seed: int = None) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    return normalize(rng.normal(0, 1, dim))
+
+
+def zero_vector(dim: int = DIM) -> np.ndarray:
+    return np.zeros(dim)
+
+
+def bind(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    if HAS_TORCH and _fft_bind_t is not None:
+        return _fft_bind_t(a, b)
+    return np.real(np.fft.ifft(np.fft.fft(a) * np.fft.fft(b)))
+
+
+def unbind(compound: np.ndarray, b: np.ndarray) -> np.ndarray:
+    F_b     = np.fft.fft(b)
+    F_b_inv = np.conj(F_b) / (np.abs(F_b) ** 2 + 1e-6)
+    b_inv   = np.real(np.fft.ifft(F_b_inv))
+    return np.real(np.fft.ifft(np.fft.fft(compound) * np.fft.fft(b_inv)))
+
+
+def bind_many(*vectors: np.ndarray) -> np.ndarray:
+    result = vectors[0].copy()
+    for v in vectors[1:]:
+        result = bind(result, v)
+    return result
+
+
+def cosine(a: np.ndarray, b: np.ndarray) -> float:
+    if HAS_TORCH and _cosine_t is not None:
+        return _cosine_t(a, b)
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8))