wavemind 2.0.0__tar.gz → 2.0.2__tar.gz

wavemind-2.0.2/PKG-INFO

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: wavemind
+Version: 2.0.2
+Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CaspianG/wavemind
+Project-URL: Repository, https://github.com/CaspianG/wavemind
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2
+Requires-Dist: pypdf>=4
+Provides-Extra: sentence
+Requires-Dist: sentence-transformers>=3; extra == "sentence"
+Provides-Extra: ml
+Requires-Dist: sentence-transformers>=3; extra == "ml"
+Provides-Extra: indexes
+Requires-Dist: annoy>=1.17; extra == "indexes"
+Requires-Dist: faiss-cpu>=1.8; platform_system != "Windows" and extra == "indexes"
+Provides-Extra: bench
+Requires-Dist: chromadb>=1.0; extra == "bench"
+Provides-Extra: langchain
+Requires-Dist: langchain-classic>=1.0; extra == "langchain"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# WaveMind is persistent dynamic memory for AI agents: vector search first, wave-field priority second, SQLite as the source of truth.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+[![Tests](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml/badge.svg)](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Terminal Demo
+
+From a cloned repository:
+
+```text
+$ python examples/demo.py
+✓ Remembered: "Andrey is a trader who tracks market breakouts."
+✓ Remembered: "Andrey prefers short practical answers about AI agents."
+
+Query: "Andrey trader agent"
+→ Result 1 (0.54): "Andrey is a trader who tracks market breakouts."
+→ Result 2 (0.30): "Andrey prefers short practical answers about AI agents."
+```
+
+The demo is offline, keyless, and uses the built-in hash encoder.
+
+## Quick Start
+
+Install from PyPI and create your first local memory:
+
+```sh
+python -m pip install wavemind
+wavemind remember "Andrey is a trader" --namespace demo
+wavemind query "trader" --namespace demo
+```
+
+What happens here:
+
+- `remember` writes the text and its vector pattern into a local SQLite database.
+- By default, the database file is `wavemind.sqlite3` in your current working directory.
+- `--namespace demo` keeps this memory separate from other users, agents, or projects.
+- `query` reads from the same SQLite file and returns the closest remembered texts.
+
+## Optional Embeddings
+
+For sentence-transformer embeddings:
+
+```sh
+python -m pip install "wavemind[sentence]"
+wavemind --encoder sentence remember "Andrey is a trader" --namespace demo
+wavemind --encoder sentence query "What does Andrey do?" --namespace demo
+```
+
+## Data Location
+
+For an explicit database path, put global options before the command:
+
+```sh
+wavemind --db ./agent_memory.sqlite3 remember "Andrey is a trader" --namespace demo
+wavemind --db ./agent_memory.sqlite3 query "trader" --namespace demo
+```
+
+## Install From Source
+
+For contributors installing from a local clone:
+
+```sh
+git clone https://github.com/CaspianG/wavemind.git
+cd wavemind
+python -m pip install -e ".[sentence]"
+```
+
+One-file setup scripts are also included in the repository:
+
+```sh
+sh install.sh
+```
+
+```bat
+install.bat
+```
+
+## LangChain Memory
+
+Install the optional integration:
+
+```sh
+pip install "wavemind[langchain]"
+```
+
+Use WaveMind as a drop-in LangChain memory object:
+
+```python
+from wavemind.integrations.langchain import WaveMindMemory
+
+memory = WaveMindMemory(db_path="agent_memory.sqlite3")
+# Replace: memory = ConversationBufferMemory()
+```
+
+Offline runnable example from a cloned repository:
+
+```sh
+python examples/langchain_memory.py
+```
+
+## Why Dynamic Memory
+
+WaveMind is not positioned as "a faster Chroma." Chroma, Qdrant, Pinecone, and Weaviate are vector databases: they store embeddings and return nearest neighbors. That is the right tool for many static RAG workloads.
+
+WaveMind is an agent memory layer. It still uses vector search first, but then applies memory-specific signals that a plain vector store does not model by default:
+
+| memory behavior | Why it matters for agents | WaveMind mechanism |
+|---|---|---|
+| Hot memories | Facts recalled repeatedly should become easier to recall again. | Wave-field hotness and priority updates. |
+| Aging memories | Old low-value facts should fade instead of competing forever. | TTL and decay-aware scoring. |
+| Scoped memory | One user, agent, workspace, or project should not leak into another. | Namespaces and tags. |
+| Explicit forgetting | Agents need deletion, privacy cleanup, and correction workflows. | `forget()` plus SQLite persistence. |
+| Stable restart behavior | A memory system must survive process restarts. | SQLite source of truth, reloadable indexes. |
+| Vector plus memory rank | Semantic similarity is necessary but not sufficient for long-running agents. | k-NN candidates first, wave field as re-ranker. |
+
+The current Chroma benchmark below is intentionally conservative: it compares static retrieval on the same facts and the same hash embeddings. That benchmark is useful, but it does not exercise WaveMind's main product thesis: memory that changes over time as an agent recalls, reinforces, ages, and forgets information.
+
+The benchmark that should decide whether WaveMind is worth using is a dynamic agent-memory benchmark:
+
+| scenario | What should happen |
+|---|---|
+| A user repeats a preference many times. | WaveMind should rank it higher than equally similar but unused facts. |
+| A fact expires via TTL. | WaveMind should suppress it without requiring manual vector cleanup. |
+| A user corrects an old fact. | WaveMind should prefer the newer or reinforced memory. |
+| A query is ambiguous across namespaces. | WaveMind should return only the scoped user's memory. |
+| A long conversation has many irrelevant facts. | WaveMind should preserve useful recall instead of treating all vectors equally. |
+
+In short: static vector search answers "what is nearest?" Agent memory also asks "what is still relevant, reinforced, scoped, and allowed to be remembered?"
+
+## Benchmark
+
+Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
+
+| metric | hash | sentence-transformers |
+|---|---:|---:|
+| precision@1 | 1.00 | 1.00 |
+| precision@3 | 1.00 | 1.00 |
+| avg query | 0.49 ms | 52.84 ms |
+
+Capacity check with the hash encoder:
+
+| memories | precision@1 | precision@3 | avg query |
+|---:|---:|---:|---:|
+| 200 | 1.00 | 1.00 | 0.49 ms |
+| 1000 | 0.88 | 1.00 | 1.50 ms |
+| 5000 | 0.72 | 0.88 | 5.68 ms |
+
+Run locally from a cloned repository:
+
+```sh
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder hash --index numpy
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
+```
+
+Agent-memory benchmark against Chroma:
+
+200 Russian user facts, 50 natural-language questions, same precomputed `HashingTextEncoder` embeddings for WaveMind and Chroma.
+Full machine-readable result: `benchmarks/agent_memory_results.json`.
+
+This is a static retrieval benchmark. It measures baseline ranking and latency, not hotness, TTL, repeated recall, or memory aging.
+
+| engine | precision@1 | precision@3 | avg latency |
+|---|---:|---:|---:|
+| WaveMind | 0.82 | 0.90 | 2.25 ms |
+| Chroma | 0.82 | 0.88 | 0.93 ms |
+
+Run locally from a cloned repository:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
+```
+
+## Comparison
+
+| feature | WaveMind | Chroma | Qdrant |
+|---|---|---|---|
+| Primary role | Agent memory engine | Embedding database | Production vector database |
+| Local SQLite persistence | Yes | Yes | No, separate service/storage |
+| HTTP API | FastAPI included | Included | Included |
+| Dynamic memory priority | Wave-field hotness, TTL, priority | Metadata/filter driven | Payload/filter driven |
+| Built-in forgetting | TTL and explicit forget | Manual delete/filtering | Manual delete/filtering |
+| Best fit | Small to medium agent memory with dynamic recall | Local RAG apps and prototypes | Large-scale vector search |
+| Scale target today | Up to 1000 optimal on NumPy, FAISS recommended beyond 5000 | Larger than WaveMind local mode | Production scale |
+
+WaveMind is not trying to replace dedicated vector databases at scale. The intended product gap is dynamic priority: frequently used memories can become hotter while old or low-priority memories fade. For static RAG over large document collections, use a mature vector database. For agent memory that needs persistence, scoped recall, TTL, forgetting, and reinforcement, WaveMind is designed to sit above or beside the vector index.
+
+## Known Limitations
+
+- Optimal capacity on the current NumPy exact index is up to 1000 records.
+- At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
+- For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
+- `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.
+
+## 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.
+- Better semantic query expansion for short and ambiguous queries.
+- Namespace quotas, backups, and daemon hardening for SaaS use.
+- Webhook on recall for agent runtimes.
+- OHLCV pattern-memory experiments for market research and backtests.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

