holographic-memory-engine 1.0.2__tar.gz

holographic_memory_engine-1.0.2/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: holographic-memory-engine
+Version: 1.0.2
+Summary: A universal phase-space memory engine that retrieves knowledge via holographic interference instead of vector similarity search.
+Home-page: https://github.com/Luckyy0311
+Author: Abdul Mofique Siddiqui
+Author-email: mofique7860@gmail.com
+License: MIT
+Keywords: holographic-memory,rag,vector-search,ai,retrieval
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+Provides-Extra: gpu
+Requires-Dist: cupy>=12.0; extra == "gpu"
+Provides-Extra: neural
+Requires-Dist: sentence-transformers>=2.2; extra == "neural"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# holographic-memory-engine
+
+A universal phase-space memory engine that retrieves knowledge via **holographic
+interference** instead of vector similarity search.
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Why?
+
+Classic RAG retrieves text chunks by cosine similarity and stuffs them into a
+prompt. This returns **passages**, not answers, and pollutes the context window.
+
+`holographic-memory` binds `key -> value` pairs into complex phase vectors and
+retrieves by **constructive / destructive wave interference**. The result is the
+exact value, directly, with no chunk stuffing.
+
+| Feature | Classic RAG | holographic-memory |
+|---|---|---|
+| Retrieval signal | Cosine similarity | Phase interference |
+| Returns | Text chunk | Exact value |
+| Context pollution | High | None |
+| Answer verbosity | High | Minimal |
+
+---
+
+## Installation
+
+```bash
+pip install holographic-memory
+```
+
+Optional extras:
+
+```bash
+# GPU acceleration via CuPy
+pip install holographic-memory[gpu]
+
+# Neural (sentence-transformers) encoder
+pip install holographic-memory[neural]
+```
+
+---
+
+## Quick Start
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+
+engine.add("capital France", "Paris")
+engine.add("capital Japan", "Tokyo")
+engine.add("ceo Tesla", "Elon Musk")
+engine.build()
+
+print(engine.ask("What is the capital of France?")["answer"])
+# -> Paris
+```
+
+---
+
+## Use a Neural Encoder
+
+```python
+from holographic import HolographicEngine, NeuralPhaseEncoder
+
+engine = HolographicEngine(encoder=NeuralPhaseEncoder(dim=2048))
+# ... same API
+```
+
+## Custom Encoder
+
+Any object with a `dim` attribute and an `encode(text) -> complex ndarray`
+method works:
+
+```python
+import numpy as np
+from holographic import HolographicEngine
+
+class MyEncoder:
+    dim = 2048
+    def encode(self, text: str) -> np.ndarray:
+        # your logic; return complex64 vector of shape (dim,)
+        ...
+
+engine = HolographicEngine(encoder=MyEncoder())
+```
+
+---
+
+## Ingest a Whole Document
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder, ingest_text
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+ingest_text(engine, open("handbook.txt").read(), source="handbook")
+engine.build()
+```
+
+## Save / Load
+
+```python
+from holographic import save_engine, load_engine
+
+save_engine(engine, "memory.json")
+load_engine(engine, "memory.json")
+```
+
+---
+
+## Configuration
+
+```python
+from holographic import HolographicConfig
+
+config = HolographicConfig(
+    dim=4096,           # vector dimensionality
+    shard_capacity=0,   # 0 = single large shard
+    default_top_k=5,
+    score_threshold=0.0,
+    margin_ratio=1.02,
+    use_gpu=False,
+)
+```
+
+---
+
+## How It Works
+
+1. **Bind** — `key` and `value` are encoded to constant-modulus complex vectors, then bound via element-wise multiplication: `key * value`.
+2. **Superpose** — all bindings are summed into a single memory vector.
+3. **Retrieve** — the query is multiplied by the conjugate of the memory. Matching keys resonate (constructive interference) and surface their bound values; non-matches cancel out (destructive interference).
+
+---
+
+## Running the Benchmark
+
+```bash
+pip install -e .
+python examples/evaluate.py
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

holographic_memory_engine-1.0.2/README.md

@@ -0,0 +1,151 @@
+# holographic-memory-engine
+
+A universal phase-space memory engine that retrieves knowledge via **holographic
+interference** instead of vector similarity search.
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Why?
+
+Classic RAG retrieves text chunks by cosine similarity and stuffs them into a
+prompt. This returns **passages**, not answers, and pollutes the context window.
+
+`holographic-memory` binds `key -> value` pairs into complex phase vectors and
+retrieves by **constructive / destructive wave interference**. The result is the
+exact value, directly, with no chunk stuffing.
+
+| Feature | Classic RAG | holographic-memory |
+|---|---|---|
+| Retrieval signal | Cosine similarity | Phase interference |
+| Returns | Text chunk | Exact value |
+| Context pollution | High | None |
+| Answer verbosity | High | Minimal |
+
+---
+
+## Installation
+
+```bash
+pip install holographic-memory
+```
+
+Optional extras:
+
+```bash
+# GPU acceleration via CuPy
+pip install holographic-memory[gpu]
+
+# Neural (sentence-transformers) encoder
+pip install holographic-memory[neural]
+```
+
+---
+
+## Quick Start
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+
+engine.add("capital France", "Paris")
+engine.add("capital Japan", "Tokyo")
+engine.add("ceo Tesla", "Elon Musk")
+engine.build()
+
+print(engine.ask("What is the capital of France?")["answer"])
+# -> Paris
+```
+
+---
+
+## Use a Neural Encoder
+
+```python
+from holographic import HolographicEngine, NeuralPhaseEncoder
+
+engine = HolographicEngine(encoder=NeuralPhaseEncoder(dim=2048))
+# ... same API
+```
+
+## Custom Encoder
+
+Any object with a `dim` attribute and an `encode(text) -> complex ndarray`
+method works:
+
+```python
+import numpy as np
+from holographic import HolographicEngine
+
+class MyEncoder:
+    dim = 2048
+    def encode(self, text: str) -> np.ndarray:
+        # your logic; return complex64 vector of shape (dim,)
+        ...
+
+engine = HolographicEngine(encoder=MyEncoder())
+```
+
+---
+
+## Ingest a Whole Document
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder, ingest_text
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+ingest_text(engine, open("handbook.txt").read(), source="handbook")
+engine.build()
+```
+
+## Save / Load
+
+```python
+from holographic import save_engine, load_engine
+
+save_engine(engine, "memory.json")
+load_engine(engine, "memory.json")
+```
+
+---
+
+## Configuration
+
+```python
+from holographic import HolographicConfig
+
+config = HolographicConfig(
+    dim=4096,           # vector dimensionality
+    shard_capacity=0,   # 0 = single large shard
+    default_top_k=5,
+    score_threshold=0.0,
+    margin_ratio=1.02,
+    use_gpu=False,
+)
+```
+
+---
+
+## How It Works
+
+1. **Bind** — `key` and `value` are encoded to constant-modulus complex vectors, then bound via element-wise multiplication: `key * value`.
+2. **Superpose** — all bindings are summed into a single memory vector.
+3. **Retrieve** — the query is multiplied by the conjugate of the memory. Matching keys resonate (constructive interference) and surface their bound values; non-matches cancel out (destructive interference).
+
+---
+
+## Running the Benchmark
+
+```bash
+pip install -e .
+python examples/evaluate.py
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

