wavemind 2.0.3__tar.gz → 2.0.5__tar.gz

{wavemind-2.0.3/wavemind.egg-info → wavemind-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.0.3
+Version: 2.0.5
 Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/CaspianG/wavemind
@@ -219,6 +219,34 @@ pip install -e ".[bench]"
 python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
 ```
 
+Dynamic agent-memory benchmark:
+
+200 memories, 8 checks, same precomputed `HashingTextEncoder` embeddings.
+This benchmark exercises hot memory, TTL, corrections, and namespace isolation.
+WaveMind applies its built-in memory policy. `Chroma static` is a plain vector-store baseline without application-layer TTL, delete handling, namespace filters, or recall reinforcement.
+Full machine-readable result: `benchmarks/dynamic_memory_results.json`.
+
+| engine | precision@1 | precision@3 | stale suppression | avg latency |
+|---|---:|---:|---:|---:|
+| WaveMind | 1.00 | 1.00 | 1.00 | 25.26 ms |
+| Chroma static | 0.57 | 1.00 | 0.00 | 1.75 ms |
+
+Category success:
+
+| behavior | WaveMind | Chroma static |
+|---|---:|---:|
+| hot memory | 1.00 | 0.50 |
+| TTL | 1.00 | 0.00 |
+| correction | 1.00 | 0.00 |
+| namespace isolation | 1.00 | 0.00 |
+
+Run locally from a cloned repository:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/dynamic_memory_benchmark.py --engines wavemind chroma --memories 200
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -241,13 +269,14 @@ WaveMind is not trying to replace dedicated vector databases at scale. The inten
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
 - The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
 - In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
-- The current public benchmark does not yet prove the dynamic-memory advantage. The next benchmark must test hotness, TTL, corrections, namespace isolation, and repeated recall.
+- The dynamic benchmark currently compares WaveMind against a static Chroma baseline. Chroma and Qdrant can implement similar behavior with extra application-layer metadata policy, deletes, filters, and reinforcement logic.
+- Dynamic memory is slower than static Chroma in the current local benchmark: 25.26 ms vs 1.75 ms average query latency on this machine.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Dynamic agent-memory benchmark against Chroma/Qdrant: hotness, TTL, stale-fact suppression, corrections, and namespace isolation.
-- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
+- Expand the dynamic benchmark to Qdrant, Chroma metadata-policy mode, sentence-transformers, and FAISS.
+- Optimize dynamic re-ranking latency after lexical candidate filtering.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.3 → wavemind-2.0.5}/README.md

@@ -187,6 +187,34 @@ pip install -e ".[bench]"
 python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
 ```
 
+Dynamic agent-memory benchmark:
+
+200 memories, 8 checks, same precomputed `HashingTextEncoder` embeddings.
+This benchmark exercises hot memory, TTL, corrections, and namespace isolation.
+WaveMind applies its built-in memory policy. `Chroma static` is a plain vector-store baseline without application-layer TTL, delete handling, namespace filters, or recall reinforcement.
+Full machine-readable result: `benchmarks/dynamic_memory_results.json`.
+
+| engine | precision@1 | precision@3 | stale suppression | avg latency |
+|---|---:|---:|---:|---:|
+| WaveMind | 1.00 | 1.00 | 1.00 | 25.26 ms |
+| Chroma static | 0.57 | 1.00 | 0.00 | 1.75 ms |
+
+Category success:
+
+| behavior | WaveMind | Chroma static |
+|---|---:|---:|
+| hot memory | 1.00 | 0.50 |
+| TTL | 1.00 | 0.00 |
+| correction | 1.00 | 0.00 |
+| namespace isolation | 1.00 | 0.00 |
+
+Run locally from a cloned repository:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/dynamic_memory_benchmark.py --engines wavemind chroma --memories 200
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -209,13 +237,14 @@ WaveMind is not trying to replace dedicated vector databases at scale. The inten
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
 - The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
 - In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
-- The current public benchmark does not yet prove the dynamic-memory advantage. The next benchmark must test hotness, TTL, corrections, namespace isolation, and repeated recall.
+- The dynamic benchmark currently compares WaveMind against a static Chroma baseline. Chroma and Qdrant can implement similar behavior with extra application-layer metadata policy, deletes, filters, and reinforcement logic.
+- Dynamic memory is slower than static Chroma in the current local benchmark: 25.26 ms vs 1.75 ms average query latency on this machine.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Dynamic agent-memory benchmark against Chroma/Qdrant: hotness, TTL, stale-fact suppression, corrections, and namespace isolation.
-- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
+- Expand the dynamic benchmark to Qdrant, Chroma metadata-policy mode, sentence-transformers, and FAISS.
+- Optimize dynamic re-ranking latency after lexical candidate filtering.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.3 → wavemind-2.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavemind"
-version = "2.0.3"
+version = "2.0.5"
 description = "Persistent dynamic memory engine with vector search and wave-field re-ranking"
 readme = "README.md"
 license = "MIT"

wavemind-2.0.5/tests/test_dynamic_memory_benchmark.py

@@ -0,0 +1,88 @@
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_dynamic_memory_scenario_exercises_memory_behaviors():
+    from benchmarks.dynamic_memory_benchmark import build_dynamic_memory_scenario
+
+    scenario = build_dynamic_memory_scenario(memory_count=200)
+    categories = {check.category for check in scenario.checks}
+
+    assert len(scenario.memories) == 200
+    assert len(scenario.checks) >= 8
+    assert {"hot_memory", "ttl", "correction", "namespace"}.issubset(categories)
+    assert any(memory.ttl_seconds == 0 for memory in scenario.memories)
+    assert any(memory.priority >= 5 for memory in scenario.memories)
+    assert any(check.forbidden_ids for check in scenario.checks)
+
+
+def test_dynamic_memory_metrics_track_expected_and_forbidden_results():
+    from benchmarks.dynamic_memory_benchmark import DynamicCheck, compute_dynamic_metrics
+
+    checks = [
+        DynamicCheck(
+            id="q_hot",
+            category="hot_memory",
+            text="How should the assistant answer?",
+            namespace="agent-a",
+            expected_id="style_hot",
+        ),
+        DynamicCheck(
+            id="q_ttl",
+            category="ttl",
+            text="What temporary token is still valid?",
+            namespace="agent-a",
+            expected_id=None,
+            forbidden_ids=("expired_token",),
+        ),
+    ]
+    rankings = {
+        "q_hot": ["style_hot", "style_cold"],
+        "q_ttl": ["unrelated_fact"],
+    }
+
+    metrics = compute_dynamic_metrics(checks, rankings, [2.0, 4.0], engine="unit")
+
+    assert metrics.precision_at_1 == 1.0
+    assert metrics.precision_at_3 == 1.0
+    assert metrics.suppression_rate == 1.0
+    assert metrics.category_success["hot_memory"] == 1.0
+    assert metrics.category_success["ttl"] == 1.0
+    assert metrics.avg_latency_ms == 3.0
+
+
+def test_dynamic_memory_benchmark_cli_writes_json_for_wavemind(tmp_path):
+    output = tmp_path / "dynamic-memory-result.json"
+    project_root = Path(__file__).resolve().parents[1]
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(project_root) + os.pathsep + env.get("PYTHONPATH", "")
+
+    subprocess.run(
+        [
+            sys.executable,
+            "benchmarks/dynamic_memory_benchmark.py",
+            "--engines",
+            "wavemind",
+            "--memories",
+            "40",
+            "--output",
+            str(output),
+        ],
+        cwd=project_root,
+        env=env,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+    payload = json.loads(output.read_text(encoding="utf-8"))
+
+    assert payload["scenario"]["name"] == "dynamic_agent_memory"
+    assert payload["scenario"]["memories"] == 40
+    assert payload["results"][0]["engine"] == "WaveMind"
+    assert "suppression_rate" in payload["results"][0]
+    assert "category_success" in payload["results"][0]

{wavemind-2.0.3 → wavemind-2.0.5}/tests/test_packaging_files.py

@@ -1,13 +1,15 @@
 from pathlib import Path
-import tomllib
+import re
 
 import wavemind
 
 
 def test_package_version_matches_pyproject():
-    pyproject = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))
+    pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
+    match = re.search(r'^version = "([^"]+)"$', pyproject, flags=re.MULTILINE)
 