wavemind-2.0.2/README.md

@@ -0,0 +1,211 @@
+# WaveMind is persistent dynamic memory for AI agents: vector search first, wave-field priority second, SQLite as the source of truth.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+[![Tests](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml/badge.svg)](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Terminal Demo
+
+From a cloned repository:
+
+```text
+$ python examples/demo.py
+✓ Remembered: "Andrey is a trader who tracks market breakouts."
+✓ Remembered: "Andrey prefers short practical answers about AI agents."
+
+Query: "Andrey trader agent"
+→ Result 1 (0.54): "Andrey is a trader who tracks market breakouts."
+→ Result 2 (0.30): "Andrey prefers short practical answers about AI agents."
+```
+
+The demo is offline, keyless, and uses the built-in hash encoder.
+
+## Quick Start
+
+Install from PyPI and create your first local memory:
+
+```sh
+python -m pip install wavemind
+wavemind remember "Andrey is a trader" --namespace demo
+wavemind query "trader" --namespace demo
+```
+
+What happens here:
+
+- `remember` writes the text and its vector pattern into a local SQLite database.
+- By default, the database file is `wavemind.sqlite3` in your current working directory.
+- `--namespace demo` keeps this memory separate from other users, agents, or projects.
+- `query` reads from the same SQLite file and returns the closest remembered texts.
+
+## Optional Embeddings
+
+For sentence-transformer embeddings:
+
+```sh
+python -m pip install "wavemind[sentence]"
+wavemind --encoder sentence remember "Andrey is a trader" --namespace demo
+wavemind --encoder sentence query "What does Andrey do?" --namespace demo
+```
+
+## Data Location
+
+For an explicit database path, put global options before the command:
+
+```sh
+wavemind --db ./agent_memory.sqlite3 remember "Andrey is a trader" --namespace demo
+wavemind --db ./agent_memory.sqlite3 query "trader" --namespace demo
+```
+
+## Install From Source
+
+For contributors installing from a local clone:
+
+```sh
+git clone https://github.com/CaspianG/wavemind.git
+cd wavemind
+python -m pip install -e ".[sentence]"
+```
+
+One-file setup scripts are also included in the repository:
+
+```sh
+sh install.sh
+```
+
+```bat
+install.bat
+```
+
+## LangChain Memory
+
+Install the optional integration:
+
+```sh
+pip install "wavemind[langchain]"
+```
+
+Use WaveMind as a drop-in LangChain memory object:
+
+```python
+from wavemind.integrations.langchain import WaveMindMemory
+
+memory = WaveMindMemory(db_path="agent_memory.sqlite3")
+# Replace: memory = ConversationBufferMemory()
+```
+
+Offline runnable example from a cloned repository:
+
+```sh
+python examples/langchain_memory.py
+```
+
+## Why Dynamic Memory
+
+WaveMind is not positioned as "a faster Chroma." Chroma, Qdrant, Pinecone, and Weaviate are vector databases: they store embeddings and return nearest neighbors. That is the right tool for many static RAG workloads.
+
+WaveMind is an agent memory layer. It still uses vector search first, but then applies memory-specific signals that a plain vector store does not model by default:
+
+| memory behavior | Why it matters for agents | WaveMind mechanism |
+|---|---|---|
+| Hot memories | Facts recalled repeatedly should become easier to recall again. | Wave-field hotness and priority updates. |
+| Aging memories | Old low-value facts should fade instead of competing forever. | TTL and decay-aware scoring. |
+| Scoped memory | One user, agent, workspace, or project should not leak into another. | Namespaces and tags. |
+| Explicit forgetting | Agents need deletion, privacy cleanup, and correction workflows. | `forget()` plus SQLite persistence. |
+| Stable restart behavior | A memory system must survive process restarts. | SQLite source of truth, reloadable indexes. |
+| Vector plus memory rank | Semantic similarity is necessary but not sufficient for long-running agents. | k-NN candidates first, wave field as re-ranker. |
+
+The current Chroma benchmark below is intentionally conservative: it compares static retrieval on the same facts and the same hash embeddings. That benchmark is useful, but it does not exercise WaveMind's main product thesis: memory that changes over time as an agent recalls, reinforces, ages, and forgets information.
+
+The benchmark that should decide whether WaveMind is worth using is a dynamic agent-memory benchmark:
+
+| scenario | What should happen |
+|---|---|
+| A user repeats a preference many times. | WaveMind should rank it higher than equally similar but unused facts. |
+| A fact expires via TTL. | WaveMind should suppress it without requiring manual vector cleanup. |
+| A user corrects an old fact. | WaveMind should prefer the newer or reinforced memory. |
+| A query is ambiguous across namespaces. | WaveMind should return only the scoped user's memory. |
+| A long conversation has many irrelevant facts. | WaveMind should preserve useful recall instead of treating all vectors equally. |
+
+In short: static vector search answers "what is nearest?" Agent memory also asks "what is still relevant, reinforced, scoped, and allowed to be remembered?"
+
+## Benchmark
+
+Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
+
+| metric | hash | sentence-transformers |
+|---|---:|---:|
+| precision@1 | 1.00 | 1.00 |
+| precision@3 | 1.00 | 1.00 |
+| avg query | 0.49 ms | 52.84 ms |
+
+Capacity check with the hash encoder:
+
+| memories | precision@1 | precision@3 | avg query |
+|---:|---:|---:|---:|
+| 200 | 1.00 | 1.00 | 0.49 ms |
+| 1000 | 0.88 | 1.00 | 1.50 ms |
+| 5000 | 0.72 | 0.88 | 5.68 ms |
+
+Run locally from a cloned repository:
+
+```sh
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder hash --index numpy
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
+```
+
+Agent-memory benchmark against Chroma:
+
+200 Russian user facts, 50 natural-language questions, same precomputed `HashingTextEncoder` embeddings for WaveMind and Chroma.
+Full machine-readable result: `benchmarks/agent_memory_results.json`.
+
+This is a static retrieval benchmark. It measures baseline ranking and latency, not hotness, TTL, repeated recall, or memory aging.
+
+| engine | precision@1 | precision@3 | avg latency |
+|---|---:|---:|---:|
+| WaveMind | 0.82 | 0.90 | 2.25 ms |
+| Chroma | 0.82 | 0.88 | 0.93 ms |
+
+Run locally from a cloned repository:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
+```
+
+## Comparison
+
+| feature | WaveMind | Chroma | Qdrant |
+|---|---|---|---|
+| Primary role | Agent memory engine | Embedding database | Production vector database |
+| Local SQLite persistence | Yes | Yes | No, separate service/storage |
+| HTTP API | FastAPI included | Included | Included |
+| Dynamic memory priority | Wave-field hotness, TTL, priority | Metadata/filter driven | Payload/filter driven |
+| Built-in forgetting | TTL and explicit forget | Manual delete/filtering | Manual delete/filtering |
+| Best fit | Small to medium agent memory with dynamic recall | Local RAG apps and prototypes | Large-scale vector search |
+| Scale target today | Up to 1000 optimal on NumPy, FAISS recommended beyond 5000 | Larger than WaveMind local mode | Production scale |
+
+WaveMind is not trying to replace dedicated vector databases at scale. The intended product gap is dynamic priority: frequently used memories can become hotter while old or low-priority memories fade. For static RAG over large document collections, use a mature vector database. For agent memory that needs persistence, scoped recall, TTL, forgetting, and reinforcement, WaveMind is designed to sit above or beside the vector index.
+
+## Known Limitations
+
+- Optimal capacity on the current NumPy exact index is up to 1000 records.
+- At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
+- For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
+- `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.
+
+## 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.
+- Better semantic query expansion for short and ambiguous queries.
+- Namespace quotas, backups, and daemon hardening for SaaS use.
+- Webhook on recall for agent runtimes.
+- OHLCV pattern-memory experiments for market research and backtests.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