holographic_memory_engine-1.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

holographic_memory_engine-1.0.2/setup.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from setuptools import setup, find_packages
+
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name='holographic-memory-engine',
+    version='1.0.2',
+    author='Abdul Mofique Siddiqui',
+    author_email='mofique7860@gmail.com',
+    description='A universal phase-space memory engine that retrieves knowledge via holographic interference instead of vector similarity search.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/Luckyy0311',
+    license='MIT',
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Science/Research',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    keywords=["holographic-memory", "rag", "vector-search", "ai", "retrieval"],
+    python_requires='>=3.9',
+    install_requires=[
+        'numpy>=1.21',
+    ],
+    extras_require={
+        "gpu": ["cupy>=12.0"],
+        "neural": ["sentence-transformers>=2.2"],
+        "dev": ["pytest>=7.0", "build>=1.0", "twine>=4.0"],
+    },
+    include_package_data=True,
+    zip_safe=False,
+)

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: holographic-memory-engine
+Version: 1.0.2
+Summary: A universal phase-space memory engine that retrieves knowledge via holographic interference instead of vector similarity search.
+Home-page: https://github.com/Luckyy0311
+Author: Abdul Mofique Siddiqui
+Author-email: mofique7860@gmail.com
+License: MIT
+Keywords: holographic-memory,rag,vector-search,ai,retrieval
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+Provides-Extra: gpu
+Requires-Dist: cupy>=12.0; extra == "gpu"
+Provides-Extra: neural
+Requires-Dist: sentence-transformers>=2.2; extra == "neural"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# holographic-memory-engine
+
+A universal phase-space memory engine that retrieves knowledge via **holographic
+interference** instead of vector similarity search.
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Why?
+
+Classic RAG retrieves text chunks by cosine similarity and stuffs them into a
+prompt. This returns **passages**, not answers, and pollutes the context window.
+
+`holographic-memory` binds `key -> value` pairs into complex phase vectors and
+retrieves by **constructive / destructive wave interference**. The result is the
+exact value, directly, with no chunk stuffing.
+
+| Feature | Classic RAG | holographic-memory |
+|---|---|---|
+| Retrieval signal | Cosine similarity | Phase interference |
+| Returns | Text chunk | Exact value |
+| Context pollution | High | None |
+| Answer verbosity | High | Minimal |
+
+---
+
+## Installation
+
+```bash
+pip install holographic-memory
+```
+
+Optional extras:
+
+```bash
+# GPU acceleration via CuPy
+pip install holographic-memory[gpu]
+
+# Neural (sentence-transformers) encoder
+pip install holographic-memory[neural]
+```
+
+---
+
+## Quick Start
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+
+engine.add("capital France", "Paris")
+engine.add("capital Japan", "Tokyo")
+engine.add("ceo Tesla", "Elon Musk")
+engine.build()
+
+print(engine.ask("What is the capital of France?")["answer"])
+# -> Paris
+```
+
+---
+
+## Use a Neural Encoder
+
+```python
+from holographic import HolographicEngine, NeuralPhaseEncoder
+
+engine = HolographicEngine(encoder=NeuralPhaseEncoder(dim=2048))
+# ... same API
+```
+
+## Custom Encoder
+
+Any object with a `dim` attribute and an `encode(text) -> complex ndarray`
+method works:
+
+```python
+import numpy as np
+from holographic import HolographicEngine
+
+class MyEncoder:
+    dim = 2048
+    def encode(self, text: str) -> np.ndarray:
+        # your logic; return complex64 vector of shape (dim,)
+        ...
+
+engine = HolographicEngine(encoder=MyEncoder())
+```
+
+---
+
+## Ingest a Whole Document
+
+```python
+from holographic import HolographicEngine, HashPhaseEncoder, ingest_text
+
+engine = HolographicEngine(encoder=HashPhaseEncoder(dim=2048))
+ingest_text(engine, open("handbook.txt").read(), source="handbook")
+engine.build()
+```
+
+## Save / Load
+
+```python
+from holographic import save_engine, load_engine
+
+save_engine(engine, "memory.json")
+load_engine(engine, "memory.json")
+```
+
+---
+
+## Configuration
+
+```python
+from holographic import HolographicConfig
+
+config = HolographicConfig(
+    dim=4096,           # vector dimensionality
+    shard_capacity=0,   # 0 = single large shard
+    default_top_k=5,
+    score_threshold=0.0,
+    margin_ratio=1.02,
+    use_gpu=False,
+)
+```
+
+---
+
+## How It Works
+
+1. **Bind** — `key` and `value` are encoded to constant-modulus complex vectors, then bound via element-wise multiplication: `key * value`.
+2. **Superpose** — all bindings are summed into a single memory vector.
+3. **Retrieve** — the query is multiplied by the conjugate of the memory. Matching keys resonate (constructive interference) and surface their bound values; non-matches cancel out (destructive interference).
+
+---
+
+## Running the Benchmark
+
+```bash
+pip install -e .
+python examples/evaluate.py
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/holographic_memory_engine.egg-info/PKG-INFO
+src/holographic_memory_engine.egg-info/SOURCES.txt
+src/holographic_memory_engine.egg-info/dependency_links.txt
+src/holographic_memory_engine.egg-info/not-zip-safe
+src/holographic_memory_engine.egg-info/requires.txt
+src/holographic_memory_engine.egg-info/top_level.txt
+test/test_engine.py

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/requires.txt

