wavemind 2.0.0__tar.gz

wavemind-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WaveMind contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wavemind-2.0.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: wavemind
+Version: 2.0.0
+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: 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
+
+```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
+
+```sh
+python -m pip install -e .
+wavemind remember "Andrey is a trader" --namespace demo
+wavemind query "trader" --namespace demo
+```
+
+This creates `wavemind.sqlite3` in your current working directory.
+
+For sentence-transformer embeddings:
+
+```sh
+python -m pip install -e ".[sentence]"
+wavemind --encoder sentence remember "Andrey is a trader" --namespace demo
+wavemind --encoder sentence query "What does Andrey do?" --namespace demo
+```
+
+One-file setup scripts are also included:
+
+```sh
+sh install.sh
+```
+
+```bat
+install.bat
+```
+
+## 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:
+
+```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
+```
+
+## 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. Its difference is dynamic priority: frequently used memories can become hotter while old or low-priority memories fade.
+
+## 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 bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+
+## Roadmap
+
+- FAISS-first production index path with persisted index rebuilds.
+- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- 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/README.md

@@ -0,0 +1,107 @@
+# 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
+
+```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
+
+```sh
+python -m pip install -e .
+wavemind remember "Andrey is a trader" --namespace demo
+wavemind query "trader" --namespace demo
+```
+
+This creates `wavemind.sqlite3` in your current working directory.
+
+For sentence-transformer embeddings:
+
+```sh
+python -m pip install -e ".[sentence]"
+wavemind --encoder sentence remember "Andrey is a trader" --namespace demo
+wavemind --encoder sentence query "What does Andrey do?" --namespace demo
+```
+
+One-file setup scripts are also included:
+
+```sh
+sh install.sh
+```
+
+```bat
+install.bat
+```
+
+## 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:
+
+```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
+```
+
+## 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. Its difference is dynamic priority: frequently used memories can become hotter while old or low-priority memories fade.
+
+## 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 bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+
+## Roadmap
+
+- FAISS-first production index path with persisted index rebuilds.
+- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- 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/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wavemind"
+version = "2.0.0"
+description = "Persistent dynamic memory engine with vector search and wave-field re-ranking"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+  "numpy>=1.24",
+  "fastapi>=0.110",
+  "uvicorn[standard]>=0.27",
+  "pydantic>=2",
+  "pypdf>=4",
+]
+
+[project.optional-dependencies]
+sentence = [
+  "sentence-transformers>=3",
+]
+ml = [
+  "sentence-transformers>=3",
+]
+indexes = [
+  "annoy>=1.17",
+  "faiss-cpu>=1.8; platform_system != 'Windows'",
+]
+dev = [
+  "pytest>=8",
+  "httpx>=0.27",
+]
+
+[project.scripts]
+wavemind = "wavemind.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/CaspianG/wavemind"
+Repository = "https://github.com/CaspianG/wavemind"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["wavemind*"]

wavemind-2.0.0/setup.cfg

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

wavemind-2.0.0/tests/test_api.py

@@ -0,0 +1,52 @@
+from fastapi.testclient import TestClient
+
+from wavemind import HashingTextEncoder, WaveMind
+from wavemind.api import create_app
+
+
+def test_fastapi_remember_query_forget_and_stats(tmp_path):
+    mind = WaveMind(
+        db_path=tmp_path / "api.sqlite3",
+        width=32,
+        height=32,
+        layers=2,
+        encoder=HashingTextEncoder(vector_dim=64),
+        score_threshold=0.05,
+    )
+    client = TestClient(create_app(mind=mind))
+
+    remember = client.post(
+        "/remember",
+        json={
+            "text": "кошка сидит на подоконнике",
+            "namespace": "pets",
+            "tags": ["animal"],
+            "ttl_seconds": 3600,
+        },
+    )
+    assert remember.status_code == 200
+    memory_id = remember.json()["id"]
+
+    query = client.post(
+        "/query",
+        json={"text": "кошка", "namespace": "pets", "top_k": 3, "tags": ["animal"]},
+    )
+    assert query.status_code == 200
+    assert query.json()["results"][0]["id"] == memory_id
+    assert query.json()["results"][0]["text"] == "кошка сидит на подоконнике"
+
+    stats = client.get("/stats", params={"namespace": "pets"})
+    assert stats.status_code == 200
+    assert stats.json()["active_memories"] == 1
+
+    deleted = client.request(
+        "DELETE",
+        "/forget",
+        json={"id": memory_id, "namespace": "pets"},
+    )
+    assert deleted.status_code == 200
+    assert deleted.json()["deleted"] == 1
+
+    empty = client.post("/query", json={"text": "кошка", "namespace": "pets"})
+    assert empty.json()["results"] == []
+

wavemind-2.0.0/tests/test_api_process_persistence.py