{wavemind-2.0.0 → wavemind-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavemind"
-version = "2.0.0"
+version = "2.0.2"
 description = "Persistent dynamic memory engine with vector search and wave-field re-ranking"
 readme = "README.md"
 license = "MIT"
@@ -28,6 +28,12 @@ indexes = [
   "annoy>=1.17",
   "faiss-cpu>=1.8; platform_system != 'Windows'",
 ]
+bench = [
+  "chromadb>=1.0",
+]
+langchain = [
+  "langchain-classic>=1.0",
+]
 dev = [
   "pytest>=8",
   "httpx>=0.27",

wavemind-2.0.2/tests/test_agent_memory_benchmark.py

@@ -0,0 +1,74 @@
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_agent_memory_scenario_has_requested_shape():
+    from benchmarks.agent_memory_benchmark import build_agent_memory_scenario
+
+    scenario = build_agent_memory_scenario()
+    fact_ids = {fact.id for fact in scenario.facts}
+
+    assert len(scenario.facts) == 200
+    assert len(scenario.queries) == 50
+    assert len(fact_ids) == 200
+    assert all(query.expected_id in fact_ids for query in scenario.queries)
+    assert any("бюджет" in query.text.lower() for query in scenario.queries)
+    assert any("зовут" in query.text.lower() for query in scenario.queries)
+
+
+def test_agent_memory_metrics_use_expected_fact_in_top_k():
+    from benchmarks.agent_memory_benchmark import AgentQuery, compute_metrics
+
+    queries = [
+        AgentQuery(id="q1", text="как зовут пользователя?", expected_id="fact_name"),
+        AgentQuery(id="q2", text="что знаем про бюджет?", expected_id="fact_budget"),
+    ]
+    rankings = {
+        "q1": ["fact_name", "fact_role", "fact_budget"],
+        "q2": ["fact_role", "fact_budget", "fact_name"],
+    }
+
+    metrics = compute_metrics(queries, rankings, [1.0, 3.0])
+
+    assert metrics.precision_at_1 == 0.5
+    assert metrics.precision_at_3 == 1.0
+    assert metrics.avg_latency_ms == 2.0
+
+
+def test_agent_memory_benchmark_cli_writes_json_for_wavemind(tmp_path):
+    output = tmp_path / "agent-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/agent_memory_benchmark.py",
+            "--engines",
+            "wavemind",
+            "--facts",
+            "20",
+            "--queries",
+            "5",
+            "--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"]["facts"] == 20
+    assert payload["scenario"]["queries"] == 5
+    assert payload["results"][0]["engine"] == "WaveMind"
+    assert "precision_at_1" in payload["results"][0]
+    assert "avg_latency_ms" in payload["results"][0]

wavemind-2.0.2/tests/test_langchain_integration.py

@@ -0,0 +1,86 @@
+import subprocess
+import sys
+from pathlib import Path
+
+from wavemind import HashingTextEncoder, WaveMind
+
+
+def make_memory(tmp_path):
+    from wavemind.integrations.langchain import WaveMindMemory
+
+    mind = WaveMind(
+        db_path=tmp_path / "langchain.sqlite3",
+        encoder=HashingTextEncoder(vector_dim=128),
+        width=32,
+        height=32,
+        layers=2,
+        evolve_on_feed=1,
+        score_threshold=0.0,
+    )
+    return WaveMindMemory(memory=mind, top_k=3)
+
+
+def test_wavemind_memory_exposes_langchain_base_memory_methods(tmp_path):
+    memory = make_memory(tmp_path)
+
+    assert memory.memory_variables == ["history"]
+    assert hasattr(memory, "load_memory_variables")
+    assert hasattr(memory, "save_context")
+    assert hasattr(memory, "clear")
+
+
+def test_wavemind_memory_saves_context_and_recalls_relevant_history(tmp_path):
+    memory = make_memory(tmp_path)
+
+    memory.save_context(
+        {"input": "my name is Andrey and I am a trader"},
+        {"output": "remembered"},
+    )
+    loaded = memory.load_memory_variables({"input": "what is my name?"})
+
+    assert set(loaded) == {"history"}
+    assert "Andrey" in loaded["history"]
+    assert "trader" in loaded["history"]
+
+
+def test_wavemind_memory_supports_custom_input_output_keys(tmp_path):
+    memory = make_memory(tmp_path)
+    memory.input_key = "question"
+    memory.output_key = "answer"
+
+    memory.save_context(
+        {"question": "the user budget is 2000 dollars", "irrelevant": "skip me"},
+        {"answer": "saved", "other": "ignore me"},
+    )
+    loaded = memory.load_memory_variables({"question": "what is the budget?"})
+
+    assert "2000 dollars" in loaded["history"]
+    assert "skip me" not in loaded["history"]
+    assert "ignore me" not in loaded["history"]
+
+
+def test_wavemind_memory_clear_forgets_namespace(tmp_path):
+    memory = make_memory(tmp_path)
+
+    memory.save_context({"input": "Andrey likes short answers"}, {"output": "ok"})
+    assert "Andrey" in memory.load_memory_variables({"input": "short answers"})["history"]
+
+    memory.clear()
+
+    assert memory.load_memory_variables({"input": "short answers"})["history"] == ""
+
+
+def test_langchain_example_runs_without_external_keys():
+    project_root = Path(__file__).resolve().parents[1]
+
+    result = subprocess.run(
+        [sys.executable, "examples/langchain_memory.py"],
+        cwd=project_root,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+    assert "WaveMindMemory history:" in result.stdout
+    assert "Andrey" in result.stdout

{wavemind-2.0.0 → wavemind-2.0.2}/tests/test_packaging_files.py

@@ -8,6 +8,20 @@ def test_sentence_extra_is_available_for_install_scripts():
     assert '"sentence-transformers>=3"' in pyproject
 
 
+def test_benchmark_extra_installs_chroma():
+    pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
+
+    assert "bench = [" in pyproject
+    assert '"chromadb>=1.0"' in pyproject
+
+
+def test_langchain_extra_installs_classic_memory_api():
+    pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
+
+    assert "langchain = [" in pyproject
+    assert '"langchain-classic>=1.0"' in pyproject
+
+
 def test_install_scripts_create_venv_and_install_sentence_extra():
     install_sh = Path("install.sh").read_text(encoding="utf-8")
     install_bat = Path("install.bat").read_text(encoding="utf-8")

wavemind-2.0.2/wavemind/integrations/__init__.py

@@ -0,0 +1,2 @@
+"""Optional integrations for external agent frameworks."""
+