@@ -0,0 +1,12 @@
+numpy>=1.21
+
+[dev]
+pytest>=7.0
+build>=1.0
+twine>=4.0
+
+[gpu]
+cupy>=12.0
+
+[neural]
+sentence-transformers>=2.2

holographic_memory_engine-1.0.2/src/holographic_memory_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+

holographic_memory_engine-1.0.2/test/test_engine.py

@@ -0,0 +1,30 @@
+"""Unit tests for the holographic engine."""
+import tempfile
+from pathlib import Path
+from holographic import HolographicEngine, HashPhaseEncoder, HolographicConfig
+
+def make_engine(dim=512):
+    config = HolographicConfig(dim=dim)
+    return HolographicEngine(encoder=HashPhaseEncoder(dim=dim), config=config)
+
+def test_basic_add_and_ask():
+    engine = make_engine()
+    engine.add("capital France", "Paris")
+    engine.add("capital Japan", "Tokyo")
+    engine.build()
+    assert engine.ask("What is the capital of France?")["answer"] == "Paris"
+
+def test_save_and_load():
+    engine = make_engine()
+    engine.add("capital France", "Paris")
+    engine.build()
+
+    with tempfile.TemporaryDirectory() as tmp:
+        path = str(Path(tmp) / "state.json")
+        
+        # Using the new clean methods
+        engine.save(path)
+
+        engine2 = make_engine()
+        engine2.load(path)
+        assert engine2.ask("capital France")["answer"] == "Paris"