grafeo-memory 0.2.0__tar.gz → 0.2.1__tar.gz

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/CHANGELOG.md

@@ -5,6 +5,42 @@ All notable changes to grafeo-memory are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-04-07
+
+Test quality, error surfacing, documentation improvements, and shared database support.
+
+### Added
+
+- **Shared database support**: `MemoryManager` and `AsyncMemoryManager` accept an optional `db=` keyword argument to inject an existing `GrafeoDB` instance instead of creating one internally. `close()` respects ownership and leaves externally provided databases open ([#18](https://github.com/GrafeoDB/grafeo-memory/issues/18), [#19](https://github.com/GrafeoDB/grafeo-memory/pull/19), thanks [@Michaelzag](https://github.com/Michaelzag))
+- **Multi-tenant safety**: all internal operations are now scoped to Memory and Entity nodes, making it safe to share a database with non-memory data
+
+### Fixed
+
+- **Graph metrics pollution**: `_recompute_graph_metrics()` now writes `_pagerank`, `_betweenness`, `_community` only to Memory/Entity nodes instead of every node in the database
+- **Unlabeled Cypher queries**: `temporal_chain()` and `_get_node_relations()` now require `:Memory` labels on match patterns, preventing traversal from foreign nodes
+- **N+1 entity lookup**: `_find_or_create_entity` and `graph_search` replaced global `find_nodes_by_property` + Python filtering with single label-scoped Cypher queries, reducing FFI crossings
+- **Stats data leak**: `_stats_impl()` no longer exposes raw `db.info()`, returning only memory-scoped counts. MCP `memory://stats` resource now delegates to the manager's scoped stats
+- **Error surfacing tests**: broken embedder on add/search now verified to raise, not silently return empty results
+- **Persistence lifecycle tests**: write, close, reopen round-trip with `tmp_path`
+- **Multi-session regression tests**: sequential open/close/open guards against event loop corruption
+- **Concurrency tests**: concurrent async adds for same user (lock verification) and different users (isolation)
+- **Reconciliation boundary test**: controlled embeddings at threshold boundary verify UPDATE triggers
+- **History ordering test**: LEADS_TO chain verified for session-order retrieval
+- **Delete cascade test**: orphaned entity behavior after memory deletion documented
+- **Memory type filter test**: search with `memory_type` filter verified
+- **Summarize test**: non-empty summary from related memories
+- **MCP tool smoke tests**: all tool functions imported and called with mock context
+
+### Changed
+
+- `test_search_with_broken_embedder` now uses `pytest.raises` instead of silently passing
+- Concurrency tests use `async with` context manager for guaranteed cleanup
+- Error surfacing tests wrapped in `try/finally` for manager cleanup
+- Shared `make_manager` helper extracted to `conftest.py`
+- README: added model compatibility table (OpenAI, Anthropic, Mistral, Groq, Google)
+- README: documented reconciliation threshold tuning and `history()` return type
+- 435 tests passing
+
 ## [0.2.0] - 2026-03-26
 
 Temporal reasoning, multi-hop search and engine integration for better long running memory performance.

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grafeo-memory
-Version: 0.2.0
+Version: 0.2.1
 Summary: AI memory layer powered by GrafeoDB's hybrid graph and vector database
 Project-URL: Homepage, https://github.com/GrafeoDB/grafeo-memory
 Project-URL: Repository, https://github.com/GrafeoDB/grafeo-memory
@@ -183,6 +183,18 @@ MemoryManager("google-gla:gemini-2.0-flash", config, embedder=embedder)
 
 Both accept an optional `model` parameter to override the default.
 
+### Which model works best?
+
+| Provider | Combined extraction | Individual extraction | Notes |
+| --- | --- | --- | --- |
+| OpenAI (gpt-4o-mini) | Works | Works | Recommended default |
+| Anthropic (claude-sonnet) | Works | Works | Untested in CI |
+| Mistral (mistral-small) | Falls back | Works | 3 API calls instead of 1 |
+| Groq | Unknown | Unknown | Needs testing |
+| Google | Unknown | Unknown | Needs testing |
+
+grafeo-memory tries a single "combined" LLM call first (facts + entities + relations in one schema). If the model cannot handle the combined schema, it falls back to separate calls automatically. Mistral models typically trigger this fallback, which means 3 API calls per `add()` instead of 1. The fallback is silent (logged at DEBUG level, no traceback printed).
+
 ## Custom Embeddings
 
 Implement the `EmbeddingClient` protocol to use any embedding provider:
@@ -306,7 +318,7 @@ config = MemoryConfig(instrument=InstrumentationSettings(
 - `.delete(memory_id)` → `bool`
 - `.delete_all(user_id=None)` → `int` (count deleted)
 - `.summarize(user_id=None, *, preserve_recent=5, batch_size=20)` → `AddResult`
-- `.history(memory_id)` → `list[HistoryEntry]`
+- `.history(memory_id)` → `list[HistoryEntry]`: returns change history sorted by timestamp (oldest first)
 - `.set_importance(memory_id, importance)` → `bool`
 - `.close()`: close the database
 
@@ -318,7 +330,7 @@ Use as a context manager: `with MemoryManager(...) as memory:`. Multiple session
 - `user_id`: default user scope (default `"default"`)
 - `session_id`: default session scope
 - `agent_id`: default agent scope
-- `reconciliation_threshold`: minimum similarity for reconciliation candidates (default 0.3)
+- `reconciliation_threshold`: minimum cosine similarity (0.0 to 1.0) for a memory to be considered a reconciliation candidate during `add()`. Lower values find more candidates, higher values require closer matches. At 0.3 (default), loosely related memories are considered. At 0.7+, only very similar memories trigger UPDATE/DELETE decisions
 - `search_min_score`: minimum score for search results, 0.0 returns everything (default 0.0)
 - `agreement_bonus`: score boost when both vector and graph find the same memory (default 0.1)
 - `embedding_dimensions`: vector dimensions (default 1536)
@@ -340,7 +352,7 @@ Use as a context manager: `with MemoryManager(...) as memory:`. Multiple session
 - **`SearchResponse`**: list subclass of `SearchResult`, with `.usage` for LLM token counts
 - **`MemoryEvent`**: `.action` (ADD/UPDATE/DELETE/NONE), `.memory_id`, `.text`, `.old_text`
 - **`SearchResult`**: `.memory_id`, `.text`, `.score`, `.user_id`, `.metadata`, `.relations`, `.memory_type`
-- **`HistoryEntry`**: `.event`, `.old_text`, `.new_text`, `.timestamp`, `.actor_id`, `.role`
+- **`HistoryEntry`**: `.event` (ADD/UPDATE/DELETE), `.old_text`, `.new_text`, `.timestamp` (epoch ms), `.actor_id`, `.role`. Returned sorted by timestamp ascending (oldest first)
 
 ### Iteration
 

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/README.md

@@ -145,6 +145,18 @@ MemoryManager("google-gla:gemini-2.0-flash", config, embedder=embedder)
 
 Both accept an optional `model` parameter to override the default.
 
+### Which model works best?
+
+| Provider | Combined extraction | Individual extraction | Notes |
+| --- | --- | --- | --- |
+| OpenAI (gpt-4o-mini) | Works | Works | Recommended default |
+| Anthropic (claude-sonnet) | Works | Works | Untested in CI |
+| Mistral (mistral-small) | Falls back | Works | 3 API calls instead of 1 |
+| Groq | Unknown | Unknown | Needs testing |
+| Google | Unknown | Unknown | Needs testing |
+
+grafeo-memory tries a single "combined" LLM call first (facts + entities + relations in one schema). If the model cannot handle the combined schema, it falls back to separate calls automatically. Mistral models typically trigger this fallback, which means 3 API calls per `add()` instead of 1. The fallback is silent (logged at DEBUG level, no traceback printed).
+
 ## Custom Embeddings
 
 Implement the `EmbeddingClient` protocol to use any embedding provider:
@@ -268,7 +280,7 @@ config = MemoryConfig(instrument=InstrumentationSettings(
 - `.delete(memory_id)` → `bool`
 - `.delete_all(user_id=None)` → `int` (count deleted)
 - `.summarize(user_id=None, *, preserve_recent=5, batch_size=20)` → `AddResult`
-- `.history(memory_id)` → `list[HistoryEntry]`
+- `.history(memory_id)` → `list[HistoryEntry]`: returns change history sorted by timestamp (oldest first)
 - `.set_importance(memory_id, importance)` → `bool`
 - `.close()`: close the database
 
@@ -280,7 +292,7 @@ Use as a context manager: `with MemoryManager(...) as memory:`. Multiple session
 - `user_id`: default user scope (default `"default"`)
 - `session_id`: default session scope
 - `agent_id`: default agent scope
-- `reconciliation_threshold`: minimum similarity for reconciliation candidates (default 0.3)
+- `reconciliation_threshold`: minimum cosine similarity (0.0 to 1.0) for a memory to be considered a reconciliation candidate during `add()`. Lower values find more candidates, higher values require closer matches. At 0.3 (default), loosely related memories are considered. At 0.7+, only very similar memories trigger UPDATE/DELETE decisions
 - `search_min_score`: minimum score for search results, 0.0 returns everything (default 0.0)
 - `agreement_bonus`: score boost when both vector and graph find the same memory (default 0.1)
 - `embedding_dimensions`: vector dimensions (default 1536)
@@ -302,7 +314,7 @@ Use as a context manager: `with MemoryManager(...) as memory:`. Multiple session
 - **`SearchResponse`**: list subclass of `SearchResult`, with `.usage` for LLM token counts
 - **`MemoryEvent`**: `.action` (ADD/UPDATE/DELETE/NONE), `.memory_id`, `.text`, `.old_text`
 - **`SearchResult`**: `.memory_id`, `.text`, `.score`, `.user_id`, `.metadata`, `.relations`, `.memory_type`
-- **`HistoryEntry`**: `.event`, `.old_text`, `.new_text`, `.timestamp`, `.actor_id`, `.role`
+- **`HistoryEntry`**: `.event` (ADD/UPDATE/DELETE), `.old_text`, `.new_text`, `.timestamp` (epoch ms), `.actor_id`, `.role`. Returned sorted by timestamp ascending (oldest first)
 
 ### Iteration
 

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "grafeo-memory"
-version = "0.2.0"
+version = "0.2.1"
 description = "AI memory layer powered by GrafeoDB's hybrid graph and vector database"
 readme = "README.md"
 license = "Apache-2.0"

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/src/grafeo_memory/manager.py

@@ -58,6 +58,7 @@ class _MemoryCore:
         *,
         embedder: EmbeddingClient,
         reranker: object | None = None,
+        db: GrafeoDBProtocol | None = None,
     ):
         import grafeo
 
@@ -67,7 +68,10 @@ class _MemoryCore:
         self._reranker = reranker
 
         self._db: GrafeoDBProtocol
-        if self._config.db_path:
+        self._db_external = db is not None
+        if db is not None:
+            self._db = db
+        elif self._config.db_path:
             self._db = grafeo.GrafeoDB(self._config.db_path)
         else:
             self._db = grafeo.GrafeoDB()
@@ -84,6 +88,14 @@ class _MemoryCore:
             Agent.instrument_all(self._config.instrument if self._config.instrument is not True else True)
 
     def _ensure_indexes(self) -> None:
+        """Create indexes for efficient memory queries.
+
+        Vector and text indexes are label-scoped to Memory nodes. Property
+        indexes (user_id, created_at, memory_type, name) are database-wide
+        because GrafeoDB's ``create_property_index`` does not support
+        label-scoped indexing. In a shared database these indexes will also
+        cover non-memory nodes — harmless but slightly wasteful.
+        """
         vp = self._config.vector_property
         tp = self._config.text_property
         dims = self._config.embedding_dimensions
@@ -108,7 +120,7 @@ class _MemoryCore:
         except Exception:
             logger.debug("Text index creation deferred or already exists")
 
-        # Property indexes for fast filtered lookups
+        # Property indexes for fast filtered lookups (database-wide; see docstring).
         for prop in ("user_id", "created_at", "memory_type"):
             with contextlib.suppress(Exception):
                 self._db.create_property_index(prop)
@@ -130,10 +142,15 @@ class _MemoryCore:
     def close(self) -> None:
         """Close the database connection.
 
+        If the database was externally provided via the ``db`` parameter,
+        it is **not** closed here — the caller owns its lifecycle.
+
         The async runner is intentionally NOT closed here — it is shared across
         sessions and cleaned up automatically at process exit via atexit. Closing
         it per-session corrupts httpx/anyio transport state on Windows.
         """
+        if self._db_external:
+            return
         if hasattr(self._db, "close"):
             self._db.close()  # ty: ignore[call-non-callable]
 
@@ -1162,7 +1179,7 @@ class _MemoryCore:
 
         if direction in ("forward", "both"):
             query = (
-                f"MATCH (m)-[:LEADS_TO*1..{max_depth}]->(rest:Memory) "
+                f"MATCH (m:{MEMORY_LABEL})-[:{LEADS_TO_EDGE}*1..{max_depth}]->(rest:{MEMORY_LABEL}) "
                 f"WHERE id(m) = $mid{user_filter} "
                 f"RETURN id(rest), rest.text, rest.created_at, rest.session_id "
                 f"ORDER BY rest.created_at"
@@ -1192,7 +1209,7 @@ class _MemoryCore:
 
         if direction in ("backward", "both"):
             query = (
-                f"MATCH (rest:Memory)-[:LEADS_TO*1..{max_depth}]->(m) "
+                f"MATCH (rest:{MEMORY_LABEL})-[:{LEADS_TO_EDGE}*1..{max_depth}]->(m:{MEMORY_LABEL}) "
                 f"WHERE id(m) = $mid{user_filter} "
                 f"RETURN id(rest), rest.text, rest.created_at, rest.session_id "
                 f"ORDER BY rest.created_at"
@@ -1247,6 +1264,10 @@ class _MemoryCore:
         Runs pagerank, betweenness centrality, and louvain community detection.
         Results are stored as node properties for fast access during search scoring.
         Only runs when enable_graph_algorithms is True and the graph has changed.
+
+        Only Memory and Entity nodes are updated. Algorithm computation may span
+        the full graph (GrafeoDB API limitation), so scores can be influenced by
+        non-memory topology when using a shared database.
         """
         if not self._config.enable_graph_algorithms or not self._graph_dirty:
             return
@@ -1256,21 +1277,32 @@ class _MemoryCore:
             logger.debug("Graph algorithms not available on this db instance")
             return
 
+        # Collect IDs of nodes we own so we only write to Memory/Entity nodes.
+        owned_ids: set[int] = set()
+        for node_id, _ in self._db.get_nodes_by_label(MEMORY_LABEL):
+            owned_ids.add(node_id)
+        for node_id, _ in self._db.get_nodes_by_label(ENTITY_LABEL):
+            owned_ids.add(node_id)
+        if not owned_ids:
+            return
+
         algos = self._db.algorithms
 
         try:
             ranks = algos.pagerank(0.85, 100, 1e-6)  # ty: ignore[unresolved-attribute]
             for node_id, score in ranks.items():
-                with contextlib.suppress(Exception):
-                    self._db.set_node_property(node_id, "_pagerank", score)
+                if node_id in owned_ids:
+                    with contextlib.suppress(Exception):
+                        self._db.set_node_property(node_id, "_pagerank", score)
         except Exception:
             logger.debug("pagerank computation failed", exc_info=True)
 
         try:
             centrality = algos.betweenness_centrality(True)  # ty: ignore[unresolved-attribute]
             for node_id, score in centrality.items():
-                with contextlib.suppress(Exception):
-                    self._db.set_node_property(node_id, "_betweenness", score)
+                if node_id in owned_ids:
+                    with contextlib.suppress(Exception):
+                        self._db.set_node_property(node_id, "_betweenness", score)
         except Exception:
             logger.debug("betweenness_centrality computation failed", exc_info=True)
 
@@ -1278,8 +1310,9 @@ class _MemoryCore:
             result = algos.louvain(1.0)  # ty: ignore[unresolved-attribute]
             communities = result.get("communities", {}) if isinstance(result, dict) else {}
             for node_id, community_id in communities.items():
-                with contextlib.suppress(Exception):
-                    self._db.set_node_property(node_id, "_community", community_id)
+                if node_id in owned_ids:
+                    with contextlib.suppress(Exception):
+                        self._db.set_node_property(node_id, "_community", community_id)
         except Exception:
             logger.debug("louvain community detection failed", exc_info=True)
 
@@ -1324,19 +1357,17 @@ class _MemoryCore:
 
     def _find_or_create_entity(self, entity: Entity, user_id: str) -> int:
         try:
-            nodes = self._db.find_nodes_by_property("name", entity.name)
+            rows = self._db.execute(
+                f"MATCH (e:{ENTITY_LABEL}) WHERE e.name = $name AND e.user_id = $uid RETURN id(e)",
+                {"name": entity.name, "uid": user_id},
+            )
+            for row in rows:
+                if isinstance(row, dict):
+                    vals = list(row.values())
+                    if vals:
+                        return int(vals[0])
         except Exception:
             logger.warning("_find_or_create_entity: lookup failed for %r", entity.name, exc_info=True)
-            nodes = []
-
-        for nid in nodes:
-            node = self._db.get_node(nid)
-            if node is None:
-                continue
-            props = _get_props(node)
-            labels = node.labels if hasattr(node, "labels") else []
-            if ENTITY_LABEL in labels and props.get("user_id") == user_id:
-                return nid
 
         node = self._db.create_node(
             [ENTITY_LABEL],
@@ -1594,11 +1625,6 @@ class _MemoryCore:
         except Exception:
             pass
 
-        try:
-            db_info = self._db.info()
-        except Exception:
-            db_info = {}
-
         total = semantic + procedural + episodic
         return MemoryStats(
             total_memories=total,
@@ -1607,7 +1633,11 @@ class _MemoryCore:
             episodic_count=episodic,
             entity_count=entity_count,
             relation_count=relation_count,
-            db_info=db_info if isinstance(db_info, dict) else {},
+            db_info={
+                "memory_node_count": total,
+                "entity_node_count": entity_count,
+                "relation_edge_count": relation_count,
+            },
         )
 
     def _set_importance_impl(self, memory_id: str, importance: float) -> bool:

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/src/grafeo_memory/mcp/resources.py

@@ -32,15 +32,17 @@ async def memory_config(ctx: Context[ServerSession, AppContext]) -> str:
 
 @mcp.resource("memory://stats")
 async def memory_stats(ctx: Context[ServerSession, AppContext]) -> str:
-    """Memory system statistics: node/edge counts, database info."""
+    """Memory system statistics: node/edge counts scoped to memory data."""
     manager = ctx.request_context.lifespan_context.manager
-    db = manager._db
-    try:
-        info = db.info()
-    except Exception:
-        info = {}
-    try:
-        stats = db.detailed_stats()  # ty: ignore[unresolved-attribute]
-    except Exception:
-        stats = {}
-    return json.dumps({"db_info": info, "db_stats": stats}, default=str)
+    stats = manager._stats_impl()
+    return json.dumps(
+        {
+            "total_memories": stats.total_memories,
+            "semantic_count": stats.semantic_count,
+            "procedural_count": stats.procedural_count,
+            "episodic_count": stats.episodic_count,
+            "entity_count": stats.entity_count,
+            "relation_count": stats.relation_count,
+        },
+        default=str,
+    )

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/src/grafeo_memory/search/graph.py

@@ -79,26 +79,27 @@ def graph_search(
     seen_memory_ids: set[str] = set()
 
     for entity in entities:
+        # Find Entity nodes by name, scoped to the Entity label and user.
+        entity_nids: list[int] = []
         try:
-            node_ids = db.find_nodes_by_property("name", entity.name)
+            rows = db.execute(
+                f"MATCH (e:{ENTITY_LABEL}) WHERE e.name = $name AND e.user_id = $uid RETURN id(e)",
+                {"name": entity.name, "uid": user_id},
+            )
+            entity_nids = [int(next(iter(r.values()))) for r in rows if isinstance(r, dict) and r]
         except Exception:
-            logger.warning("graph_search: find_nodes_by_property failed for entity=%r", entity.name, exc_info=True)
-            continue
+            logger.warning("graph_search: entity lookup failed for %r", entity.name, exc_info=True)
 
-        # Also try case-insensitive match
-        if not node_ids:
+        # Case-insensitive fallback
+        if not entity_nids:
             with contextlib.suppress(Exception):
-                node_ids = db.find_nodes_by_property("name", entity.name.lower())
-
-        for entity_nid in node_ids:
-            node = db.get_node(entity_nid)
-            if node is None:
-                continue
-            props = _get_props(node)
-            labels = node.labels if hasattr(node, "labels") else []
-            if ENTITY_LABEL not in labels or props.get("user_id") != user_id:
-                continue
+                rows = db.execute(
+                    f"MATCH (e:{ENTITY_LABEL}) WHERE toLower(e.name) = $name AND e.user_id = $uid RETURN id(e)",
+                    {"name": entity.name.lower(), "uid": user_id},
+                )
+                entity_nids = [int(next(iter(r.values()))) for r in rows if isinstance(r, dict) and r]
 
+        for entity_nid in entity_nids:
             # Traverse HAS_ENTITY edges back to Memory nodes
             try:
                 query_str = (

{grafeo_memory-0.2.0 → grafeo_memory-0.2.1}/src/grafeo_memory/search/vector.py

@@ -377,12 +377,12 @@ def _matches_filters(props: dict, filters: dict) -> bool:
 
 def _get_node_relations(db: GrafeoDBProtocol, node_id: int) -> list[dict]:
     """Get relations for a memory node by traversing HAS_ENTITY and RELATION edges."""
-    from ..types import ENTITY_LABEL, HAS_ENTITY_EDGE, RELATION_EDGE
+    from ..types import ENTITY_LABEL, HAS_ENTITY_EDGE, MEMORY_LABEL, RELATION_EDGE
 
     relations: list[dict] = []
     try:
         query = (
-            f"MATCH (m)-[:{HAS_ENTITY_EDGE}]->(e:{ENTITY_LABEL})"
+            f"MATCH (m:{MEMORY_LABEL})-[:{HAS_ENTITY_EDGE}]->(e:{ENTITY_LABEL})"
             f"-[r:{RELATION_EDGE}]->(t:{ENTITY_LABEL}) "
             f"WHERE id(m) = $nid RETURN e.name, r.relation_type, t.name"
         )

grafeo_memory-0.2.1/tests/conftest.py

@@ -0,0 +1,21 @@
+"""Pytest configuration for grafeo-memory tests."""
+
+import sys
+from pathlib import Path
+
+# Add tests directory to sys.path so mock_llm can be imported
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mock_llm import MockEmbedder, make_test_model
+
+from grafeo_memory import MemoryConfig, MemoryManager
+
+
+def make_manager(outputs, db_path=None, dims=16, **config_kwargs):
+    """Create a MemoryManager with mock model and specified db_path."""
+    model = make_test_model(outputs)
+    embedder = MockEmbedder(dims)
+    defaults = {"db_path": db_path, "user_id": "test_user", "embedding_dimensions": dims}
+    defaults.update(config_kwargs)
+    config = MemoryConfig(**defaults)  # type: ignore[invalid-argument-type]
+    return MemoryManager(model, config, embedder=embedder)

grafeo_memory-0.2.1/tests/test_concurrency.py

@@ -0,0 +1,119 @@
+"""Tests for concurrent add operations.
+
+Covers T7 (concurrent add for same user) and T8 (concurrent add for different users).
+
+Uses AsyncMemoryManager with asyncio.gather to test true concurrency,
+since the sync MemoryManager uses a shared asyncio.Runner that cannot
+handle concurrent calls from multiple threads.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from mock_llm import MockEmbedder, make_test_model
+
+from grafeo_memory import AsyncMemoryManager, MemoryConfig
+
+
+def _make_async_manager(dims=16, **config_kwargs):
+    """Create an AsyncMemoryManager with mock model and in-memory GrafeoDB."""
+    model = make_test_model([])
+    embedder = MockEmbedder(dims)
+    defaults = {"db_path": None, "user_id": "test_user", "embedding_dimensions": dims}
+    defaults.update(config_kwargs)
+    config = MemoryConfig(**defaults)  # type: ignore[invalid-argument-type]
+    return AsyncMemoryManager(model, config, embedder=embedder)
+
+
+class TestConcurrentAddSameUser:
+    """T7: concurrent add() calls for the same user_id should not corrupt data."""
+
+    def test_concurrent_adds_no_data_loss(self):
+        async def _run():
+            async with _make_async_manager() as manager:
+                user = "shared_user"
+                tasks = []
+                for thread_id in (1, 2):
+                    for i in range(5):
+                        tasks.append(manager.add(f"thread {thread_id} fact {i}", user_id=user, infer=False))
+                await asyncio.gather(*tasks)
+
+                memories = await manager.get_all(user_id=user)
+                # Both "threads" added 5 facts each, so we expect 10 total
+                assert len(memories) == 10
+                texts = sorted(m.text for m in memories)
+                # Verify no duplicates or missing entries
+                assert len(set(texts)) == 10
+
+        asyncio.run(_run())
+
+    def test_concurrent_adds_all_texts_present(self):
+        async def _run():
+            async with _make_async_manager() as manager:
+                user = "shared_user"
+                texts_to_add = [f"concurrent fact {i}" for i in range(10)]
+                tasks = [manager.add(t, user_id=user, infer=False) for t in texts_to_add]
+                await asyncio.gather(*tasks)
+
+                memories = await manager.get_all(user_id=user)
+                stored_texts = {m.text for m in memories}
+                for t in texts_to_add:
+                    assert t in stored_texts, f"Missing: {t}"
+
+        asyncio.run(_run())
+
+
+class TestConcurrentAddDifferentUsers:
+    """T8: concurrent adds for different users should not contaminate each other."""
+
+    def test_user_isolation_under_concurrency(self):
+        async def _run():
+            async with _make_async_manager() as manager:
+
+                async def add_for_user(user_id: str):
+                    for i in range(5):
+                        await manager.add(f"{user_id} fact {i}", user_id=user_id, infer=False)
+
+                await asyncio.gather(add_for_user("alice"), add_for_user("bob"))
+
+                alice_mems = await manager.get_all(user_id="alice")
+                bob_mems = await manager.get_all(user_id="bob")
+
+                assert len(alice_mems) == 5
+                assert len(bob_mems) == 5
+
+                # No cross-contamination
+                alice_texts = {m.text for m in alice_mems}
+                bob_texts = {m.text for m in bob_mems}
+                assert alice_texts.isdisjoint(bob_texts)
+
+                # Verify all alice facts mention alice
+                for t in alice_texts:
+                    assert t.startswith("alice")
+                for t in bob_texts:
+                    assert t.startswith("bob")
+
+        asyncio.run(_run())
+
+    def test_three_users_concurrent(self):
+        async def _run():
+            async with _make_async_manager() as manager:
+
+                async def add_for_user(user_id: str):
+                    for i in range(3):
+                        await manager.add(f"{user_id} item {i}", user_id=user_id, infer=False)
+
+                await asyncio.gather(
+                    add_for_user("alice"),
+                    add_for_user("bob"),
+                    add_for_user("carol"),
+                )
+
+                for user_id in ("alice", "bob", "carol"):
+                    mems = await manager.get_all(user_id=user_id)
+                    assert len(mems) == 3
+                    for m in mems:
+                        assert m.text.startswith(user_id)
+
+        asyncio.run(_run())