-    assert wavemind.__version__ == pyproject["project"]["version"]
+    assert match is not None
+    assert wavemind.__version__ == match.group(1)
 
 
 def test_sentence_extra_is_available_for_install_scripts():
@@ -56,6 +58,15 @@ def test_install_scripts_create_venv_and_install_sentence_extra():
     assert 'pip install -e ".[sentence]"' in install_bat
 
 
+def test_docker_files_track_runtime_package_version():
+    requirements = Path("requirements.txt").read_text(encoding="utf-8")
+    compose = Path("docker-compose.yml").read_text(encoding="utf-8")
+
+    assert "pytest" not in requirements
+    assert "httpx" not in requirements
+    assert f"image: wavemind:{wavemind.__version__}" in compose
+
+
 def test_github_actions_runs_pytest_on_main_for_python_310_and_311():
     workflow = Path(".github/workflows/tests.yml").read_text(encoding="utf-8")
 

{wavemind-2.0.3 → wavemind-2.0.5}/tests/test_semantic_and_latency.py

@@ -131,6 +131,30 @@ def test_short_query_exact_match_can_beat_stronger_vector_candidate(tmp_path):
     assert results[0].id == expected_id
 
 
+def test_common_query_words_do_not_expand_lexical_candidates(tmp_path):
+    mind = WaveMind(
+        db_path=tmp_path / "stopwords.sqlite3",
+        encoder=FlatSemanticEncoder(),
+        width=16,
+        height=16,
+        layers=2,
+        index_kind="numpy",
+        rerank_k=1,
+    )
+    expected_id = mind.remember("rarebudget target memory", namespace="stopwords")
+    noise_ids = [
+        mind.remember(f"the user background filler memory {i}", namespace="stopwords")
+        for i in range(20)
+    ]
+
+    tokens = mind._tokens("what is the user rarebudget")
+    candidate_ids = mind._lexical_candidate_ids(tokens, {expected_id, *noise_ids})
+
+    assert "the" not in tokens
+    assert "user" not in tokens
+    assert candidate_ids == {expected_id}
+
+
 def test_field_weight_is_disabled_above_capacity_threshold(tmp_path):
     mind = WaveMind(
         db_path=tmp_path / "field-cutoff.sqlite3",

{wavemind-2.0.3 → wavemind-2.0.5}/wavemind/__init__.py

@@ -8,7 +8,7 @@ from .encoders import (
 )
 from .storage import MemoryRecord, SQLiteMemoryStore
 
-__version__ = "2.0.3"
+__version__ = "2.0.5"
 
 __all__ = [
     "FieldProjector",

{wavemind-2.0.3 → wavemind-2.0.5}/wavemind/core.py

@@ -13,6 +13,32 @@ from .indexes import NumpyVectorIndex, create_vector_index
 from .storage import MemoryRecord, SQLiteMemoryStore
 
 
+LEXICAL_STOPWORDS = {
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "be",
+    "for",
+    "from",
+    "how",
+    "is",
+    "it",
+    "of",
+    "or",
+    "should",
+    "that",
+    "the",
+    "this",
+    "to",
+    "user",
+    "what",
+    "which",
+    "with",
+}
+
+
 class WaveField:
     def __init__(
         self,
@@ -408,6 +434,7 @@ class WaveMind:
         return tuple(
             token.replace("ё", "е")
             for token in re.findall(r"[\w]+", text.lower(), flags=re.UNICODE)
+            if token not in LEXICAL_STOPWORDS
         )
 
     def _lexical_match(self, query_tokens: tuple[str, ...], text: str) -> float:

{wavemind-2.0.3 → wavemind-2.0.5/wavemind.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.0.3
+Version: 2.0.5
 Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/CaspianG/wavemind
@@ -219,6 +219,34 @@ pip install -e ".[bench]"
 python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
 ```
 
+Dynamic agent-memory benchmark:
+
+200 memories, 8 checks, same precomputed `HashingTextEncoder` embeddings.
+This benchmark exercises hot memory, TTL, corrections, and namespace isolation.
+WaveMind applies its built-in memory policy. `Chroma static` is a plain vector-store baseline without application-layer TTL, delete handling, namespace filters, or recall reinforcement.
+Full machine-readable result: `benchmarks/dynamic_memory_results.json`.
+
+| engine | precision@1 | precision@3 | stale suppression | avg latency |
+|---|---:|---:|---:|---:|
+| WaveMind | 1.00 | 1.00 | 1.00 | 25.26 ms |
+| Chroma static | 0.57 | 1.00 | 0.00 | 1.75 ms |
+
+Category success:
+
+| behavior | WaveMind | Chroma static |
+|---|---:|---:|
+| hot memory | 1.00 | 0.50 |
+| TTL | 1.00 | 0.00 |
+| correction | 1.00 | 0.00 |
+| namespace isolation | 1.00 | 0.00 |
+
+Run locally from a cloned repository:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/dynamic_memory_benchmark.py --engines wavemind chroma --memories 200
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -241,13 +269,14 @@ WaveMind is not trying to replace dedicated vector databases at scale. The inten
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
 - The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
 - In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
-- The current public benchmark does not yet prove the dynamic-memory advantage. The next benchmark must test hotness, TTL, corrections, namespace isolation, and repeated recall.
+- The dynamic benchmark currently compares WaveMind against a static Chroma baseline. Chroma and Qdrant can implement similar behavior with extra application-layer metadata policy, deletes, filters, and reinforcement logic.
+- Dynamic memory is slower than static Chroma in the current local benchmark: 25.26 ms vs 1.75 ms average query latency on this machine.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Dynamic agent-memory benchmark against Chroma/Qdrant: hotness, TTL, stale-fact suppression, corrections, and namespace isolation.
-- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
+- Expand the dynamic benchmark to Qdrant, Chroma metadata-policy mode, sentence-transformers, and FAISS.
+- Optimize dynamic re-ranking latency after lexical candidate filtering.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.3 → wavemind-2.0.5}/wavemind.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ tests/test_api.py
 tests/test_api_process_persistence.py
 tests/test_cli_smoke.py
 tests/test_core_persistence.py
+tests/test_dynamic_memory_benchmark.py
 tests/test_examples.py
 tests/test_import_benchmark.py
 tests/test_indexes_encoders.py