mnemo-mcp 2.2.2b1__tar.gz → 2.2.2b2__tar.gz

{mnemo_mcp-2.2.2b1 → mnemo_mcp-2.2.2b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnemo-mcp
-Version: 2.2.2b1
+Version: 2.2.2b2
 Summary: Open-source MCP Server for persistent AI memory with embedded sync
 Project-URL: Homepage, https://github.com/n24q02m/mnemo-mcp
 Project-URL: Repository, https://github.com/n24q02m/mnemo-mcp.git

{mnemo_mcp-2.2.2b1 → mnemo_mcp-2.2.2b2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mnemo-mcp"
-version = "2.2.2-beta.1"
+version = "2.2.2-beta.2"
 description = "Open-source MCP Server for persistent AI memory with embedded sync"
 readme = "README.md"
 license = { text = "MIT" }

{mnemo_mcp-2.2.2b1 → mnemo_mcp-2.2.2b2}/src/mnemo_mcp/graph.py

@@ -305,7 +305,7 @@ def create_relations(
 
 def link_memory_entities(conn, memory_id: str, entity_ids: list[str]) -> None:
     """Link a memory to entities."""
-    if not entity_ids:
+    if not memory_id or not memory_id.strip() or not entity_ids:
         return
 
     try:

{mnemo_mcp-2.2.2b1 → mnemo_mcp-2.2.2b2}/src/mnemo_mcp/server.py

@@ -2146,6 +2146,14 @@ def save_summary(summary: str) -> str:
     - Use when a conversation is concluding or shifting topics to persist key takeaways.
     - Parameters: 'summary' (the consolidated text to save).
     """
+    if not summary or not summary.strip():
+        return _json(
+            {
+                "error": "Summary cannot be empty",
+                "suggestion": "Provide a concise summary of the conversation to save as memory.",
+            }
+        )
+
     return (
         f"Save this conversation summary as a memory:\n\n{summary}\n\n"
         "Use the memory tool with action='add', category='context', "
@@ -2161,6 +2169,14 @@ def recall_context(topic: str) -> str:
     - Use when starting a new task or answering a question to retrieve prior context.
     - Parameters: 'topic' (the specific subject or keywords to search for).
     """
+    if not topic or not topic.strip():
+        return _json(
+            {
+                "error": "Topic cannot be empty",
+                "suggestion": "Provide a specific topic or keyword to search for in your memories.",
+            }
+        )
+
     return (
         f"Search your memories for relevant context about: {topic}\n\n"
         "Use the memory tool with action='search' and this query. "

{mnemo_mcp-2.2.2b1 → mnemo_mcp-2.2.2b2}/src/mnemo_mcp/sync/delta.py

@@ -269,46 +269,50 @@ def _apply_kg_sections(db: MemoryDB, payload: dict[str, bytes]) -> dict:
     cursor = db._conn.cursor()
 
     ents_raw = payload.get("memories_entities.jsonl", b"").decode("utf-8")
+    entities_list = []
     for line in ents_raw.splitlines():
         line = line.strip()
         if not line:
             continue
         try:
             ent = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        try:
-            cursor.execute(
-                "INSERT OR IGNORE INTO memory_entities "
-                "(id, name, entity_type, created_at, updated_at) "
-                "VALUES (?, ?, ?, ?, ?)",
+            if not isinstance(ent, dict):
+                continue
+            entities_list.append(
                 (
                     ent.get("id"),
                     ent.get("name"),
                     ent.get("entity_type"),
                     ent.get("created_at"),
                     ent.get("updated_at"),
-                ),
+                )
+            )
+        except (json.JSONDecodeError, AttributeError):
+            continue
+
+    if entities_list:
+        try:
+            cursor.executemany(
+                "INSERT OR IGNORE INTO memory_entities "
+                "(id, name, entity_type, created_at, updated_at) "
+                "VALUES (?, ?, ?, ?, ?)",
+                entities_list,
             )
             counts["entities_applied"] += cursor.rowcount or 0
         except Exception as e:
-            logger.debug(f"apply_bundle: entity skipped ({e})")
+            logger.debug(f"apply_bundle: entities skipped ({e})")
 
     edges_raw = payload.get("memories_edges.jsonl", b"").decode("utf-8")
+    edges_list = []
     for line in edges_raw.splitlines():
         line = line.strip()
         if not line:
             continue
         try:
             edge = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        try:
-            cursor.execute(
-                "INSERT OR IGNORE INTO memory_edges "
-                "(id, source_id, target_id, relation_type, created_at, "
-                " memory_id, valid_from, valid_to) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+            if not isinstance(edge, dict):
+                continue
+            edges_list.append(
                 (
                     edge.get("id"),
                     edge.get("source_id"),
@@ -318,30 +322,48 @@ def _apply_kg_sections(db: MemoryDB, payload: dict[str, bytes]) -> dict:
                     edge.get("memory_id"),
                     edge.get("valid_from"),
                     edge.get("valid_to"),
-                ),
+                )
+            )
+        except (json.JSONDecodeError, AttributeError):
+            continue
+
+    if edges_list:
+        try:
+            cursor.executemany(
+                "INSERT OR IGNORE INTO memory_edges "
+                "(id, source_id, target_id, relation_type, created_at, "
+                " memory_id, valid_from, valid_to) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                edges_list,
             )
             counts["edges_applied"] += cursor.rowcount or 0
         except Exception as e:
-            logger.debug(f"apply_bundle: edge skipped ({e})")
+            logger.debug(f"apply_bundle: edges skipped ({e})")
 
     links_raw = payload.get("memories_entity_links.jsonl", b"").decode("utf-8")
+    links_list = []
     for line in links_raw.splitlines():
         line = line.strip()
         if not line:
             continue
         try:
             link = json.loads(line)
-        except json.JSONDecodeError:
+            if not isinstance(link, dict):
+                continue
+            links_list.append((link.get("memory_id"), link.get("entity_id")))
+        except (json.JSONDecodeError, AttributeError):
             continue
+
+    if links_list:
         try:
-            cursor.execute(
+            cursor.executemany(
                 "INSERT OR IGNORE INTO memory_entity_links "
                 "(memory_id, entity_id) VALUES (?, ?)",
-                (link.get("memory_id"), link.get("entity_id")),
+                links_list,
             )
             counts["links_applied"] += cursor.rowcount or 0
         except Exception as e:
-            logger.debug(f"apply_bundle: link skipped ({e})")
+            logger.debug(f"apply_bundle: links skipped ({e})")
 
     db._conn.commit()
     return counts