@@ -0,0 +1,112 @@
+import socket
+import subprocess
+import sys
+import time
+
+import httpx
+
+
+def free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def start_api(db_path, port: int) -> subprocess.Popen:
+    return subprocess.Popen(
+        [
+            sys.executable,
+            "-m",
+            "wavemind",
+            "--db",
+            str(db_path),
+            "--score-threshold",
+            "0.05",
+            "serve",
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(port),
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+    )
+
+
+def wait_until_ready(base_url: str, process: subprocess.Popen) -> None:
+    deadline = time.time() + 20
+    last_error = None
+    with httpx.Client(trust_env=False) as client:
+        while time.time() < deadline:
+            if process.poll() is not None:
+                stdout, stderr = process.communicate(timeout=1)
+                raise AssertionError(
+                    f"API process exited early with {process.returncode}\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}"
+                )
+            try:
+                response = client.get(f"{base_url}/stats", timeout=1)
+                if response.status_code == 200:
+                    return
+            except (httpx.NetworkError, httpx.TimeoutException) as exc:
+                last_error = exc
+            time.sleep(0.25)
+    raise AssertionError(f"API did not become ready: {last_error}")
+
+
+def kill_process(process: subprocess.Popen) -> None:
+    if process.poll() is not None:
+        return
+    process.kill()
+    try:
+        process.communicate(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.terminate()
+        process.communicate(timeout=5)
+
+
+def test_api_persists_10_memories_across_process_restart(tmp_path):
+    db_path = tmp_path / "persistent.sqlite3"
+    port = free_port()
+    base_url = f"http://127.0.0.1:{port}"
+    memories = [
+        f"wmrestart{i:02d} контрольная память номер {i} сохраняется в sqlite"
+        for i in range(10)
+    ]
+
+    first = start_api(db_path, port)
+    try:
+        wait_until_ready(base_url, first)
+        with httpx.Client(trust_env=False) as client:
+            for text in memories:
+                response = client.post(
+                    f"{base_url}/remember",
+                    json={"text": text, "namespace": "restart", "tags": ["persistence"]},
+                    timeout=5,
+                )
+                assert response.status_code == 200
+                assert response.json()["id"] > 0
+    finally:
+        kill_process(first)
+
+    second = start_api(db_path, port)
+    try:
+        wait_until_ready(base_url, second)
+        with httpx.Client(trust_env=False) as client:
+            for i, expected in enumerate(memories):
+                response = client.post(
+                    f"{base_url}/query",
+                    json={
+                        "text": f"wmrestart{i:02d}",
+                        "namespace": "restart",
+                        "tags": ["persistence"],
+                        "top_k": 3,
+                    },
+                    timeout=5,
+                )
+                assert response.status_code == 200
+                texts = [item["text"] for item in response.json()["results"]]
+                assert expected in texts
+    finally:
+        kill_process(second)

wavemind-2.0.0/tests/test_cli_smoke.py

@@ -0,0 +1,77 @@
+import subprocess
+import sys
+import json
+import os
+from pathlib import Path
+
+
+def run_cli(*args, cwd=None):
+    env = os.environ.copy()
+    project_root = Path(__file__).resolve().parents[1]
+    env["PYTHONPATH"] = str(project_root) + os.pathsep + env.get("PYTHONPATH", "")
+    return subprocess.run(
+        [sys.executable, "-m", "wavemind", *args],
+        cwd=cwd,
+        env=env,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+
+def test_module_cli_remember_query_stats_and_backup(tmp_path):
+    db_path = tmp_path / "cli.sqlite3"
+    backup_path = tmp_path / "backup.sqlite3"
+
+    remembered = run_cli(
+        "--db",
+        str(db_path),
+        "remember",
+        "кошка спит на окне",
+        "--namespace",
+        "cli",
+        "--tag",
+        "animal",
+    )
+    assert "remembered id=" in remembered.stdout
+
+    queried = run_cli("--db", str(db_path), "query", "кошка", "--namespace", "cli")
+    assert "кошка спит на окне" in queried.stdout
+
+    stats = run_cli("--db", str(db_path), "stats", "--namespace", "cli")
+    assert "active_memories: 1" in stats.stdout
+
+    backup = run_cli("--db", str(db_path), "backup", "--out", str(backup_path))
+    assert "backup:" in backup.stdout
+    assert backup_path.exists()
+
+
+def test_legacy_script_delegates_to_new_cli(tmp_path):
+    result = subprocess.run(
+        [sys.executable, "wavemind_v2.py", "--help"],
+        cwd=".",
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+    assert "WaveMind" in result.stdout
+
+
+def test_cli_benchmark_seeds_all_synthetic_cases(tmp_path):
+    db_path = tmp_path / "bench.sqlite3"
+
+    result = run_cli("--db", str(db_path), "benchmark")
+    report = json.loads(result.stdout)
+
+    assert report["capacity"] == 4
+    assert report["recall_at_k"] == 1.0
+
+
+def test_cli_default_database_is_created_in_working_directory(tmp_path):
+    result = run_cli("remember", "portable default database memory", cwd=tmp_path)
+
+    assert "remembered id=" in result.stdout
+    assert (tmp_path / "wavemind.sqlite3").exists()
+    assert not (tmp_path / "data").exists()

wavemind-2.0.0/tests/test_core_persistence.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+
+from wavemind import HashingTextEncoder, QueryResult, WaveMind
+
+
+def make_mind(db_path: Path, **kwargs) -> WaveMind:
+    params = {
+        "db_path": db_path,
+        "width": 32,
+        "height": 32,
+        "layers": 2,
+        "encoder": HashingTextEncoder(vector_dim=64),
+        "score_threshold": 0.05,
+    }
+    params.update(kwargs)
+    return WaveMind(**params)
+
+
+def test_remember_query_persist_and_load(tmp_path):
+    db_path = tmp_path / "memory.sqlite3"
+    mind = make_mind(db_path)
+
+    first_id = mind.remember(
+        "кошка сидит на подоконнике",
+        namespace="pets",
+        tags=["animal", "home"],
+        metadata={"source": "unit"},
+    )
+    mind.remember("собака лает во дворе", namespace="pets", tags=["animal"])
+    mind.remember("market signal breaks resistance", namespace="markets", tags=["trading"])
+    mind.save()
+
+    results = mind.query("кошка", namespace="pets", top_k=2)
+    assert isinstance(results[0], QueryResult)
+    assert results[0].id == first_id
+    assert results[0].text == "кошка сидит на подоконнике"
+    assert results[0].namespace == "pets"
+    assert set(results[0].tags) == {"animal", "home"}
+
+    reloaded = make_mind(db_path)
+    reloaded.load()
+    reloaded_results = reloaded.query("кошка", namespace="pets", top_k=1)
+    assert reloaded_results[0].text == "кошка сидит на подоконнике"
+
+
+def test_namespace_tags_threshold_ttl_and_forget(tmp_path):
+    db_path = tmp_path / "memory.sqlite3"
+    mind = make_mind(db_path, score_threshold=0.20)
+
+    keep_id = mind.remember("alpha project launch checklist", namespace="work", tags=["project"])
+    mind.remember("alpha private journal note", namespace="personal", tags=["journal"])
+    expired_id = mind.remember(
+        "alpha obsolete task",
+        namespace="work",
+        tags=["project"],
+        ttl_seconds=-1,
+    )
+
+    work_results = mind.query("alpha", namespace="work", tags=["project"], top_k=5)
+    assert [result.id for result in work_results] == [keep_id]
+    assert all(result.score >= 0.20 for result in work_results)
+
+    stats = mind.stats(namespace="work")
+    assert stats["active_memories"] == 1
+    assert stats["expired_memories"] == 1
+
+    removed = mind.forget(id=keep_id, namespace="work")
+    assert removed == 1
+    assert mind.query("alpha", namespace="work", top_k=5) == []
+
+    purged = mind.purge_expired()
+    assert purged == 1
+    assert mind.store.get(expired_id) is None

wavemind-2.0.0/tests/test_examples.py

@@ -0,0 +1,53 @@
+import importlib.util
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+def load_example():
+    path = Path("examples/agent_with_memory.py")
+    spec = importlib.util.spec_from_file_location("agent_with_memory", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_agent_example_uses_environment_key_not_hardcoded_secret():
+    text = Path("examples/agent_with_memory.py").read_text(encoding="utf-8")
+
+    assert "sk-or-v1-" not in text
+    assert "OPENROUTER_API_KEY" in text
+    assert "https://openrouter.ai/api/v1/chat/completions" in text
+
+
+def test_offline_demo_prints_recall_flow():
+    env = os.environ.copy()
+    project_root = Path(__file__).resolve().parents[1]
+    env["PYTHONPATH"] = str(project_root) + os.pathsep + env.get("PYTHONPATH", "")
+
+    result = subprocess.run(
+        [sys.executable, "examples/demo.py"],
+        cwd=project_root,
+        env=env,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+    assert '✓ Remembered: "' in result.stdout
+    assert 'Query: "' in result.stdout
+    assert "→ Result 1" in result.stdout
+    assert "→ Result 2" in result.stdout
+
+
+def test_agent_example_remembers_and_recalls_user_profile(tmp_path):
+    module = load_example()
+    memory = module.build_memory(tmp_path / "agent.sqlite3")
+
+    module.observe_user_message(memory, "меня зовут Андрей, я трейдер")
+    context = module.recall_memory(memory, "как меня зовут?")
+
+    assert "Андрей" in context
+    assert "трейдер" in context